Moving VR cameras to VR folder

Adding all .d.ts files

Babylon/.gitignore

@@ -1 +0,0 @@
-*.d.ts

Babylon/Actions/babylon.action.d.ts

@@ -0,0 +1,19 @@
+declare module BABYLON {
+    class Action {
+        public triggerOptions: any;
+        public trigger: number;
+        public _actionManager: ActionManager;
+        private _nextActiveAction;
+        private _child;
+        private _condition;
+        private _triggerParameter;
+        constructor(triggerOptions: any, condition?: Condition);
+        public _prepare(): void;
+        public getTriggerParameter(): any;
+        public _executeCurrent(evt: ActionEvent): void;
+        public execute(evt: ActionEvent): void;
+        public then(action: Action): Action;
+        public _getProperty(propertyPath: string): string;
+        public _getEffectiveTarget(target: any, propertyPath: string): any;
+    }
+}

Babylon/Actions/babylon.actionManager.d.ts

@@ -0,0 +1,50 @@
+declare module BABYLON {
+    class ActionEvent {
+        public source: AbstractMesh;
+        public pointerX: number;
+        public pointerY: number;
+        public meshUnderPointer: AbstractMesh;
+        public sourceEvent: any;
+        constructor(source: AbstractMesh, pointerX: number, pointerY: number, meshUnderPointer: AbstractMesh, sourceEvent?: any);
+        static CreateNew(source: AbstractMesh, evt?: Event): ActionEvent;
+        static CreateNewFromScene(scene: Scene, evt: Event): ActionEvent;
+    }
+    class ActionManager {
+        private static _NothingTrigger;
+        private static _OnPickTrigger;
+        private static _OnLeftPickTrigger;
+        private static _OnRightPickTrigger;
+        private static _OnCenterPickTrigger;
+        private static _OnPointerOverTrigger;
+        private static _OnPointerOutTrigger;
+        private static _OnEveryFrameTrigger;
+        private static _OnIntersectionEnterTrigger;
+        private static _OnIntersectionExitTrigger;
+        private static _OnKeyDownTrigger;
+        private static _OnKeyUpTrigger;
+        static NothingTrigger : number;
+        static OnPickTrigger : number;
+        static OnLeftPickTrigger : number;
+        static OnRightPickTrigger : number;
+        static OnCenterPickTrigger : number;
+        static OnPointerOverTrigger : number;
+        static OnPointerOutTrigger : number;
+        static OnEveryFrameTrigger : number;
+        static OnIntersectionEnterTrigger : number;
+        static OnIntersectionExitTrigger : number;
+        static OnKeyDownTrigger : number;
+        static OnKeyUpTrigger : number;
+        public actions: Action[];
+        private _scene;
+        constructor(scene: Scene);
+        public dispose(): void;
+        public getScene(): Scene;
+        public hasSpecificTriggers(triggers: number[]): boolean;
+        public hasPointerTriggers : boolean;
+        public hasPickTriggers : boolean;
+        public registerAction(action: Action): Action;
+        public processTrigger(trigger: number, evt: ActionEvent): void;
+        public _getEffectiveTarget(target: any, propertyPath: string): any;
+        public _getProperty(propertyPath: string): string;
+    }
+}

Babylon/Actions/babylon.condition.d.ts

@@ -0,0 +1,42 @@
+declare module BABYLON {
+    class Condition {
+        public _actionManager: ActionManager;
+        public _evaluationId: number;
+        public _currentResult: boolean;
+        constructor(actionManager: ActionManager);
+        public isValid(): boolean;
+        public _getProperty(propertyPath: string): string;
+        public _getEffectiveTarget(target: any, propertyPath: string): any;
+    }
+    class ValueCondition extends Condition {
+        public propertyPath: string;
+        public value: any;
+        public operator: number;
+        private static _IsEqual;
+        private static _IsDifferent;
+        private static _IsGreater;
+        private static _IsLesser;
+        static IsEqual : number;
+        static IsDifferent : number;
+        static IsGreater : number;
+        static IsLesser : number;
+        public _actionManager: ActionManager;
+        private _target;
+        private _property;
+        constructor(actionManager: ActionManager, target: any, propertyPath: string, value: any, operator?: number);
+        public isValid(): boolean;
+    }
+    class PredicateCondition extends Condition {
+        public predicate: () => boolean;
+        public _actionManager: ActionManager;
+        constructor(actionManager: ActionManager, predicate: () => boolean);
+        public isValid(): boolean;
+    }
+    class StateCondition extends Condition {
+        public value: string;
+        public _actionManager: ActionManager;
+        private _target;
+        constructor(actionManager: ActionManager, target: any, value: string);
+        public isValid(): boolean;
+    }
+}

Babylon/Actions/babylon.directActions.d.ts

@@ -0,0 +1,71 @@
+declare module BABYLON {
+    class SwitchBooleanAction extends Action {
+        public propertyPath: string;
+        private _target;
+        private _property;
+        constructor(triggerOptions: any, target: any, propertyPath: string, condition?: Condition);
+        public _prepare(): void;
+        public execute(): void;
+    }
+    class SetStateAction extends Action {
+        public value: string;
+        private _target;
+        constructor(triggerOptions: any, target: any, value: string, condition?: Condition);
+        public execute(): void;
+    }
+    class SetValueAction extends Action {
+        public propertyPath: string;
+        public value: any;
+        private _target;
+        private _property;
+        constructor(triggerOptions: any, target: any, propertyPath: string, value: any, condition?: Condition);
+        public _prepare(): void;
+        public execute(): void;
+    }
+    class IncrementValueAction extends Action {
+        public propertyPath: string;
+        public value: any;
+        private _target;
+        private _property;
+        constructor(triggerOptions: any, target: any, propertyPath: string, value: any, condition?: Condition);
+        public _prepare(): void;
+        public execute(): void;
+    }
+    class PlayAnimationAction extends Action {
+        public from: number;
+        public to: number;
+        public loop: boolean;
+        private _target;
+        constructor(triggerOptions: any, target: any, from: number, to: number, loop?: boolean, condition?: Condition);
+        public _prepare(): void;
+        public execute(): void;
+    }
+    class StopAnimationAction extends Action {
+        private _target;
+        constructor(triggerOptions: any, target: any, condition?: Condition);
+        public _prepare(): void;
+        public execute(): void;
+    }
+    class DoNothingAction extends Action {
+        constructor(triggerOptions?: any, condition?: Condition);
+        public execute(): void;
+    }
+    class CombineAction extends Action {
+        public children: Action[];
+        constructor(triggerOptions: any, children: Action[], condition?: Condition);
+        public _prepare(): void;
+        public execute(evt: ActionEvent): void;
+    }
+    class ExecuteCodeAction extends Action {
+        public func: (evt: ActionEvent) => void;
+        constructor(triggerOptions: any, func: (evt: ActionEvent) => void, condition?: Condition);
+        public execute(evt: ActionEvent): void;
+    }
+    class SetParentAction extends Action {
+        private _parent;
+        private _target;
+        constructor(triggerOptions: any, target: any, parent: any, condition?: Condition);
+        public _prepare(): void;
+        public execute(): void;
+    }
+}

Babylon/Actions/babylon.interpolateValueAction.d.ts

@@ -0,0 +1,13 @@
+declare module BABYLON {
+    class InterpolateValueAction extends Action {
+        public propertyPath: string;
+        public value: any;
+        public duration: number;
+        public stopOtherAnimations: boolean;
+        private _target;
+        private _property;
+        constructor(triggerOptions: any, target: any, propertyPath: string, value: any, duration?: number, condition?: Condition, stopOtherAnimations?: boolean);
+        public _prepare(): void;
+        public execute(): void;
+    }
+}

Babylon/Animations/babylon.animatable.d.ts

@@ -0,0 +1,23 @@
+declare module BABYLON {
+    class Animatable {
+        public target: any;
+        public fromFrame: number;
+        public toFrame: number;
+        public loopAnimation: boolean;
+        public speedRatio: number;
+        public onAnimationEnd: any;
+        private _localDelayOffset;
+        private _pausedDelay;
+        private _animations;
+        private _paused;
+        private _scene;
+        public animationStarted: boolean;
+        constructor(scene: Scene, target: any, fromFrame?: number, toFrame?: number, loopAnimation?: boolean, speedRatio?: number, onAnimationEnd?: any, animations?: any);
+        public appendAnimations(target: any, animations: Animation[]): void;
+        public getAnimationByTargetProperty(property: string): Animation;
+        public pause(): void;
+        public restart(): void;
+        public stop(): void;
+        public _animate(delay: number): boolean;
+    }
+}

Babylon/Animations/babylon.animation.d.ts

@@ -0,0 +1,50 @@
+declare module BABYLON {
+    class Animation {
+        public name: string;
+        public targetProperty: string;
+        public framePerSecond: number;
+        public dataType: number;
+        public loopMode: number;
+        private _keys;
+        private _offsetsCache;
+        private _highLimitsCache;
+        private _stopped;
+        public _target: any;
+        private _easingFunction;
+        public targetPropertyPath: string[];
+        public currentFrame: number;
+        static CreateAndStartAnimation(name: string, mesh: AbstractMesh, tartgetProperty: string, framePerSecond: number, totalFrame: number, from: any, to: any, loopMode?: number): void;
+        constructor(name: string, targetProperty: string, framePerSecond: number, dataType: number, loopMode?: number);
+        public isStopped(): boolean;
+        public getKeys(): any[];
+        public getEasingFunction(): IEasingFunction;
+        public setEasingFunction(easingFunction: EasingFunction): void;
+        public floatInterpolateFunction(startValue: number, endValue: number, gradient: number): number;
+        public quaternionInterpolateFunction(startValue: Quaternion, endValue: Quaternion, gradient: number): Quaternion;
+        public vector3InterpolateFunction(startValue: Vector3, endValue: Vector3, gradient: number): Vector3;
+        public vector2InterpolateFunction(startValue: Vector2, endValue: Vector2, gradient: number): Vector2;
+        public color3InterpolateFunction(startValue: Color3, endValue: Color3, gradient: number): Color3;
+        public clone(): Animation;
+        public setKeys(values: any[]): void;
+        private _interpolate(currentFrame, repeatCount, loopMode, offsetValue?, highLimitValue?);
+        public animate(delay: number, from: number, to: number, loop: boolean, speedRatio: number): boolean;
+        private static _ANIMATIONTYPE_FLOAT;
+        private static _ANIMATIONTYPE_VECTOR3;
+        private static _ANIMATIONTYPE_QUATERNION;
+        private static _ANIMATIONTYPE_MATRIX;
+        private static _ANIMATIONTYPE_COLOR3;
+        private static _ANIMATIONTYPE_VECTOR2;
+        private static _ANIMATIONLOOPMODE_RELATIVE;
+        private static _ANIMATIONLOOPMODE_CYCLE;
+        private static _ANIMATIONLOOPMODE_CONSTANT;
+        static ANIMATIONTYPE_FLOAT : number;
+        static ANIMATIONTYPE_VECTOR3 : number;
+        static ANIMATIONTYPE_VECTOR2 : number;
+        static ANIMATIONTYPE_QUATERNION : number;
+        static ANIMATIONTYPE_MATRIX : number;
+        static ANIMATIONTYPE_COLOR3 : number;
+        static ANIMATIONLOOPMODE_RELATIVE : number;
+        static ANIMATIONLOOPMODE_CYCLE : number;
+        static ANIMATIONLOOPMODE_CONSTANT : number;
+    }
+}

Babylon/Animations/babylon.easing.d.ts

@@ -0,0 +1,71 @@
+declare module BABYLON {
+    interface IEasingFunction {
+        ease(gradient: number): number;
+    }
+    class EasingFunction implements IEasingFunction {
+        private static _EASINGMODE_EASEIN;
+        private static _EASINGMODE_EASEOUT;
+        private static _EASINGMODE_EASEINOUT;
+        static EASINGMODE_EASEIN : number;
+        static EASINGMODE_EASEOUT : number;
+        static EASINGMODE_EASEINOUT : number;
+        private _easingMode;
+        public setEasingMode(easingMode: number): void;
+        public getEasingMode(): number;
+        public easeInCore(gradient: number): number;
+        public ease(gradient: number): number;
+    }
+    class CircleEase extends EasingFunction implements IEasingFunction {
+        public easeInCore(gradient: number): number;
+    }
+    class BackEase extends EasingFunction implements IEasingFunction {
+        public amplitude: number;
+        constructor(amplitude?: number);
+        public easeInCore(gradient: number): number;
+    }
+    class BounceEase extends EasingFunction implements IEasingFunction {
+        public bounces: number;
+        public bounciness: number;
+        constructor(bounces?: number, bounciness?: number);
+        public easeInCore(gradient: number): number;
+    }
+    class CubicEase extends EasingFunction implements IEasingFunction {
+        public easeInCore(gradient: number): number;
+    }
+    class ElasticEase extends EasingFunction implements IEasingFunction {
+        public oscillations: number;
+        public springiness: number;
+        constructor(oscillations?: number, springiness?: number);
+        public easeInCore(gradient: number): number;
+    }
+    class ExponentialEase extends EasingFunction implements IEasingFunction {
+        public exponent: number;
+        constructor(exponent?: number);
+        public easeInCore(gradient: number): number;
+    }
+    class PowerEase extends EasingFunction implements IEasingFunction {
+        public power: number;
+        constructor(power?: number);
+        public easeInCore(gradient: number): number;
+    }
+    class QuadraticEase extends EasingFunction implements IEasingFunction {
+        public easeInCore(gradient: number): number;
+    }
+    class QuarticEase extends EasingFunction implements IEasingFunction {
+        public easeInCore(gradient: number): number;
+    }
+    class QuinticEase extends EasingFunction implements IEasingFunction {
+        public easeInCore(gradient: number): number;
+    }
+    class SineEase extends EasingFunction implements IEasingFunction {
+        public easeInCore(gradient: number): number;
+    }
+    class BezierCurveEase extends EasingFunction implements IEasingFunction {
+        public x1: number;
+        public y1: number;
+        public x2: number;
+        public y2: number;
+        constructor(x1?: number, y1?: number, x2?: number, y2?: number);
+        public easeInCore(gradient: number): number;
+    }
+}

Babylon/Audio/babylon.audioengine.d.ts

@@ -0,0 +1,10 @@
+declare module BABYLON {
+    class AudioEngine {
+        public audioContext: AudioContext;
+        public canUseWebAudio: boolean;
+        public masterGain: GainNode;
+        constructor();
+        public getGlobalVolume(): number;
+        public setGlobalVolume(newVolume: number): void;
+    }
+}

Babylon/Audio/babylon.sound.d.ts

@@ -0,0 +1,64 @@
+declare module BABYLON {
+    class Sound {
+        public maxDistance: number;
+        public autoplay: boolean;
+        public loop: boolean;
+        public useBabylonJSAttenuation: boolean;
+        public soundTrackId: number;
+        private _position;
+        private _localDirection;
+        private _volume;
+        private _isLoaded;
+        private _isReadyToPlay;
+        private _isPlaying;
+        private _isDirectional;
+        private _audioEngine;
+        private _readyToPlayCallback;
+        private _audioBuffer;
+        private _soundSource;
+        private _soundPanner;
+        private _soundGain;
+        private _coneInnerAngle;
+        private _coneOuterAngle;
+        private _coneOuterGain;
+        private _scene;
+        private _name;
+        private _connectedMesh;
+        /**
+        * Create a sound and attach it to a scene
+        * @param name Name of your sound
+        * @param url Url to the sound to load async
+        * @param readyToPlayCallback Provide a callback function if you'd like to load your code once the sound is ready to be played
+        * @param options Objects to provide with the current available options: autoplay, loop, distanceMax
+        */
+        constructor(name: string, url: string, scene: Scene, readyToPlayCallback?: () => void, options?: any);
+        public connectToSoundTrackAudioNode(soundTrackAudioNode: AudioNode): void;
+        /**
+        * Transform this sound into a directional source
+        * @param coneInnerAngle Size of the inner cone in degree
+        * @param coneOuterAngle Size of the outer cone in degree
+        * @param coneOuterGain Volume of the sound outside the outer cone (between 0.0 and 1.0)
+        */
+        public setDirectionalCone(coneInnerAngle: number, coneOuterAngle: number, coneOuterGain: number): void;
+        public setPosition(newPosition: Vector3): void;
+        public setLocalDirectionToMesh(newLocalDirection: Vector3): void;
+        private _updateDirection();
+        public updateDistanceFromListener(): void;
+        /**
+        * Play the sound
+        * @param time (optional) Start the sound after X seconds. Start immediately (0) by default.
+        */
+        public play(time?: number): void;
+        /**
+        * Stop the sound
+        * @param time (optional) Stop the sound after X seconds. Stop immediately (0) by default.
+        */
+        public stop(time?: number): void;
+        public pause(): void;
+        public setVolume(newVolume: number): void;
+        public getVolume(): number;
+        public attachToMesh(meshToConnectTo: AbstractMesh): void;
+        private _onRegisterAfterWorldMatrixUpdate(connectedMesh);
+        private _soundLoaded(audioData);
+    }
+}

Babylon/Audio/babylon.soundtrack.d.ts

@@ -0,0 +1,15 @@
+declare module BABYLON {
+    class SoundTrack {
+        private _audioEngine;
+        private _trackGain;
+        private _trackConvolver;
+        private _scene;
+        public id: number;
+        public soundCollection: Sound[];
+        private _isMainTrack;
+        constructor(scene: Scene, options?: any);
+        public AddSound(sound: Sound): void;
+        public RemoveSound(sound: Sound): void;
+        public setVolume(newVolume: number): void;
+    }
+}

Babylon/Bones/babylon.bone.d.ts

@@ -0,0 +1,24 @@
+declare module BABYLON {
+    class Bone {
+        public name: string;
+        public children: Bone[];
+        public animations: Animation[];
+        private _skeleton;
+        private _matrix;
+        private _baseMatrix;
+        private _worldTransform;
+        private _absoluteTransform;
+        private _invertedAbsoluteTransform;
+        private _parent;
+        constructor(name: string, skeleton: Skeleton, parentBone: Bone, matrix: Matrix);
+        public getParent(): Bone;
+        public getLocalMatrix(): Matrix;
+        public getBaseMatrix(): Matrix;
+        public getWorldMatrix(): Matrix;
+        public getInvertedAbsoluteTransform(): Matrix;
+        public getAbsoluteMatrix(): Matrix;
+        public updateMatrix(matrix: Matrix): void;
+        private _updateDifferenceMatrix();
+        public markAsDirty(): void;
+    }
+}

Babylon/Bones/babylon.skeleton.d.ts

@@ -0,0 +1,18 @@
+declare module BABYLON {
+    class Skeleton {
+        public name: string;
+        public id: string;
+        public bones: Bone[];
+        private _scene;
+        private _isDirty;
+        private _transformMatrices;
+        private _animatables;
+        private _identity;
+        constructor(name: string, id: string, scene: Scene);
+        public getTransformMatrices(): Float32Array;
+        public _markAsDirty(): void;
+        public prepare(): void;
+        public getAnimatables(): IAnimatable[];
+        public clone(name: string, id: string): Skeleton;
+    }
+}

Babylon/Cameras/VR/babylon.oculusCamera.d.ts

@@ -0,0 +1,14 @@
+declare module BABYLON {
+    class OculusCamera extends FreeCamera {
+        private _leftCamera;
+        private _rightCamera;
+        private _offsetOrientation;
+        private _deviceOrientationHandler;
+        constructor(name: string, position: Vector3, scene: Scene);
+        public _update(): void;
+        public _updateCamera(camera: FreeCamera): void;
+        public _onOrientationEvent(evt: DeviceOrientationEvent): void;
+        public attachControl(element: HTMLElement, noPreventDefault?: boolean): void;
+        public detachControl(element: HTMLElement): void;
+    }
+}

Babylon/Cameras/VR/babylon.oculusCamera.js

@@ -0,0 +1,141 @@
+var __extends = this.__extends || function (d, b) {
+    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
+    function __() { this.constructor = d; }
+    __.prototype = b.prototype;
+    d.prototype = new __();
+};
+var BABYLON;
+(function (BABYLON) {
+    var OculusRiftDevKit2013_Metric = {
+        HResolution: 1280,
+        VResolution: 800,
+        HScreenSize: 0.149759993,
+        VScreenSize: 0.0935999975,
+        VScreenCenter: 0.0467999987,
+        EyeToScreenDistance: 0.0410000011,
+        LensSeparationDistance: 0.0635000020,
+        InterpupillaryDistance: 0.0640000030,
+        DistortionK: [1.0, 0.219999999, 0.239999995, 0.0],
+        ChromaAbCorrection: [0.995999992, -0.00400000019, 1.01400006, 0.0],
+        PostProcessScaleFactor: 1.714605507808412,
+        LensCenterOffset: 0.151976421
+    };
+
+    var _OculusInnerCamera = (function (_super) {
+        __extends(_OculusInnerCamera, _super);
+        function _OculusInnerCamera(name, position, scene, isLeftEye) {
+            _super.call(this, name, position, scene);
+            this._workMatrix = new BABYLON.Matrix();
+            this._actualUp = new BABYLON.Vector3(0, 0, 0);
+
+            // Constants
+            this._aspectRatioAspectRatio = OculusRiftDevKit2013_Metric.HResolution / (2 * OculusRiftDevKit2013_Metric.VResolution);
+            this._aspectRatioFov = (2 * Math.atan((OculusRiftDevKit2013_Metric.PostProcessScaleFactor * OculusRiftDevKit2013_Metric.VScreenSize) / (2 * OculusRiftDevKit2013_Metric.EyeToScreenDistance)));
+
+            var hMeters = (OculusRiftDevKit2013_Metric.HScreenSize / 4) - (OculusRiftDevKit2013_Metric.LensSeparationDistance / 2);
+            var h = (4 * hMeters) / OculusRiftDevKit2013_Metric.HScreenSize;
+
+            this._hMatrix = BABYLON.Matrix.Translation(isLeftEye ? h : -h, 0, 0);
+
+            this.viewport = new BABYLON.Viewport(isLeftEye ? 0 : 0.5, 0, 0.5, 1.0);
+
+            this._preViewMatrix = BABYLON.Matrix.Translation(isLeftEye ? .5 * OculusRiftDevKit2013_Metric.InterpupillaryDistance : -.5 * OculusRiftDevKit2013_Metric.InterpupillaryDistance, 0, 0);
+
+            // Postprocess
+            var postProcess = new BABYLON.OculusDistortionCorrectionPostProcess("Oculus Distortion", this, !isLeftEye, OculusRiftDevKit2013_Metric);
+        }
+        _OculusInnerCamera.prototype.getProjectionMatrix = function () {
+            BABYLON.Matrix.PerspectiveFovLHToRef(this._aspectRatioFov, this._aspectRatioAspectRatio, this.minZ, this.maxZ, this._workMatrix);
+            this._workMatrix.multiplyToRef(this._hMatrix, this._projectionMatrix);
+            return this._projectionMatrix;
+        };
+
+        _OculusInnerCamera.prototype._getViewMatrix = function () {
+            BABYLON.Matrix.RotationYawPitchRollToRef(this.rotation.y, this.rotation.x, this.rotation.z, this._cameraRotationMatrix);
+
+            BABYLON.Vector3.TransformCoordinatesToRef(this._referencePoint, this._cameraRotationMatrix, this._transformedReferencePoint);
+            BABYLON.Vector3.TransformNormalToRef(this.upVector, this._cameraRotationMatrix, this._actualUp);
+
+            // Computing target and final matrix
+            this.position.addToRef(this._transformedReferencePoint, this._currentTarget);
+
+            BABYLON.Matrix.LookAtLHToRef(this.position, this._currentTarget, this._actualUp, this._workMatrix);
+
+            this._workMatrix.multiplyToRef(this._preViewMatrix, this._viewMatrix);
+            return this._viewMatrix;
+        };
+        return _OculusInnerCamera;
+    })(BABYLON.FreeCamera);
+
+    var OculusCamera = (function (_super) {
+        __extends(OculusCamera, _super);
+        function OculusCamera(name, position, scene) {
+            _super.call(this, name, position, scene);
+
+            this._leftCamera = new _OculusInnerCamera(name + "_left", position.clone(), scene, true);
+            this._rightCamera = new _OculusInnerCamera(name + "_right", position.clone(), scene, false);
+
+            this.subCameras.push(this._leftCamera);
+            this.subCameras.push(this._rightCamera);
+
+            this._deviceOrientationHandler = this._onOrientationEvent.bind(this);
+        }
+        OculusCamera.prototype._update = function () {
+            this._leftCamera.position.copyFrom(this.position);
+            this._rightCamera.position.copyFrom(this.position);
+
+            this._updateCamera(this._leftCamera);
+            this._updateCamera(this._rightCamera);
+
+            _super.prototype._update.call(this);
+        };
+
+        OculusCamera.prototype._updateCamera = function (camera) {
+            camera.minZ = this.minZ;
+            camera.maxZ = this.maxZ;
+
+            camera.rotation.x = this.rotation.x;
+            camera.rotation.y = this.rotation.y;
+            camera.rotation.z = this.rotation.z;
+        };
+
+        // Oculus events
+        OculusCamera.prototype._onOrientationEvent = function (evt) {
+            var yaw = evt.alpha / 180 * Math.PI;
+            var pitch = evt.beta / 180 * Math.PI;
+            var roll = evt.gamma / 180 * Math.PI;
+
+            if (!this._offsetOrientation) {
+                this._offsetOrientation = {
+                    yaw: yaw,
+                    pitch: pitch,
+                    roll: roll
+                };
+                return;
+            } else {
+                this.rotation.y += yaw - this._offsetOrientation.yaw;
+                this.rotation.x += pitch - this._offsetOrientation.pitch;
+                this.rotation.z += this._offsetOrientation.roll - roll;
+
+                this._offsetOrientation.yaw = yaw;
+                this._offsetOrientation.pitch = pitch;
+                this._offsetOrientation.roll = roll;
+            }
+        };
+
+        OculusCamera.prototype.attachControl = function (element, noPreventDefault) {
+            _super.prototype.attachControl.call(this, element, noPreventDefault);
+
+            window.addEventListener("deviceorientation", this._deviceOrientationHandler);
+        };
+
+        OculusCamera.prototype.detachControl = function (element) {
+            _super.prototype.detachControl.call(this, element);
+
+            window.removeEventListener("deviceorientation", this._deviceOrientationHandler);
+        };
+        return OculusCamera;
+    })(BABYLON.FreeCamera);
+    BABYLON.OculusCamera = OculusCamera;
+})(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.oculusCamera.js.map

Babylon/Cameras/VR/babylon.oculusGamepadCamera.d.ts

@@ -0,0 +1,21 @@
+declare module BABYLON {
+    class OculusGamepadCamera extends FreeCamera {
+        private _leftCamera;
+        private _rightCamera;
+        private _offsetOrientation;
+        private _deviceOrientationHandler;
+        private _gamepad;
+        private _gamepads;
+        public angularSensibility: number;
+        public moveSensibility: number;
+        constructor(name: string, position: Vector3, scene: Scene);
+        private _onNewGameConnected(gamepad);
+        public _update(): void;
+        public _checkInputs(): void;
+        public _updateCamera(camera: FreeCamera): void;
+        public _onOrientationEvent(evt: DeviceOrientationEvent): void;
+        public attachControl(element: HTMLElement, noPreventDefault?: boolean): void;
+        public detachControl(element: HTMLElement): void;
+        public dispose(): void;
+    }
+}

Babylon/Cameras/VR/babylon.oculusGamepadCamera.js

@@ -0,0 +1,175 @@
+var __extends = this.__extends || function (d, b) {
+    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
+    function __() { this.constructor = d; }
+    __.prototype = b.prototype;
+    d.prototype = new __();
+};
+var BABYLON;
+(function (BABYLON) {
+    var OculusRiftDevKit2013_Metric = {
+        HResolution: 1280,
+        VResolution: 800,
+        HScreenSize: 0.149759993,
+        VScreenSize: 0.0935999975,
+        VScreenCenter: 0.0467999987,
+        EyeToScreenDistance: 0.0410000011,
+        LensSeparationDistance: 0.0635000020,
+        InterpupillaryDistance: 0.0640000030,
+        DistortionK: [1.0, 0.219999999, 0.239999995, 0.0],
+        ChromaAbCorrection: [0.995999992, -0.00400000019, 1.01400006, 0.0],
+        PostProcessScaleFactor: 1.714605507808412,
+        LensCenterOffset: 0.151976421
+    };
+
+    var _OculusInnerGamepadCamera = (function (_super) {
+        __extends(_OculusInnerGamepadCamera, _super);
+        function _OculusInnerGamepadCamera(name, position, scene, isLeftEye) {
+            _super.call(this, name, position, scene);
+            this._workMatrix = new BABYLON.Matrix();
+            this._actualUp = new BABYLON.Vector3(0, 0, 0);
+
+            // Constants
+            this._aspectRatioAspectRatio = OculusRiftDevKit2013_Metric.HResolution / (2 * OculusRiftDevKit2013_Metric.VResolution);
+            this._aspectRatioFov = (2 * Math.atan((OculusRiftDevKit2013_Metric.PostProcessScaleFactor * OculusRiftDevKit2013_Metric.VScreenSize) / (2 * OculusRiftDevKit2013_Metric.EyeToScreenDistance)));
+
+            var hMeters = (OculusRiftDevKit2013_Metric.HScreenSize / 4) - (OculusRiftDevKit2013_Metric.LensSeparationDistance / 2);
+            var h = (4 * hMeters) / OculusRiftDevKit2013_Metric.HScreenSize;
+
+            this._hMatrix = BABYLON.Matrix.Translation(isLeftEye ? h : -h, 0, 0);
+
+            this.viewport = new BABYLON.Viewport(isLeftEye ? 0 : 0.5, 0, 0.5, 1.0);
+
+            this._preViewMatrix = BABYLON.Matrix.Translation(isLeftEye ? .5 * OculusRiftDevKit2013_Metric.InterpupillaryDistance : -.5 * OculusRiftDevKit2013_Metric.InterpupillaryDistance, 0, 0);
+
+            // Postprocess
+            var postProcess = new BABYLON.OculusDistortionCorrectionPostProcess("Oculus Distortion", this, !isLeftEye, OculusRiftDevKit2013_Metric);
+        }
+        _OculusInnerGamepadCamera.prototype.getProjectionMatrix = function () {
+            BABYLON.Matrix.PerspectiveFovLHToRef(this._aspectRatioFov, this._aspectRatioAspectRatio, this.minZ, this.maxZ, this._workMatrix);
+            this._workMatrix.multiplyToRef(this._hMatrix, this._projectionMatrix);
+            return this._projectionMatrix;
+        };
+
+        _OculusInnerGamepadCamera.prototype._getViewMatrix = function () {
+            BABYLON.Matrix.RotationYawPitchRollToRef(this.rotation.y, this.rotation.x, this.rotation.z, this._cameraRotationMatrix);
+
+            BABYLON.Vector3.TransformCoordinatesToRef(this._referencePoint, this._cameraRotationMatrix, this._transformedReferencePoint);
+            BABYLON.Vector3.TransformNormalToRef(this.upVector, this._cameraRotationMatrix, this._actualUp);
+
+            // Computing target and final matrix
+            this.position.addToRef(this._transformedReferencePoint, this._currentTarget);
+
+            BABYLON.Matrix.LookAtLHToRef(this.position, this._currentTarget, this._actualUp, this._workMatrix);
+
+            this._workMatrix.multiplyToRef(this._preViewMatrix, this._viewMatrix);
+            return this._viewMatrix;
+        };
+        return _OculusInnerGamepadCamera;
+    })(BABYLON.FreeCamera);
+
+    var OculusGamepadCamera = (function (_super) {
+        __extends(OculusGamepadCamera, _super);
+        function OculusGamepadCamera(name, position, scene) {
+            var _this = this;
+            _super.call(this, name, position, scene);
+            this.angularSensibility = 200;
+            this.moveSensibility = 75;
+
+            this._leftCamera = new _OculusInnerGamepadCamera(name + "_left", position.clone(), scene, true);
+            this._rightCamera = new _OculusInnerGamepadCamera(name + "_right", position.clone(), scene, false);
+
+            this.subCameras.push(this._leftCamera);
+            this.subCameras.push(this._rightCamera);
+
+            this._deviceOrientationHandler = this._onOrientationEvent.bind(this);
+            this._gamepads = new BABYLON.Gamepads(function (gamepad) {
+                _this._onNewGameConnected(gamepad);
+            });
+        }
+        OculusGamepadCamera.prototype._onNewGameConnected = function (gamepad) {
+            // Only the first gamepad can control the camera
+            if (gamepad.index === 0) {
+                this._gamepad = gamepad;
+            }
+        };
+
+        OculusGamepadCamera.prototype._update = function () {
+            this._leftCamera.position.copyFrom(this.position);
+            this._rightCamera.position.copyFrom(this.position);
+
+            this._updateCamera(this._leftCamera);
+            this._updateCamera(this._rightCamera);
+
+            _super.prototype._update.call(this);
+        };
+
+        OculusGamepadCamera.prototype._checkInputs = function () {
+            if (!this._gamepad) {
+                return;
+            }
+
+            var LSValues = this._gamepad.leftStick;
+            var normalizedLX = LSValues.x / this.moveSensibility;
+            var normalizedLY = LSValues.y / this.moveSensibility;
+            LSValues.x = Math.abs(normalizedLX) > 0.005 ? 0 + normalizedLX : 0;
+            LSValues.y = Math.abs(normalizedLY) > 0.005 ? 0 + normalizedLY : 0;
+
+            var cameraTransform = BABYLON.Matrix.RotationYawPitchRoll(this.rotation.y, this.rotation.x, 0);
+            var deltaTransform = BABYLON.Vector3.TransformCoordinates(new BABYLON.Vector3(LSValues.x, 0, -LSValues.y), cameraTransform);
+            this.cameraDirection = this.cameraDirection.add(deltaTransform);
+        };
+
+        OculusGamepadCamera.prototype._updateCamera = function (camera) {
+            camera.minZ = this.minZ;
+            camera.maxZ = this.maxZ;
+
+            camera.rotation.x = this.rotation.x;
+            camera.rotation.y = this.rotation.y;
+            camera.rotation.z = this.rotation.z;
+        };
+
+        // Oculus events
+        OculusGamepadCamera.prototype._onOrientationEvent = function (evt) {
+            var yaw = evt.alpha / 180 * Math.PI;
+            var pitch = evt.beta / 180 * Math.PI;
+            var roll = evt.gamma / 180 * Math.PI;
+
+            if (!this._offsetOrientation) {
+                this._offsetOrientation = {
+                    yaw: yaw,
+                    pitch: pitch,
+                    roll: roll
+                };
+                return;
+            } else {
+                this.rotation.y += yaw - this._offsetOrientation.yaw;
+                this.rotation.x += pitch - this._offsetOrientation.pitch;
+                this.rotation.z += this._offsetOrientation.roll - roll;
+
+                this._offsetOrientation.yaw = yaw;
+                this._offsetOrientation.pitch = pitch;
+                this._offsetOrientation.roll = roll;
+            }
+        };
+
+        OculusGamepadCamera.prototype.attachControl = function (element, noPreventDefault) {
+            _super.prototype.attachControl.call(this, element, noPreventDefault);
+
+            window.addEventListener("deviceorientation", this._deviceOrientationHandler);
+        };
+
+        OculusGamepadCamera.prototype.detachControl = function (element) {
+            _super.prototype.detachControl.call(this, element);
+
+            window.removeEventListener("deviceorientation", this._deviceOrientationHandler);
+        };
+
+        OculusGamepadCamera.prototype.dispose = function () {
+            this._gamepads.dispose();
+            _super.prototype.dispose.call(this);
+        };
+        return OculusGamepadCamera;
+    })(BABYLON.FreeCamera);
+    BABYLON.OculusGamepadCamera = OculusGamepadCamera;
+})(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.oculusGamepadCamera.js.map

Babylon/Cameras/VR/babylon.vrDeviceOrientationCamera.d.ts

@@ -0,0 +1,9 @@
+declare module BABYLON {
+    class VRDeviceOrientationCamera extends OculusCamera {
+        public _alpha: number;
+        public _beta: number;
+        public _gamma: number;
+        constructor(name: string, position: Vector3, scene: Scene);
+        public _onOrientationEvent(evt: DeviceOrientationEvent): void;
+    }
+}

Babylon/Cameras/VR/babylon.vrDeviceOrientationCamera.js

@@ -0,0 +1,37 @@
+var __extends = this.__extends || function (d, b) {
+    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
+    function __() { this.constructor = d; }
+    __.prototype = b.prototype;
+    d.prototype = new __();
+};
+var BABYLON;
+(function (BABYLON) {
+    var VRDeviceOrientationCamera = (function (_super) {
+        __extends(VRDeviceOrientationCamera, _super);
+        function VRDeviceOrientationCamera(name, position, scene) {
+            _super.call(this, name, position, scene);
+            this._alpha = 0;
+            this._beta = 0;
+            this._gamma = 0;
+        }
+        VRDeviceOrientationCamera.prototype._onOrientationEvent = function (evt) {
+            this._alpha = +evt.alpha | 0;
+            this._beta = +evt.beta | 0;
+            this._gamma = +evt.gamma | 0;
+
+            if (this._gamma < 0) {
+                this._gamma = 90 + this._gamma;
+            } else {
+                // Incline it in the correct angle.
+                this._gamma = 270 - this._gamma;
+            }
+
+            this.rotation.x = this._gamma / 180.0 * Math.PI;
+            this.rotation.y = -this._alpha / 180.0 * Math.PI;
+            this.rotation.z = this._beta / 180.0 * Math.PI;
+        };
+        return VRDeviceOrientationCamera;
+    })(BABYLON.OculusCamera);
+    BABYLON.VRDeviceOrientationCamera = VRDeviceOrientationCamera;
+})(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.vrDeviceOrientationCamera.js.map

Babylon/Cameras/VR/babylon.webVRCamera.d.ts

@@ -0,0 +1,17 @@
+declare var HMDVRDevice: any;
+declare var PositionSensorVRDevice: any;
+declare module BABYLON {
+    class WebVRCamera extends OculusCamera {
+        public _hmdDevice: any;
+        public _sensorDevice: any;
+        public _cacheState: any;
+        public _cacheQuaternion: Quaternion;
+        public _cacheRotation: Vector3;
+        public _vrEnabled: boolean;
+        constructor(name: string, position: Vector3, scene: Scene);
+        private _getWebVRDevices(devices);
+        public _update(): void;
+        public attachControl(element: HTMLElement, noPreventDefault?: boolean): void;
+        public detachControl(element: HTMLElement): void;
+    }
+}

Babylon/Cameras/VR/babylon.webVRCamera.js

@@ -0,0 +1,80 @@
+var __extends = this.__extends || function (d, b) {
+    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
+    function __() { this.constructor = d; }
+    __.prototype = b.prototype;
+    d.prototype = new __();
+};
+var BABYLON;
+(function (BABYLON) {
+    var WebVRCamera = (function (_super) {
+        __extends(WebVRCamera, _super);
+        function WebVRCamera(name, position, scene) {
+            _super.call(this, name, position, scene);
+            this._hmdDevice = null;
+            this._sensorDevice = null;
+            this._cacheState = null;
+            this._cacheQuaternion = new BABYLON.Quaternion();
+            this._cacheRotation = BABYLON.Vector3.Zero();
+            this._vrEnabled = false;
+            this._getWebVRDevices = this._getWebVRDevices.bind(this);
+        }
+        WebVRCamera.prototype._getWebVRDevices = function (devices) {
+            var size = devices.length;
+            var i = 0;
+
+            // Reset devices.
+            this._sensorDevice = null;
+            this._hmdDevice = null;
+
+            while (i < size && this._hmdDevice === null) {
+                if (devices[i] instanceof HMDVRDevice) {
+                    this._hmdDevice = devices[i];
+                }
+                i++;
+            }
+
+            i = 0;
+
+            while (i < size && this._sensorDevice === null) {
+                if (devices[i] instanceof PositionSensorVRDevice && (!this._hmdDevice || devices[i].hardwareUnitId === this._hmdDevice.hardwareUnitId)) {
+                    this._sensorDevice = devices[i];
+                }
+                i++;
+            }
+
+            this._vrEnabled = this._sensorDevice && this._hmdDevice ? true : false;
+        };
+
+        WebVRCamera.prototype._update = function () {
+            if (this._vrEnabled) {
+                this._cacheState = this._sensorDevice.getState();
+                this._cacheQuaternion.copyFromFloats(this._cacheState.orientation.x, this._cacheState.orientation.y, this._cacheState.orientation.z, this._cacheState.orientation.w);
+                this._cacheQuaternion.toEulerAnglesToRef(this._cacheRotation);
+
+                this.rotation.x = -this._cacheRotation.z;
+                this.rotation.y = -this._cacheRotation.y;
+                this.rotation.z = this._cacheRotation.x;
+            }
+
+            _super.prototype._update.call(this);
+        };
+
+        WebVRCamera.prototype.attachControl = function (element, noPreventDefault) {
+            _super.prototype.attachControl.call(this, element, noPreventDefault);
+
+            if (navigator.getVRDevices) {
+                navigator.getVRDevices().then(this._getWebVRDevices);
+            } else if (navigator.mozGetVRDevices) {
+                navigator.mozGetVRDevices(this._getWebVRDevices);
+            }
+        };
+
+        WebVRCamera.prototype.detachControl = function (element) {
+            _super.prototype.detachControl.call(this, element);
+            this._vrEnabled = false;
+        };
+        return WebVRCamera;
+    })(BABYLON.OculusCamera);
+    BABYLON.WebVRCamera = WebVRCamera;
+})(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.webVRCamera.js.map

Babylon/Cameras/babylon.anaglyphCamera.d.ts

@@ -0,0 +1,20 @@
+declare module BABYLON {
+    class AnaglyphArcRotateCamera extends ArcRotateCamera {
+        private _eyeSpace;
+        private _leftCamera;
+        private _rightCamera;
+        constructor(name: string, alpha: number, beta: number, radius: number, target: any, eyeSpace: number, scene: any);
+        public _update(): void;
+        public _updateCamera(camera: ArcRotateCamera): void;
+    }
+    class AnaglyphFreeCamera extends FreeCamera {
+        private _eyeSpace;
+        private _leftCamera;
+        private _rightCamera;
+        private _transformMatrix;
+        constructor(name: string, position: Vector3, eyeSpace: number, scene: Scene);
+        public _getSubCameraPosition(eyeSpace: any, result: any): void;
+        public _update(): void;
+        public _updateCamera(camera: FreeCamera): void;
+    }
+}

Babylon/Cameras/babylon.arcRotateCamera.d.ts

@@ -0,0 +1,69 @@
+declare module BABYLON {
+    class ArcRotateCamera extends Camera {
+        public alpha: number;
+        public beta: number;
+        public radius: number;
+        public target: any;
+        public inertialAlphaOffset: number;
+        public inertialBetaOffset: number;
+        public inertialRadiusOffset: number;
+        public lowerAlphaLimit: any;
+        public upperAlphaLimit: any;
+        public lowerBetaLimit: number;
+        public upperBetaLimit: number;
+        public lowerRadiusLimit: any;
+        public upperRadiusLimit: any;
+        public angularSensibility: number;
+        public wheelPrecision: number;
+        public keysUp: number[];
+        public keysDown: number[];
+        public keysLeft: number[];
+        public keysRight: number[];
+        public zoomOnFactor: number;
+        public targetScreenOffset: Vector2;
+        private _keys;
+        private _viewMatrix;
+        private _attachedElement;
+        private _onPointerDown;
+        private _onPointerUp;
+        private _onPointerMove;
+        private _wheel;
+        private _onMouseMove;
+        private _onKeyDown;
+        private _onKeyUp;
+        private _onLostFocus;
+        private _reset;
+        private _onGestureStart;
+        private _onGesture;
+        private _MSGestureHandler;
+        public onCollide: (collidedMesh: AbstractMesh) => void;
+        public checkCollisions: boolean;
+        public collisionRadius: Vector3;
+        private _collider;
+        private _previousPosition;
+        private _collisionVelocity;
+        private _newPosition;
+        private _previousAlpha;
+        private _previousBeta;
+        private _previousRadius;
+        public pinchPrecision: number;
+        private _touchStart;
+        private _touchMove;
+        private _touchEnd;
+        private _pinchStart;
+        private _pinchMove;
+        private _pinchEnd;
+        constructor(name: string, alpha: number, beta: number, radius: number, target: any, scene: Scene);
+        public _getTargetPosition(): Vector3;
+        public _initCache(): void;
+        public _updateCache(ignoreParentClass?: boolean): void;
+        public _isSynchronizedViewMatrix(): boolean;
+        public attachControl(element: HTMLElement, noPreventDefault?: boolean): void;
+        public detachControl(element: HTMLElement): void;
+        public _update(): void;
+        public setPosition(position: Vector3): void;
+        public _getViewMatrix(): Matrix;
+        public zoomOn(meshes?: AbstractMesh[]): void;
+        public focusOn(meshesOrMinMaxVectorAndDistance: any): void;
+    }
+}

Babylon/Cameras/babylon.camera.d.ts

@@ -0,0 +1,44 @@
+declare module BABYLON {
+    class Camera extends Node {
+        public position: Vector3;
+        static PERSPECTIVE_CAMERA: number;
+        static ORTHOGRAPHIC_CAMERA: number;
+        public upVector: Vector3;
+        public orthoLeft: any;
+        public orthoRight: any;
+        public orthoBottom: any;
+        public orthoTop: any;
+        public fov: number;
+        public minZ: number;
+        public maxZ: number;
+        public inertia: number;
+        public mode: number;
+        public isIntermediate: boolean;
+        public viewport: Viewport;
+        public subCameras: any[];
+        public layerMask: number;
+        private _computedViewMatrix;
+        public _projectionMatrix: Matrix;
+        private _worldMatrix;
+        public _postProcesses: PostProcess[];
+        public _postProcessesTakenIndices: any[];
+        constructor(name: string, position: Vector3, scene: Scene);
+        public _initCache(): void;
+        public _updateCache(ignoreParentClass?: boolean): void;
+        public _updateFromScene(): void;
+        public _isSynchronized(): boolean;
+        public _isSynchronizedViewMatrix(): boolean;
+        public _isSynchronizedProjectionMatrix(): boolean;
+        public attachControl(element: HTMLElement): void;
+        public detachControl(element: HTMLElement): void;
+        public _update(): void;
+        public attachPostProcess(postProcess: PostProcess, insertAt?: number): number;
+        public detachPostProcess(postProcess: PostProcess, atIndices?: any): number[];
+        public getWorldMatrix(): Matrix;
+        public _getViewMatrix(): Matrix;
+        public getViewMatrix(): Matrix;
+        public _computeViewMatrix(force?: boolean): Matrix;
+        public getProjectionMatrix(force?: boolean): Matrix;
+        public dispose(): void;
+    }
+}

Babylon/Cameras/babylon.deviceOrientationCamera.d.ts

@@ -0,0 +1,18 @@
+declare module BABYLON {
+    class DeviceOrientationCamera extends FreeCamera {
+        private _offsetX;
+        private _offsetY;
+        private _orientationGamma;
+        private _orientationBeta;
+        private _initialOrientationGamma;
+        private _initialOrientationBeta;
+        private _attachedCanvas;
+        private _orientationChanged;
+        public angularSensibility: number;
+        public moveSensibility: number;
+        constructor(name: string, position: Vector3, scene: Scene);
+        public attachControl(canvas: HTMLCanvasElement, noPreventDefault: boolean): void;
+        public detachControl(canvas: HTMLCanvasElement): void;
+        public _checkInputs(): void;
+    }
+}

Babylon/Cameras/babylon.followCamera.d.ts

@@ -0,0 +1,14 @@
+declare module BABYLON {
+    class FollowCamera extends TargetCamera {
+        public radius: number;
+        public rotationOffset: number;
+        public heightOffset: number;
+        public cameraAcceleration: number;
+        public maxCameraSpeed: number;
+        public target: AbstractMesh;
+        constructor(name: string, position: Vector3, scene: Scene);
+        private getRadians(degrees);
+        private follow(cameraTarget);
+        public _update(): void;
+    }
+}

Babylon/Cameras/babylon.freeCamera.d.ts

@@ -0,0 +1,38 @@
+declare module BABYLON {
+    class FreeCamera extends TargetCamera {
+        public ellipsoid: Vector3;
+        public keysUp: number[];
+        public keysDown: number[];
+        public keysLeft: number[];
+        public keysRight: number[];
+        public checkCollisions: boolean;
+        public applyGravity: boolean;
+        public angularSensibility: number;
+        public onCollide: (collidedMesh: AbstractMesh) => void;
+        private _keys;
+        private _collider;
+        private _needMoveForGravity;
+        private _oldPosition;
+        private _diffPosition;
+        private _newPosition;
+        private _attachedElement;
+        private _localDirection;
+        private _transformedDirection;
+        private _onMouseDown;
+        private _onMouseUp;
+        private _onMouseOut;
+        private _onMouseMove;
+        private _onKeyDown;
+        private _onKeyUp;
+        public _onLostFocus: (e: FocusEvent) => any;
+        public _waitingLockedTargetId: string;
+        constructor(name: string, position: Vector3, scene: Scene);
+        public attachControl(element: HTMLElement, noPreventDefault?: boolean): void;
+        public detachControl(element: HTMLElement): void;
+        public _collideWithWorld(velocity: Vector3): void;
+        public _checkInputs(): void;
+        public _decideIfNeedsToMove(): boolean;
+        public _updatePosition(): void;
+        public _update(): void;
+    }
+}

Babylon/Cameras/babylon.gamepadCamera.d.ts

@@ -0,0 +1,12 @@
+declare module BABYLON {
+    class GamepadCamera extends FreeCamera {
+        private _gamepad;
+        private _gamepads;
+        public angularSensibility: number;
+        public moveSensibility: number;
+        constructor(name: string, position: Vector3, scene: Scene);
+        private _onNewGameConnected(gamepad);
+        public _checkInputs(): void;
+        public dispose(): void;
+    }
+}

Babylon/Cameras/babylon.oculusCamera.d.ts

@@ -0,0 +1,14 @@
+declare module BABYLON {
+    class OculusCamera extends FreeCamera {
+        private _leftCamera;
+        private _rightCamera;
+        private _offsetOrientation;
+        private _deviceOrientationHandler;
+        constructor(name: string, position: Vector3, scene: Scene);
+        public _update(): void;
+        public _updateCamera(camera: FreeCamera): void;
+        public _onOrientationEvent(evt: DeviceOrientationEvent): void;
+        public attachControl(element: HTMLElement, noPreventDefault?: boolean): void;
+        public detachControl(element: HTMLElement): void;
+    }
+}

Babylon/Cameras/babylon.oculusGamepadCamera.d.ts

@@ -0,0 +1,21 @@
+declare module BABYLON {
+    class OculusGamepadCamera extends FreeCamera {
+        private _leftCamera;
+        private _rightCamera;
+        private _offsetOrientation;
+        private _deviceOrientationHandler;
+        private _gamepad;
+        private _gamepads;
+        public angularSensibility: number;
+        public moveSensibility: number;
+        constructor(name: string, position: Vector3, scene: Scene);
+        private _onNewGameConnected(gamepad);
+        public _update(): void;
+        public _checkInputs(): void;
+        public _updateCamera(camera: FreeCamera): void;
+        public _onOrientationEvent(evt: DeviceOrientationEvent): void;
+        public attachControl(element: HTMLElement, noPreventDefault?: boolean): void;
+        public detachControl(element: HTMLElement): void;
+        public dispose(): void;
+    }
+}

Babylon/Cameras/babylon.targetCamera.d.ts

@@ -0,0 +1,33 @@
+declare module BABYLON {
+    class TargetCamera extends Camera {
+        public cameraDirection: Vector3;
+        public cameraRotation: Vector2;
+        public rotation: Vector3;
+        public speed: number;
+        public noRotationConstraint: boolean;
+        public lockedTarget: any;
+        public _currentTarget: Vector3;
+        public _viewMatrix: Matrix;
+        public _camMatrix: Matrix;
+        public _cameraTransformMatrix: Matrix;
+        public _cameraRotationMatrix: Matrix;
+        public _referencePoint: Vector3;
+        public _transformedReferencePoint: Vector3;
+        public _lookAtTemp: Matrix;
+        public _tempMatrix: Matrix;
+        public _reset: () => void;
+        public _waitingLockedTargetId: string;
+        constructor(name: string, position: Vector3, scene: Scene);
+        public _getLockedTargetPosition(): Vector3;
+        public _initCache(): void;
+        public _updateCache(ignoreParentClass?: boolean): void;
+        public _isSynchronizedViewMatrix(): boolean;
+        public _computeLocalCameraSpeed(): number;
+        public setTarget(target: Vector3): void;
+        public getTarget(): Vector3;
+        public _decideIfNeedsToMove(): boolean;
+        public _updatePosition(): void;
+        public _update(): void;
+        public _getViewMatrix(): Matrix;
+    }
+}

Babylon/Cameras/babylon.touchCamera.d.ts

@@ -0,0 +1,18 @@
+declare module BABYLON {
+    class TouchCamera extends FreeCamera {
+        private _offsetX;
+        private _offsetY;
+        private _pointerCount;
+        private _pointerPressed;
+        private _attachedCanvas;
+        private _onPointerDown;
+        private _onPointerUp;
+        private _onPointerMove;
+        public angularSensibility: number;
+        public moveSensibility: number;
+        constructor(name: string, position: Vector3, scene: Scene);
+        public attachControl(canvas: HTMLCanvasElement, noPreventDefault: boolean): void;
+        public detachControl(canvas: HTMLCanvasElement): void;
+        public _checkInputs(): void;
+    }
+}

Babylon/Cameras/babylon.virtualJoysticksCamera.d.ts

@@ -0,0 +1,9 @@
+declare module BABYLON {
+    class VirtualJoysticksCamera extends FreeCamera {
+        private _leftjoystick;
+        private _rightjoystick;
+        constructor(name: string, position: Vector3, scene: Scene);
+        public _checkInputs(): void;
+        public dispose(): void;
+    }
+}

Babylon/Cameras/babylon.vrDeviceOrientationCamera.d.ts

@@ -0,0 +1,9 @@
+declare module BABYLON {
+    class VRDeviceOrientationCamera extends OculusCamera {
+        public _alpha: number;
+        public _beta: number;
+        public _gamma: number;
+        constructor(name: string, position: Vector3, scene: Scene);
+        public _onOrientationEvent(evt: DeviceOrientationEvent): void;
+    }
+}

Babylon/Cameras/babylon.webVRCamera.d.ts

@@ -0,0 +1,17 @@
+declare var HMDVRDevice: any;
+declare var PositionSensorVRDevice: any;
+declare module BABYLON {
+    class WebVRCamera extends OculusCamera {
+        public _hmdDevice: any;
+        public _sensorDevice: any;
+        public _cacheState: any;
+        public _cacheQuaternion: Quaternion;
+        public _cacheRotation: Vector3;
+        public _vrEnabled: boolean;
+        constructor(name: string, position: Vector3, scene: Scene);
+        private _getWebVRDevices(devices);
+        public _update(): void;
+        public attachControl(element: HTMLElement, noPreventDefault?: boolean): void;
+        public detachControl(element: HTMLElement): void;
+    }
+}

Babylon/Collisions/babylon.collider.d.ts

@@ -0,0 +1,36 @@
+declare module BABYLON {
+    class Collider {
+        public radius: Vector3;
+        public retry: number;
+        public velocity: Vector3;
+        public basePoint: Vector3;
+        public epsilon: number;
+        public collisionFound: boolean;
+        public velocityWorldLength: number;
+        public basePointWorld: Vector3;
+        public velocityWorld: Vector3;
+        public normalizedVelocity: Vector3;
+        public initialVelocity: Vector3;
+        public initialPosition: Vector3;
+        public nearestDistance: number;
+        public intersectionPoint: Vector3;
+        public collidedMesh: AbstractMesh;
+        private _collisionPoint;
+        private _planeIntersectionPoint;
+        private _tempVector;
+        private _tempVector2;
+        private _tempVector3;
+        private _tempVector4;
+        private _edge;
+        private _baseToVertex;
+        private _destinationPoint;
+        private _slidePlaneNormal;
+        private _displacementVector;
+        public _initialize(source: Vector3, dir: Vector3, e: number): void;
+        public _checkPointInTriangle(point: Vector3, pa: Vector3, pb: Vector3, pc: Vector3, n: Vector3): boolean;
+        public _canDoCollision(sphereCenter: Vector3, sphereRadius: number, vecMin: Vector3, vecMax: Vector3): boolean;
+        public _testTriangle(faceIndex: number, subMesh: SubMesh, p1: Vector3, p2: Vector3, p3: Vector3): void;
+        public _collide(subMesh: any, pts: Vector3[], indices: number[], indexStart: number, indexEnd: number, decal: number): void;
+        public _getResponse(pos: Vector3, vel: Vector3): void;
+    }
+}

Babylon/Collisions/babylon.pickingInfo.d.ts

@@ -0,0 +1,20 @@
+declare module BABYLON {
+    class IntersectionInfo {
+        public bu: number;
+        public bv: number;
+        public distance: number;
+        public faceId: number;
+        constructor(bu: number, bv: number, distance: number);
+    }
+    class PickingInfo {
+        public hit: boolean;
+        public distance: number;
+        public pickedPoint: Vector3;
+        public pickedMesh: AbstractMesh;
+        public bu: number;
+        public bv: number;
+        public faceId: number;
+        public getNormal(): Vector3;
+        public getTextureCoordinates(): Vector2;
+    }
+}

Babylon/Culling/Octrees/babylon.octree.d.ts

@@ -0,0 +1,22 @@
+declare module BABYLON {
+    interface IOctreeContainer<T> {
+        blocks: OctreeBlock<T>[];
+    }
+    class Octree<T> {
+        public maxDepth: number;
+        public blocks: OctreeBlock<T>[];
+        public dynamicContent: T[];
+        private _maxBlockCapacity;
+        private _selectionContent;
+        private _creationFunc;
+        constructor(creationFunc: (entry: T, block: OctreeBlock<T>) => void, maxBlockCapacity?: number, maxDepth?: number);
+        public update(worldMin: Vector3, worldMax: Vector3, entries: T[]): void;
+        public addMesh(entry: T): void;
+        public select(frustumPlanes: Plane[], allowDuplicate?: boolean): SmartArray<T>;
+        public intersects(sphereCenter: Vector3, sphereRadius: number, allowDuplicate?: boolean): SmartArray<T>;
+        public intersectsRay(ray: Ray): SmartArray<T>;
+        static _CreateBlocks<T>(worldMin: Vector3, worldMax: Vector3, entries: T[], maxBlockCapacity: number, currentDepth: number, maxDepth: number, target: IOctreeContainer<T>, creationFunc: (entry: T, block: OctreeBlock<T>) => void): void;
+        static CreationFuncForMeshes: (entry: AbstractMesh, block: OctreeBlock<AbstractMesh>) => void;
+        static CreationFuncForSubMeshes: (entry: SubMesh, block: OctreeBlock<SubMesh>) => void;
+    }
+}

Babylon/Culling/Octrees/babylon.octreeBlock.d.ts

@@ -0,0 +1,23 @@
+declare module BABYLON {
+    class OctreeBlock<T> {
+        public entries: T[];
+        public blocks: OctreeBlock<T>[];
+        private _depth;
+        private _maxDepth;
+        private _capacity;
+        private _minPoint;
+        private _maxPoint;
+        private _boundingVectors;
+        private _creationFunc;
+        constructor(minPoint: Vector3, maxPoint: Vector3, capacity: number, depth: number, maxDepth: number, creationFunc: (entry: T, block: OctreeBlock<T>) => void);
+        public capacity : number;
+        public minPoint : Vector3;
+        public maxPoint : Vector3;
+        public addEntry(entry: T): void;
+        public addEntries(entries: T[]): void;
+        public select(frustumPlanes: Plane[], selection: SmartArray<T>, allowDuplicate?: boolean): void;
+        public intersects(sphereCenter: Vector3, sphereRadius: number, selection: SmartArray<T>, allowDuplicate?: boolean): void;
+        public intersectsRay(ray: Ray, selection: SmartArray<T>): void;
+        public createInnerBlocks(): void;
+    }
+}

Babylon/Culling/babylon.boundingBox.d.ts

@@ -0,0 +1,26 @@
+declare module BABYLON {
+    class BoundingBox {
+        public minimum: Vector3;
+        public maximum: Vector3;
+        public vectors: Vector3[];
+        public center: Vector3;
+        public extendSize: Vector3;
+        public directions: Vector3[];
+        public vectorsWorld: Vector3[];
+        public minimumWorld: Vector3;
+        public maximumWorld: Vector3;
+        private _worldMatrix;
+        constructor(minimum: Vector3, maximum: Vector3);
+        public getWorldMatrix(): Matrix;
+        public _update(world: Matrix): void;
+        public isInFrustum(frustumPlanes: Plane[]): boolean;
+        public isCompletelyInFrustum(frustumPlanes: Plane[]): boolean;
+        public intersectsPoint(point: Vector3): boolean;
+        public intersectsSphere(sphere: BoundingSphere): boolean;
+        public intersectsMinMax(min: Vector3, max: Vector3): boolean;
+        static Intersects(box0: BoundingBox, box1: BoundingBox): boolean;
+        static IntersectsSphere(minPoint: Vector3, maxPoint: Vector3, sphereCenter: Vector3, sphereRadius: number): boolean;
+        static IsCompletelyInFrustum(boundingVectors: Vector3[], frustumPlanes: Plane[]): boolean;
+        static IsInFrustum(boundingVectors: Vector3[], frustumPlanes: Plane[]): boolean;
+    }
+}

Babylon/Culling/babylon.boundingInfo.d.ts

@@ -0,0 +1,15 @@
+declare module BABYLON {
+    class BoundingInfo {
+        public minimum: Vector3;
+        public maximum: Vector3;
+        public boundingBox: BoundingBox;
+        public boundingSphere: BoundingSphere;
+        constructor(minimum: Vector3, maximum: Vector3);
+        public _update(world: Matrix): void;
+        public isInFrustum(frustumPlanes: Plane[]): boolean;
+        public isCompletelyInFrustum(frustumPlanes: Plane[]): boolean;
+        public _checkCollision(collider: Collider): boolean;
+        public intersectsPoint(point: Vector3): boolean;
+        public intersects(boundingInfo: BoundingInfo, precise: boolean): boolean;
+    }
+}

Babylon/Culling/babylon.boundingSphere.d.ts

@@ -0,0 +1,16 @@
+declare module BABYLON {
+    class BoundingSphere {
+        public minimum: Vector3;
+        public maximum: Vector3;
+        public center: Vector3;
+        public radius: number;
+        public centerWorld: Vector3;
+        public radiusWorld: number;
+        private _tempRadiusVector;
+        constructor(minimum: Vector3, maximum: Vector3);
+        public _update(world: Matrix): void;
+        public isInFrustum(frustumPlanes: Plane[]): boolean;
+        public intersectsPoint(point: Vector3): boolean;
+        static Intersects(sphere0: BoundingSphere, sphere1: BoundingSphere): boolean;
+    }
+}

Babylon/Layer/babylon.layer.d.ts

@@ -0,0 +1,18 @@
+declare module BABYLON {
+    class Layer {
+        public name: string;
+        public texture: Texture;
+        public isBackground: boolean;
+        public color: Color4;
+        public onDispose: () => void;
+        private _scene;
+        private _vertexDeclaration;
+        private _vertexStrideSize;
+        private _vertexBuffer;
+        private _indexBuffer;
+        private _effect;
+        constructor(name: string, imgUrl: string, scene: Scene, isBackground?: boolean, color?: Color4);
+        public render(): void;
+        public dispose(): void;
+    }
+}

Babylon/LensFlare/babylon.lensFlare.d.ts

@@ -0,0 +1,11 @@
+declare module BABYLON {
+    class LensFlare {
+        public size: number;
+        public position: number;
+        public color: Color3;
+        public texture: Texture;
+        private _system;
+        constructor(size: number, position: number, color: any, imgUrl: string, system: LensFlareSystem);
+        public dispose: () => void;
+    }
+}

Babylon/LensFlare/babylon.lensFlareSystem.d.ts

@@ -0,0 +1,27 @@
+declare module BABYLON {
+    class LensFlareSystem {
+        public name: string;
+        public lensFlares: LensFlare[];
+        public borderLimit: number;
+        public meshesSelectionPredicate: (mesh: Mesh) => boolean;
+        private _scene;
+        private _emitter;
+        private _vertexDeclaration;
+        private _vertexStrideSize;
+        private _vertexBuffer;
+        private _indexBuffer;
+        private _effect;
+        private _positionX;
+        private _positionY;
+        private _isEnabled;
+        constructor(name: string, emitter: any, scene: Scene);
+        public isEnabled : boolean;
+        public getScene(): Scene;
+        public getEmitter(): any;
+        public getEmitterPosition(): Vector3;
+        public computeEffectivePosition(globalViewport: Viewport): boolean;
+        public _isVisible(): boolean;
+        public render(): boolean;
+        public dispose(): void;
+    }
+}

Babylon/Lights/Shadows/babylon.shadowGenerator.d.ts

@@ -0,0 +1,35 @@
+declare module BABYLON {
+    class ShadowGenerator {
+        private static _FILTER_NONE;
+        private static _FILTER_VARIANCESHADOWMAP;
+        private static _FILTER_POISSONSAMPLING;
+        static FILTER_NONE : number;
+        static FILTER_VARIANCESHADOWMAP : number;
+        static FILTER_POISSONSAMPLING : number;
+        public filter: number;
+        public useVarianceShadowMap : boolean;
+        public usePoissonSampling : boolean;
+        private _light;
+        private _scene;
+        private _shadowMap;
+        private _darkness;
+        private _transparencyShadow;
+        private _effect;
+        private _viewMatrix;
+        private _projectionMatrix;
+        private _transformMatrix;
+        private _worldViewProjection;
+        private _cachedPosition;
+        private _cachedDirection;
+        private _cachedDefines;
+        constructor(mapSize: number, light: DirectionalLight);
+        public isReady(subMesh: SubMesh, useInstances: boolean): boolean;
+        public getShadowMap(): RenderTargetTexture;
+        public getLight(): DirectionalLight;
+        public getTransformMatrix(): Matrix;
+        public getDarkness(): number;
+        public setDarkness(darkness: number): void;
+        public setTransparencyShadow(hasShadow: boolean): void;
+        public dispose(): void;
+    }
+}

Babylon/Lights/babylon.directionalLight.d.ts

@@ -0,0 +1,15 @@
+declare module BABYLON {
+    class DirectionalLight extends Light {
+        public direction: Vector3;
+        public position: Vector3;
+        private _transformedDirection;
+        public _transformedPosition: Vector3;
+        private _worldMatrix;
+        constructor(name: string, direction: Vector3, scene: Scene);
+        public getAbsolutePosition(): Vector3;
+        public setDirectionToTarget(target: Vector3): Vector3;
+        public _computeTransformedPosition(): boolean;
+        public transferToEffect(effect: Effect, directionUniformName: string): void;
+        public _getWorldMatrix(): Matrix;
+    }
+}

Babylon/Lights/babylon.hemisphericLight.d.ts

@@ -0,0 +1,12 @@
+declare module BABYLON {
+    class HemisphericLight extends Light {
+        public direction: Vector3;
+        public groundColor: Color3;
+        private _worldMatrix;
+        constructor(name: string, direction: Vector3, scene: Scene);
+        public setDirectionToTarget(target: Vector3): Vector3;
+        public getShadowGenerator(): ShadowGenerator;
+        public transferToEffect(effect: Effect, directionUniformName: string, groundColorUniformName: string): void;
+        public _getWorldMatrix(): Matrix;
+    }
+}

Babylon/Lights/babylon.light.d.ts

@@ -0,0 +1,22 @@
+declare module BABYLON {
+    class Light extends Node {
+        public diffuse: Color3;
+        public specular: Color3;
+        public intensity: number;
+        public range: number;
+        public includedOnlyMeshes: AbstractMesh[];
+        public excludedMeshes: AbstractMesh[];
+        public _shadowGenerator: ShadowGenerator;
+        private _parentedWorldMatrix;
+        public _excludedMeshesIds: string[];
+        public _includedOnlyMeshesIds: string[];
+        constructor(name: string, scene: Scene);
+        public getShadowGenerator(): ShadowGenerator;
+        public getAbsolutePosition(): Vector3;
+        public transferToEffect(effect: Effect, uniformName0?: string, uniformName1?: string): void;
+        public _getWorldMatrix(): Matrix;
+        public canAffectMesh(mesh: AbstractMesh): boolean;
+        public getWorldMatrix(): Matrix;
+        public dispose(): void;
+    }
+}

Babylon/Lights/babylon.pointLight.d.ts

@@ -0,0 +1,12 @@
+declare module BABYLON {
+    class PointLight extends Light {
+        public position: Vector3;
+        private _worldMatrix;
+        private _transformedPosition;
+        constructor(name: string, position: Vector3, scene: Scene);
+        public getAbsolutePosition(): Vector3;
+        public transferToEffect(effect: Effect, positionUniformName: string): void;
+        public getShadowGenerator(): ShadowGenerator;
+        public _getWorldMatrix(): Matrix;
+    }
+}

Babylon/Lights/babylon.spotLight.d.ts

@@ -0,0 +1,16 @@
+declare module BABYLON {
+    class SpotLight extends Light {
+        public position: Vector3;
+        public direction: Vector3;
+        public angle: number;
+        public exponent: number;
+        private _transformedDirection;
+        private _transformedPosition;
+        private _worldMatrix;
+        constructor(name: string, position: Vector3, direction: Vector3, angle: number, exponent: number, scene: Scene);
+        public getAbsolutePosition(): Vector3;
+        public setDirectionToTarget(target: Vector3): Vector3;
+        public transferToEffect(effect: Effect, positionUniformName: string, directionUniformName: string): void;
+        public _getWorldMatrix(): Matrix;
+    }
+}

Babylon/Loading/Plugins/babylon.babylonFileLoader.d.ts

@@ -0,0 +1,2 @@
+declare module BABYLON.Internals {
+}

Babylon/Loading/babylon.sceneLoader.d.ts

@@ -0,0 +1,31 @@
+declare module BABYLON {
+    interface ISceneLoaderPlugin {
+        extensions: string;
+        importMesh: (meshesNames: any, scene: Scene, data: any, rootUrl: string, meshes: AbstractMesh[], particleSystems: ParticleSystem[], skeletons: Skeleton[]) => boolean;
+        load: (scene: Scene, data: string, rootUrl: string) => boolean;
+    }
+    class SceneLoader {
+        private static _ForceFullSceneLoadingForIncremental;
+        private static _ShowLoadingScreen;
+        static ForceFullSceneLoadingForIncremental : boolean;
+        static ShowLoadingScreen : boolean;
+        private static _registeredPlugins;
+        private static _getPluginForFilename(sceneFilename);
+        static RegisterPlugin(plugin: ISceneLoaderPlugin): void;
+        static ImportMesh(meshesNames: any, rootUrl: string, sceneFilename: string, scene: Scene, onsuccess?: (meshes: AbstractMesh[], particleSystems: ParticleSystem[], skeletons: Skeleton[]) => void, progressCallBack?: () => void, onerror?: (scene: Scene, e: any) => void): void;
+        /**
+        * Load a scene
+        * @param rootUrl a string that defines the root url for scene and resources
+        * @param sceneFilename a string that defines the name of the scene file. can start with "data:" following by the stringified version of the scene
+        * @param engine is the instance of BABYLON.Engine to use to create the scene
+        */
+        static Load(rootUrl: string, sceneFilename: any, engine: Engine, onsuccess?: (scene: Scene) => void, progressCallBack?: any, onerror?: (scene: Scene) => void): void;
+        /**
+        * Append a scene
+        * @param rootUrl a string that defines the root url for scene and resources
+        * @param sceneFilename a string that defines the name of the scene file. can start with "data:" following by the stringified version of the scene
+        * @param scene is the instance of BABYLON.Scene to append to
+        */
+        static Append(rootUrl: string, sceneFilename: any, scene: Scene, onsuccess?: (scene: Scene) => void, progressCallBack?: any, onerror?: (scene: Scene) => void): void;
+    }
+}

Babylon/Materials/Textures/Procedurals/babylon.customProceduralTexture.d.ts

@@ -0,0 +1,15 @@
+declare module BABYLON {
+    class CustomProceduralTexture extends ProceduralTexture {
+        private _animate;
+        private _time;
+        private _config;
+        private _texturePath;
+        constructor(name: string, texturePath: any, size: number, scene: Scene, fallbackTexture?: Texture, generateMipMaps?: boolean);
+        private loadJson(jsonUrl);
+        public isReady(): boolean;
+        public render(useCameraPostProcess?: boolean): void;
+        public updateTextures(): void;
+        public updateShaderUniforms(): void;
+        public animate : boolean;
+    }
+}

Babylon/Materials/Textures/Procedurals/babylon.proceduralTexture.d.ts

@@ -0,0 +1,48 @@
+declare module BABYLON {
+    class ProceduralTexture extends Texture {
+        private _size;
+        public _generateMipMaps: boolean;
+        private _doNotChangeAspectRatio;
+        private _currentRefreshId;
+        private _refreshRate;
+        private _vertexBuffer;
+        private _indexBuffer;
+        private _effect;
+        private _vertexDeclaration;
+        private _vertexStrideSize;
+        private _uniforms;
+        private _samplers;
+        private _fragment;
+        public _textures: Texture[];
+        private _floats;
+        private _floatsArrays;
+        private _colors3;
+        private _colors4;
+        private _vectors2;
+        private _vectors3;
+        private _matrices;
+        private _fallbackTexture;
+        private _fallbackTextureUsed;
+        constructor(name: string, size: any, fragment: any, scene: Scene, fallbackTexture?: Texture, generateMipMaps?: boolean);
+        public reset(): void;
+        public isReady(): boolean;
+        public resetRefreshCounter(): void;
+        public setFragment(fragment: any): void;
+        public refreshRate : number;
+        public _shouldRender(): boolean;
+        public getRenderSize(): number;
+        public resize(size: any, generateMipMaps: any): void;
+        private _checkUniform(uniformName);
+        public setTexture(name: string, texture: Texture): ProceduralTexture;
+        public setFloat(name: string, value: number): ProceduralTexture;
+        public setFloats(name: string, value: number[]): ProceduralTexture;
+        public setColor3(name: string, value: Color3): ProceduralTexture;
+        public setColor4(name: string, value: Color4): ProceduralTexture;
+        public setVector2(name: string, value: Vector2): ProceduralTexture;
+        public setVector3(name: string, value: Vector3): ProceduralTexture;
+        public setMatrix(name: string, value: Matrix): ProceduralTexture;
+        public render(useCameraPostProcess?: boolean): void;
+        public clone(): ProceduralTexture;
+        public dispose(): void;
+    }
+}

Babylon/Materials/Textures/Procedurals/babylon.standardProceduralTexture.d.ts

@@ -0,0 +1,81 @@
+declare module BABYLON {
+    class WoodProceduralTexture extends ProceduralTexture {
+        private _ampScale;
+        private _woodColor;
+        constructor(name: string, size: number, scene: Scene, fallbackTexture?: Texture, generateMipMaps?: boolean);
+        public updateShaderUniforms(): void;
+        public ampScale : number;
+        public woodColor : Color3;
+    }
+    class FireProceduralTexture extends ProceduralTexture {
+        private _time;
+        private _speed;
+        private _shift;
+        private _autoGenerateTime;
+        private _fireColors;
+        private _alphaThreshold;
+        constructor(name: string, size: number, scene: Scene, fallbackTexture?: Texture, generateMipMaps?: boolean);
+        public updateShaderUniforms(): void;
+        public render(useCameraPostProcess?: boolean): void;
+        static PurpleFireColors : Color3[];
+        static GreenFireColors : Color3[];
+        static RedFireColors : Color3[];
+        static BlueFireColors : Color3[];
+        public fireColors : Color3[];
+        public time : number;
+        public speed : Vector2;
+        public shift : number;
+        public alphaThreshold : number;
+    }
+    class CloudProceduralTexture extends ProceduralTexture {
+        private _skyColor;
+        private _cloudColor;
+        constructor(name: string, size: number, scene: Scene, fallbackTexture?: Texture, generateMipMaps?: boolean);
+        public updateShaderUniforms(): void;
+        public skyColor : Color3;
+        public cloudColor : Color3;
+    }
+    class GrassProceduralTexture extends ProceduralTexture {
+        private _grassColors;
+        private _herb1;
+        private _herb2;
+        private _herb3;
+        private _groundColor;
+        constructor(name: string, size: number, scene: Scene, fallbackTexture?: Texture, generateMipMaps?: boolean);
+        public updateShaderUniforms(): void;
+        public grassColors : Color3[];
+        public groundColor : Color3;
+    }
+    class RoadProceduralTexture extends ProceduralTexture {
+        private _roadColor;
+        constructor(name: string, size: number, scene: Scene, fallbackTexture?: Texture, generateMipMaps?: boolean);
+        public updateShaderUniforms(): void;
+        public roadColor : Color3;
+    }
+    class BrickProceduralTexture extends ProceduralTexture {
+        private _numberOfBricksHeight;
+        private _numberOfBricksWidth;
+        private _jointColor;
+        private _brickColor;
+        constructor(name: string, size: number, scene: Scene, fallbackTexture?: Texture, generateMipMaps?: boolean);
+        public updateShaderUniforms(): void;
+        public numberOfBricksHeight : number;
+        public cloudColor : number;
+        public numberOfBricksWidth : number;
+        public jointColor : Color3;
+        public brickColor : Color3;
+    }
+    class MarbleProceduralTexture extends ProceduralTexture {
+        private _numberOfTilesHeight;
+        private _numberOfTilesWidth;
+        private _amplitude;
+        private _marbleColor;
+        private _jointColor;
+        constructor(name: string, size: number, scene: Scene, fallbackTexture?: Texture, generateMipMaps?: boolean);
+        public updateShaderUniforms(): void;
+        public numberOfTilesHeight : number;
+        public numberOfTilesWidth : number;
+        public jointColor : Color3;
+        public marbleColor : Color3;
+    }
+}

Babylon/Materials/Textures/babylon.baseTexture.d.ts

@@ -0,0 +1,37 @@
+declare module BABYLON {
+    class BaseTexture {
+        public name: string;
+        public delayLoadState: number;
+        public hasAlpha: boolean;
+        public getAlphaFromRGB: boolean;
+        public level: number;
+        public isCube: boolean;
+        public isRenderTarget: boolean;
+        public animations: Animation[];
+        public onDispose: () => void;
+        public coordinatesIndex: number;
+        public coordinatesMode: number;
+        public wrapU: number;
+        public wrapV: number;
+        public anisotropicFilteringLevel: number;
+        public _cachedAnisotropicFilteringLevel: number;
+        private _scene;
+        public _texture: WebGLTexture;
+        constructor(scene: Scene);
+        public getScene(): Scene;
+        public getTextureMatrix(): Matrix;
+        public getReflectionTextureMatrix(): Matrix;
+        public getInternalTexture(): WebGLTexture;
+        public isReady(): boolean;
+        public getSize(): ISize;
+        public getBaseSize(): ISize;
+        public scale(ratio: number): void;
+        public canRescale : boolean;
+        public _removeFromCache(url: string, noMipmap: boolean): void;
+        public _getFromCache(url: string, noMipmap: boolean): WebGLTexture;
+        public delayLoad(): void;
+        public releaseInternalTexture(): void;
+        public clone(): BaseTexture;
+        public dispose(): void;
+    }
+}

Babylon/Materials/Textures/babylon.cubeTexture.d.ts

@@ -0,0 +1,13 @@
+declare module BABYLON {
+    class CubeTexture extends BaseTexture {
+        public url: string;
+        public coordinatesMode: number;
+        private _noMipmap;
+        private _extensions;
+        private _textureMatrix;
+        constructor(rootUrl: string, scene: Scene, extensions?: string[], noMipmap?: boolean);
+        public clone(): CubeTexture;
+        public delayLoad(): void;
+        public getReflectionTextureMatrix(): Matrix;
+    }
+}

Babylon/Materials/Textures/babylon.dynamicTexture.d.ts

@@ -0,0 +1,14 @@
+declare module BABYLON {
+    class DynamicTexture extends Texture {
+        private _generateMipMaps;
+        private _canvas;
+        private _context;
+        constructor(name: string, options: any, scene: Scene, generateMipMaps: boolean, samplingMode?: number);
+        public canRescale : boolean;
+        public scale(ratio: number): void;
+        public getContext(): CanvasRenderingContext2D;
+        public update(invertY?: boolean): void;
+        public drawText(text: string, x: number, y: number, font: string, color: string, clearColor: string, invertY?: boolean): void;
+        public clone(): DynamicTexture;
+    }
+}

Babylon/Materials/Textures/babylon.mirrorTexture.d.ts

@@ -0,0 +1,10 @@
+declare module BABYLON {
+    class MirrorTexture extends RenderTargetTexture {
+        public mirrorPlane: Plane;
+        private _transformMatrix;
+        private _mirrorMatrix;
+        private _savedViewMatrix;
+        constructor(name: string, size: number, scene: Scene, generateMipMaps?: boolean);
+        public clone(): MirrorTexture;
+    }
+}

Babylon/Materials/Textures/babylon.rawTexture.d.ts

@@ -0,0 +1,10 @@
+declare module BABYLON {
+    class RawTexture extends Texture {
+        constructor(data: ArrayBufferView, width: number, height: number, format: number, scene: Scene, generateMipMaps?: boolean, invertY?: boolean, samplingMode?: number);
+        static CreateLuminanceTexture(data: ArrayBufferView, width: number, height: number, scene: Scene, generateMipMaps?: boolean, invertY?: boolean, samplingMode?: number): RawTexture;
+        static CreateLuminanceAlphaTexture(data: ArrayBufferView, width: number, height: number, scene: Scene, generateMipMaps?: boolean, invertY?: boolean, samplingMode?: number): RawTexture;
+        static CreateAlphaTexture(data: ArrayBufferView, width: number, height: number, scene: Scene, generateMipMaps?: boolean, invertY?: boolean, samplingMode?: number): RawTexture;
+        static CreateRGBTexture(data: ArrayBufferView, width: number, height: number, scene: Scene, generateMipMaps?: boolean, invertY?: boolean, samplingMode?: number): RawTexture;
+        static CreateRGBATexture(data: ArrayBufferView, width: number, height: number, scene: Scene, generateMipMaps?: boolean, invertY?: boolean, samplingMode?: number): RawTexture;
+    }
+}

Babylon/Materials/Textures/babylon.renderTargetTexture.d.ts

@@ -0,0 +1,30 @@
+declare module BABYLON {
+    class RenderTargetTexture extends Texture {
+        public renderList: AbstractMesh[];
+        public renderParticles: boolean;
+        public renderSprites: boolean;
+        public coordinatesMode: number;
+        public onBeforeRender: () => void;
+        public onAfterRender: () => void;
+        public activeCamera: Camera;
+        public customRenderFunction: (opaqueSubMeshes: SmartArray<SubMesh>, transparentSubMeshes: SmartArray<SubMesh>, alphaTestSubMeshes: SmartArray<SubMesh>, beforeTransparents?: () => void) => void;
+        private _size;
+        public _generateMipMaps: boolean;
+        private _renderingManager;
+        public _waitingRenderList: string[];
+        private _doNotChangeAspectRatio;
+        private _currentRefreshId;
+        private _refreshRate;
+        constructor(name: string, size: any, scene: Scene, generateMipMaps?: boolean, doNotChangeAspectRatio?: boolean);
+        public resetRefreshCounter(): void;
+        public refreshRate : number;
+        public _shouldRender(): boolean;
+        public isReady(): boolean;
+        public getRenderSize(): number;
+        public canRescale : boolean;
+        public scale(ratio: number): void;
+        public resize(size: any, generateMipMaps?: boolean): void;
+        public render(useCameraPostProcess?: boolean): void;
+        public clone(): RenderTargetTexture;
+    }
+}

Babylon/Materials/Textures/babylon.texture.d.ts

@@ -0,0 +1,50 @@
+declare module BABYLON {
+    class Texture extends BaseTexture {
+        static NEAREST_SAMPLINGMODE: number;
+        static BILINEAR_SAMPLINGMODE: number;
+        static TRILINEAR_SAMPLINGMODE: number;
+        static EXPLICIT_MODE: number;
+        static SPHERICAL_MODE: number;
+        static PLANAR_MODE: number;
+        static CUBIC_MODE: number;
+        static PROJECTION_MODE: number;
+        static SKYBOX_MODE: number;
+        static CLAMP_ADDRESSMODE: number;
+        static WRAP_ADDRESSMODE: number;
+        static MIRROR_ADDRESSMODE: number;
+        public url: string;
+        public uOffset: number;
+        public vOffset: number;
+        public uScale: number;
+        public vScale: number;
+        public uAng: number;
+        public vAng: number;
+        public wAng: number;
+        private _noMipmap;
+        public _invertY: boolean;
+        private _rowGenerationMatrix;
+        private _cachedTextureMatrix;
+        private _projectionModeMatrix;
+        private _t0;
+        private _t1;
+        private _t2;
+        private _cachedUOffset;
+        private _cachedVOffset;
+        private _cachedUScale;
+        private _cachedVScale;
+        private _cachedUAng;
+        private _cachedVAng;
+        private _cachedWAng;
+        private _cachedCoordinatesMode;
+        public _samplingMode: number;
+        private _buffer;
+        private _deleteBuffer;
+        constructor(url: string, scene: Scene, noMipmap?: boolean, invertY?: boolean, samplingMode?: number, onLoad?: () => void, onError?: () => void, buffer?: any, deleteBuffer?: boolean);
+        public delayLoad(): void;
+        private _prepareRowForTextureGeneration(x, y, z, t);
+        public getTextureMatrix(): Matrix;
+        public getReflectionTextureMatrix(): Matrix;
+        public clone(): Texture;
+        static CreateFromBase64String(data: string, name: string, scene: Scene, noMipmap?: boolean, invertY?: boolean, samplingMode?: number, onLoad?: () => void, onError?: () => void): Texture;
+    }
+}

Babylon/Materials/Textures/babylon.videoTexture.d.ts

@@ -0,0 +1,9 @@
+declare module BABYLON {
+    class VideoTexture extends Texture {
+        public video: HTMLVideoElement;
+        private _autoLaunch;
+        private _lastUpdate;
+        constructor(name: string, urls: string[], size: any, scene: Scene, generateMipMaps: boolean, invertY: boolean, samplingMode?: number);
+        public update(): boolean;
+    }
+}

Babylon/Materials/babylon.effect.d.ts

@@ -0,0 +1,61 @@
+declare module BABYLON {
+    class EffectFallbacks {
+        private _defines;
+        private _currentRank;
+        private _maxRank;
+        public addFallback(rank: number, define: string): void;
+        public isMoreFallbacks : boolean;
+        public reduce(currentDefines: string): string;
+    }
+    class Effect {
+        public name: any;
+        public defines: string;
+        public onCompiled: (effect: Effect) => void;
+        public onError: (effect: Effect, errors: string) => void;
+        public onBind: (effect: Effect) => void;
+        private _engine;
+        private _uniformsNames;
+        private _samplers;
+        private _isReady;
+        private _compilationError;
+        private _attributesNames;
+        private _attributes;
+        private _uniforms;
+        public _key: string;
+        private _program;
+        private _valueCache;
+        constructor(baseName: any, attributesNames: string[], uniformsNames: string[], samplers: string[], engine: any, defines?: string, fallbacks?: EffectFallbacks, onCompiled?: (effect: Effect) => void, onError?: (effect: Effect, errors: string) => void);
+        public isReady(): boolean;
+        public getProgram(): WebGLProgram;
+        public getAttributesNames(): string[];
+        public getAttributeLocation(index: number): number;
+        public getAttributeLocationByName(name: string): number;
+        public getAttributesCount(): number;
+        public getUniformIndex(uniformName: string): number;
+        public getUniform(uniformName: string): WebGLUniformLocation;
+        public getSamplers(): string[];
+        public getCompilationError(): string;
+        public _loadVertexShader(vertex: any, callback: (data: any) => void): void;
+        public _loadFragmentShader(fragment: any, callback: (data: any) => void): void;
+        private _prepareEffect(vertexSourceCode, fragmentSourceCode, attributesNames, defines, fallbacks?);
+        public _bindTexture(channel: string, texture: WebGLTexture): void;
+        public setTexture(channel: string, texture: BaseTexture): void;
+        public setTextureFromPostProcess(channel: string, postProcess: PostProcess): void;
+        public _cacheFloat2(uniformName: string, x: number, y: number): void;
+        public _cacheFloat3(uniformName: string, x: number, y: number, z: number): void;
+        public _cacheFloat4(uniformName: string, x: number, y: number, z: number, w: number): void;
+        public setArray(uniformName: string, array: number[]): Effect;
+        public setMatrices(uniformName: string, matrices: Float32Array): Effect;
+        public setMatrix(uniformName: string, matrix: Matrix): Effect;
+        public setFloat(uniformName: string, value: number): Effect;
+        public setBool(uniformName: string, bool: boolean): Effect;
+        public setVector2(uniformName: string, vector2: Vector2): Effect;
+        public setFloat2(uniformName: string, x: number, y: number): Effect;
+        public setVector3(uniformName: string, vector3: Vector3): Effect;
+        public setFloat3(uniformName: string, x: number, y: number, z: number): Effect;
+        public setFloat4(uniformName: string, x: number, y: number, z: number, w: number): Effect;
+        public setColor3(uniformName: string, color3: Color3): Effect;
+        public setColor4(uniformName: string, color3: Color3, alpha: number): Effect;
+        static ShadersStore: {};
+    }
+}

Babylon/Materials/babylon.material.d.ts

@@ -0,0 +1,43 @@
+declare module BABYLON {
+    class Material {
+        public name: string;
+        private static _TriangleFillMode;
+        private static _WireFrameFillMode;
+        private static _PointFillMode;
+        static TriangleFillMode : number;
+        static WireFrameFillMode : number;
+        static PointFillMode : number;
+        public id: string;
+        public checkReadyOnEveryCall: boolean;
+        public checkReadyOnlyOnce: boolean;
+        public state: string;
+        public alpha: number;
+        public backFaceCulling: boolean;
+        public onCompiled: (effect: Effect) => void;
+        public onError: (effect: Effect, errors: string) => void;
+        public onDispose: () => void;
+        public onBind: (material: Material) => void;
+        public getRenderTargetTextures: () => SmartArray<RenderTargetTexture>;
+        public _effect: Effect;
+        public _wasPreviouslyReady: boolean;
+        private _scene;
+        private _fillMode;
+        public pointSize: number;
+        public wireframe : boolean;
+        public pointsCloud : boolean;
+        public fillMode : number;
+        constructor(name: string, scene: Scene, doNotAdd?: boolean);
+        public isReady(mesh?: AbstractMesh, useInstances?: boolean): boolean;
+        public getEffect(): Effect;
+        public getScene(): Scene;
+        public needAlphaBlending(): boolean;
+        public needAlphaTesting(): boolean;
+        public getAlphaTestTexture(): BaseTexture;
+        public trackCreation(onCompiled: (effect: Effect) => void, onError: (effect: Effect, errors: string) => void): void;
+        public _preBind(): void;
+        public bind(world: Matrix, mesh: Mesh): void;
+        public bindOnlyWorldMatrix(world: Matrix): void;
+        public unbind(): void;
+        public dispose(forceDisposeEffect?: boolean): void;
+    }
+}

Babylon/Materials/babylon.multiMaterial.d.ts

@@ -0,0 +1,8 @@
+declare module BABYLON {
+    class MultiMaterial extends Material {
+        public subMaterials: Material[];
+        constructor(name: string, scene: Scene);
+        public getSubMaterial(index: any): Material;
+        public isReady(mesh?: AbstractMesh): boolean;
+    }
+}

Babylon/Materials/babylon.shaderMaterial.d.ts

@@ -0,0 +1,32 @@
+declare module BABYLON {
+    class ShaderMaterial extends Material {
+        private _shaderPath;
+        private _options;
+        private _textures;
+        private _floats;
+        private _floatsArrays;
+        private _colors3;
+        private _colors4;
+        private _vectors2;
+        private _vectors3;
+        private _matrices;
+        private _cachedWorldViewMatrix;
+        private _renderId;
+        constructor(name: string, scene: Scene, shaderPath: any, options: any);
+        public needAlphaBlending(): boolean;
+        public needAlphaTesting(): boolean;
+        private _checkUniform(uniformName);
+        public setTexture(name: string, texture: Texture): ShaderMaterial;
+        public setFloat(name: string, value: number): ShaderMaterial;
+        public setFloats(name: string, value: number[]): ShaderMaterial;
+        public setColor3(name: string, value: Color3): ShaderMaterial;
+        public setColor4(name: string, value: Color4): ShaderMaterial;
+        public setVector2(name: string, value: Vector2): ShaderMaterial;
+        public setVector3(name: string, value: Vector3): ShaderMaterial;
+        public setMatrix(name: string, value: Matrix): ShaderMaterial;
+        public isReady(): boolean;
+        public bindOnlyWorldMatrix(world: Matrix): void;
+        public bind(world: Matrix): void;
+        public dispose(forceDisposeEffect?: boolean): void;
+    }
+}

Babylon/Materials/babylon.standardMaterial.d.ts

@@ -0,0 +1,57 @@
+declare module BABYLON {
+    class FresnelParameters {
+        public isEnabled: boolean;
+        public leftColor: Color3;
+        public rightColor: Color3;
+        public bias: number;
+        public power: number;
+    }
+    class StandardMaterial extends Material {
+        public diffuseTexture: BaseTexture;
+        public ambientTexture: BaseTexture;
+        public opacityTexture: BaseTexture;
+        public reflectionTexture: BaseTexture;
+        public emissiveTexture: BaseTexture;
+        public specularTexture: BaseTexture;
+        public bumpTexture: BaseTexture;
+        public ambientColor: Color3;
+        public diffuseColor: Color3;
+        public specularColor: Color3;
+        public specularPower: number;
+        public emissiveColor: Color3;
+        public useAlphaFromDiffuseTexture: boolean;
+        public useSpecularOverAlpha: boolean;
+        public fogEnabled: boolean;
+        public diffuseFresnelParameters: FresnelParameters;
+        public opacityFresnelParameters: FresnelParameters;
+        public reflectionFresnelParameters: FresnelParameters;
+        public emissiveFresnelParameters: FresnelParameters;
+        private _cachedDefines;
+        private _renderTargets;
+        private _worldViewProjectionMatrix;
+        private _globalAmbientColor;
+        private _scaledDiffuse;
+        private _scaledSpecular;
+        private _renderId;
+        constructor(name: string, scene: Scene);
+        public needAlphaBlending(): boolean;
+        public needAlphaTesting(): boolean;
+        private _shouldUseAlphaFromDiffuseTexture();
+        public getAlphaTestTexture(): BaseTexture;
+        public isReady(mesh?: AbstractMesh, useInstances?: boolean): boolean;
+        public unbind(): void;
+        public bindOnlyWorldMatrix(world: Matrix): void;
+        public bind(world: Matrix, mesh: Mesh): void;
+        public getAnimatables(): IAnimatable[];
+        public dispose(forceDisposeEffect?: boolean): void;
+        public clone(name: string): StandardMaterial;
+        static DiffuseTextureEnabled: boolean;
+        static AmbientTextureEnabled: boolean;
+        static OpacityTextureEnabled: boolean;
+        static ReflectionTextureEnabled: boolean;
+        static EmissiveTextureEnabled: boolean;
+        static SpecularTextureEnabled: boolean;
+        static BumpTextureEnabled: boolean;
+        static FresnelEnabled: boolean;
+    }
+}

Babylon/Math/babylon.math.d.ts

@@ -0,0 +1,368 @@
+declare module BABYLON {
+    class Color3 {
+        public r: number;
+        public g: number;
+        public b: number;
+        constructor(r?: number, g?: number, b?: number);
+        public toString(): string;
+        public toArray(array: number[], index?: number): void;
+        public toColor4(alpha?: number): Color4;
+        public asArray(): number[];
+        public toLuminance(): number;
+        public multiply(otherColor: Color3): Color3;
+        public multiplyToRef(otherColor: Color3, result: Color3): void;
+        public equals(otherColor: Color3): boolean;
+        public scale(scale: number): Color3;
+        public scaleToRef(scale: number, result: Color3): void;
+        public add(otherColor: Color3): Color3;
+        public addToRef(otherColor: Color3, result: Color3): void;
+        public subtract(otherColor: Color3): Color3;
+        public subtractToRef(otherColor: Color3, result: Color3): void;
+        public clone(): Color3;
+        public copyFrom(source: Color3): void;
+        public copyFromFloats(r: number, g: number, b: number): void;
+        static FromArray(array: number[]): Color3;
+        static FromInts(r: number, g: number, b: number): Color3;
+        static Lerp(start: Color3, end: Color3, amount: number): Color3;
+        static Red(): Color3;
+        static Green(): Color3;
+        static Blue(): Color3;
+        static Black(): Color3;
+        static White(): Color3;
+        static Purple(): Color3;
+        static Magenta(): Color3;
+        static Yellow(): Color3;
+        static Gray(): Color3;
+    }
+    class Color4 {
+        public r: number;
+        public g: number;
+        public b: number;
+        public a: number;
+        constructor(r: number, g: number, b: number, a: number);
+        public addInPlace(right: any): void;
+        public asArray(): number[];
+        public toArray(array: number[], index?: number): void;
+        public add(right: Color4): Color4;
+        public subtract(right: Color4): Color4;
+        public subtractToRef(right: Color4, result: Color4): void;
+        public scale(scale: number): Color4;
+        public scaleToRef(scale: number, result: Color4): void;
+        public toString(): string;
+        public clone(): Color4;
+        static Lerp(left: Color4, right: Color4, amount: number): Color4;
+        static LerpToRef(left: Color4, right: Color4, amount: number, result: Color4): void;
+        static FromArray(array: number[], offset?: number): Color4;
+        static FromInts(r: number, g: number, b: number, a: number): Color4;
+    }
+    class Vector2 {
+        public x: number;
+        public y: number;
+        constructor(x: number, y: number);
+        public toString(): string;
+        public toArray(array: number[], index?: number): void;
+        public asArray(): number[];
+        public copyFrom(source: Vector2): void;
+        public copyFromFloats(x: number, y: number): void;
+        public add(otherVector: Vector2): Vector2;
+        public addVector3(otherVector: Vector3): Vector2;
+        public subtract(otherVector: Vector2): Vector2;
+        public subtractInPlace(otherVector: Vector2): void;
+        public multiplyInPlace(otherVector: Vector2): void;
+        public multiply(otherVector: Vector2): Vector2;
+        public multiplyToRef(otherVector: Vector2, result: Vector2): void;
+        public multiplyByFloats(x: number, y: number): Vector2;
+        public divide(otherVector: Vector2): Vector2;
+        public divideToRef(otherVector: Vector2, result: Vector2): void;
+        public negate(): Vector2;
+        public scaleInPlace(scale: number): Vector2;
+        public scale(scale: number): Vector2;
+        public equals(otherVector: Vector2): boolean;
+        public length(): number;
+        public lengthSquared(): number;
+        public normalize(): Vector2;
+        public clone(): Vector2;
+        static Zero(): Vector2;
+        static FromArray(array: number[], offset?: number): Vector2;
+        static FromArrayToRef(array: number[], offset: number, result: Vector2): void;
+        static CatmullRom(value1: Vector2, value2: Vector2, value3: Vector2, value4: Vector2, amount: number): Vector2;
+        static Clamp(value: Vector2, min: Vector2, max: Vector2): Vector2;
+        static Hermite(value1: Vector2, tangent1: Vector2, value2: Vector2, tangent2: Vector2, amount: number): Vector2;
+        static Lerp(start: Vector2, end: Vector2, amount: number): Vector2;
+        static Dot(left: Vector2, right: Vector2): number;
+        static Normalize(vector: Vector2): Vector2;
+        static Minimize(left: Vector2, right: Vector2): Vector2;
+        static Maximize(left: Vector2, right: Vector2): Vector2;
+        static Transform(vector: Vector2, transformation: Matrix): Vector2;
+        static Distance(value1: Vector2, value2: Vector2): number;
+        static DistanceSquared(value1: Vector2, value2: Vector2): number;
+    }
+    class Vector3 {
+        public x: number;
+        public y: number;
+        public z: number;
+        constructor(x: number, y: number, z: number);
+        public toString(): string;
+        public asArray(): number[];
+        public toArray(array: number[], index?: number): void;
+        public addInPlace(otherVector: Vector3): void;
+        public add(otherVector: Vector3): Vector3;
+        public addToRef(otherVector: Vector3, result: Vector3): void;
+        public subtractInPlace(otherVector: Vector3): void;
+        public subtract(otherVector: Vector3): Vector3;
+        public subtractToRef(otherVector: Vector3, result: Vector3): void;
+        public subtractFromFloats(x: number, y: number, z: number): Vector3;
+        public subtractFromFloatsToRef(x: number, y: number, z: number, result: Vector3): void;
+        public negate(): Vector3;
+        public scaleInPlace(scale: number): Vector3;
+        public scale(scale: number): Vector3;
+        public scaleToRef(scale: number, result: Vector3): void;
+        public equals(otherVector: Vector3): boolean;
+        public equalsWithEpsilon(otherVector: Vector3): boolean;
+        public equalsToFloats(x: number, y: number, z: number): boolean;
+        public multiplyInPlace(otherVector: Vector3): void;
+        public multiply(otherVector: Vector3): Vector3;
+        public multiplyToRef(otherVector: Vector3, result: Vector3): void;
+        public multiplyByFloats(x: number, y: number, z: number): Vector3;
+        public divide(otherVector: Vector3): Vector3;
+        public divideToRef(otherVector: Vector3, result: Vector3): void;
+        public MinimizeInPlace(other: Vector3): void;
+        public MaximizeInPlace(other: Vector3): void;
+        public length(): number;
+        public lengthSquared(): number;
+        public normalize(): Vector3;
+        public clone(): Vector3;
+        public copyFrom(source: Vector3): void;
+        public copyFromFloats(x: number, y: number, z: number): void;
+        static FromArray(array: number[], offset?: number): Vector3;
+        static FromArrayToRef(array: number[], offset: number, result: Vector3): void;
+        static FromFloatArrayToRef(array: Float32Array, offset: number, result: Vector3): void;
+        static FromFloatsToRef(x: number, y: number, z: number, result: Vector3): void;
+        static Zero(): Vector3;
+        static Up(): Vector3;
+        static TransformCoordinates(vector: Vector3, transformation: Matrix): Vector3;
+        static TransformCoordinatesToRef(vector: Vector3, transformation: Matrix, result: Vector3): void;
+        static TransformCoordinatesFromFloatsToRef(x: number, y: number, z: number, transformation: Matrix, result: Vector3): void;
+        static TransformNormal(vector: Vector3, transformation: Matrix): Vector3;
+        static TransformNormalToRef(vector: Vector3, transformation: Matrix, result: Vector3): void;
+        static TransformNormalFromFloatsToRef(x: number, y: number, z: number, transformation: Matrix, result: Vector3): void;
+        static CatmullRom(value1: Vector3, value2: Vector3, value3: Vector3, value4: Vector3, amount: number): Vector3;
+        static Clamp(value: Vector3, min: Vector3, max: Vector3): Vector3;
+        static Hermite(value1: Vector3, tangent1: Vector3, value2: Vector3, tangent2: Vector3, amount: number): Vector3;
+        static Lerp(start: Vector3, end: Vector3, amount: number): Vector3;
+        static Dot(left: Vector3, right: Vector3): number;
+        static Cross(left: Vector3, right: Vector3): Vector3;
+        static CrossToRef(left: Vector3, right: Vector3, result: Vector3): void;
+        static Normalize(vector: Vector3): Vector3;
+        static NormalizeToRef(vector: Vector3, result: Vector3): void;
+        static Project(vector: Vector3, world: Matrix, transform: Matrix, viewport: Viewport): Vector3;
+        static UnprojectFromTransform(source: Vector3, viewportWidth: number, viewportHeight: number, world: Matrix, transform: Matrix): Vector3;
+        static Unproject(source: Vector3, viewportWidth: number, viewportHeight: number, world: Matrix, view: Matrix, projection: Matrix): Vector3;
+        static Minimize(left: Vector3, right: Vector3): Vector3;
+        static Maximize(left: Vector3, right: Vector3): Vector3;
+        static Distance(value1: Vector3, value2: Vector3): number;
+        static DistanceSquared(value1: Vector3, value2: Vector3): number;
+        static Center(value1: Vector3, value2: Vector3): Vector3;
+    }
+    class Vector4 {
+        public x: number;
+        public y: number;
+        public z: number;
+        public w: number;
+        constructor(x: number, y: number, z: number, w: number);
+        public toString(): string;
+        public asArray(): number[];
+        public toArray(array: number[], index?: number): void;
+        public addInPlace(otherVector: Vector4): void;
+        public add(otherVector: Vector4): Vector4;
+        public addToRef(otherVector: Vector4, result: Vector4): void;
+        public subtractInPlace(otherVector: Vector4): void;
+        public subtract(otherVector: Vector4): Vector4;
+        public subtractToRef(otherVector: Vector4, result: Vector4): void;
+        public subtractFromFloats(x: number, y: number, z: number, w: number): Vector4;
+        public subtractFromFloatsToRef(x: number, y: number, z: number, w: number, result: Vector4): void;
+        public negate(): Vector4;
+        public scaleInPlace(scale: number): Vector4;
+        public scale(scale: number): Vector4;
+        public scaleToRef(scale: number, result: Vector4): void;
+        public equals(otherVector: Vector4): boolean;
+        public equalsWithEpsilon(otherVector: Vector4): boolean;
+        public equalsToFloats(x: number, y: number, z: number, w: number): boolean;
+        public multiplyInPlace(otherVector: Vector4): void;
+        public multiply(otherVector: Vector4): Vector4;
+        public multiplyToRef(otherVector: Vector4, result: Vector4): void;
+        public multiplyByFloats(x: number, y: number, z: number, w: number): Vector4;
+        public divide(otherVector: Vector4): Vector4;
+        public divideToRef(otherVector: Vector4, result: Vector4): void;
+        public MinimizeInPlace(other: Vector4): void;
+        public MaximizeInPlace(other: Vector4): void;
+        public length(): number;
+        public lengthSquared(): number;
+        public normalize(): Vector4;
+        public clone(): Vector4;
+        public copyFrom(source: Vector4): void;
+        public copyFromFloats(x: number, y: number, z: number, w: number): void;
+        static FromArray(array: number[], offset?: number): Vector4;
+        static FromArrayToRef(array: number[], offset: number, result: Vector4): void;
+        static FromFloatArrayToRef(array: Float32Array, offset: number, result: Vector4): void;
+        static FromFloatsToRef(x: number, y: number, z: number, w: number, result: Vector4): void;
+        static Zero(): Vector4;
+        static Normalize(vector: Vector4): Vector4;
+        static NormalizeToRef(vector: Vector4, result: Vector4): void;
+        static Minimize(left: Vector4, right: Vector4): Vector4;
+        static Maximize(left: Vector4, right: Vector4): Vector4;
+        static Distance(value1: Vector4, value2: Vector4): number;
+        static DistanceSquared(value1: Vector4, value2: Vector4): number;
+        static Center(value1: Vector4, value2: Vector4): Vector4;
+    }
+    class Quaternion {
+        public x: number;
+        public y: number;
+        public z: number;
+        public w: number;
+        constructor(x?: number, y?: number, z?: number, w?: number);
+        public toString(): string;
+        public asArray(): number[];
+        public equals(otherQuaternion: Quaternion): boolean;
+        public clone(): Quaternion;
+        public copyFrom(other: Quaternion): void;
+        public copyFromFloats(x: number, y: number, z: number, w: number): void;
+        public add(other: Quaternion): Quaternion;
+        public subtract(other: Quaternion): Quaternion;
+        public scale(value: number): Quaternion;
+        public multiply(q1: Quaternion): Quaternion;
+        public multiplyToRef(q1: Quaternion, result: Quaternion): void;
+        public length(): number;
+        public normalize(): void;
+        public toEulerAngles(): Vector3;
+        public toEulerAnglesToRef(result: Vector3): void;
+        public toRotationMatrix(result: Matrix): void;
+        public fromRotationMatrix(matrix: Matrix): void;
+        static Inverse(q: Quaternion): Quaternion;
+        static RotationAxis(axis: Vector3, angle: number): Quaternion;
+        static FromArray(array: number[], offset?: number): Quaternion;
+        static RotationYawPitchRoll(yaw: number, pitch: number, roll: number): Quaternion;
+        static RotationYawPitchRollToRef(yaw: number, pitch: number, roll: number, result: Quaternion): void;
+        static Slerp(left: Quaternion, right: Quaternion, amount: number): Quaternion;
+    }
+    class Matrix {
+        private static _tempQuaternion;
+        private static _xAxis;
+        private static _yAxis;
+        private static _zAxis;
+        public m: Float32Array;
+        public isIdentity(): boolean;
+        public determinant(): number;
+        public toArray(): Float32Array;
+        public asArray(): Float32Array;
+        public invert(): void;
+        public invertToRef(other: Matrix): void;
+        public setTranslation(vector3: Vector3): void;
+        public multiply(other: Matrix): Matrix;
+        public copyFrom(other: Matrix): void;
+        public copyToArray(array: Float32Array, offset?: number): void;
+        public multiplyToRef(other: Matrix, result: Matrix): void;
+        public multiplyToArray(other: Matrix, result: Float32Array, offset: number): void;
+        public equals(value: Matrix): boolean;
+        public clone(): Matrix;
+        static FromArray(array: number[], offset?: number): Matrix;
+        static FromArrayToRef(array: number[], offset: number, result: Matrix): void;
+        static FromValuesToRef(initialM11: number, initialM12: number, initialM13: number, initialM14: number, initialM21: number, initialM22: number, initialM23: number, initialM24: number, initialM31: number, initialM32: number, initialM33: number, initialM34: number, initialM41: number, initialM42: number, initialM43: number, initialM44: number, result: Matrix): void;
+        static FromValues(initialM11: number, initialM12: number, initialM13: number, initialM14: number, initialM21: number, initialM22: number, initialM23: number, initialM24: number, initialM31: number, initialM32: number, initialM33: number, initialM34: number, initialM41: number, initialM42: number, initialM43: number, initialM44: number): Matrix;
+        static Identity(): Matrix;
+        static IdentityToRef(result: Matrix): void;
+        static Zero(): Matrix;
+        static RotationX(angle: number): Matrix;
+        static Invert(source: Matrix): Matrix;
+        static RotationXToRef(angle: number, result: Matrix): void;
+        static RotationY(angle: number): Matrix;
+        static RotationYToRef(angle: number, result: Matrix): void;
+        static RotationZ(angle: number): Matrix;
+        static RotationZToRef(angle: number, result: Matrix): void;
+        static RotationAxis(axis: Vector3, angle: number): Matrix;
+        static RotationYawPitchRoll(yaw: number, pitch: number, roll: number): Matrix;
+        static RotationYawPitchRollToRef(yaw: number, pitch: number, roll: number, result: Matrix): void;
+        static Scaling(x: number, y: number, z: number): Matrix;
+        static ScalingToRef(x: number, y: number, z: number, result: Matrix): void;
+        static Translation(x: number, y: number, z: number): Matrix;
+        static TranslationToRef(x: number, y: number, z: number, result: Matrix): void;
+        static LookAtLH(eye: Vector3, target: Vector3, up: Vector3): Matrix;
+        static LookAtLHToRef(eye: Vector3, target: Vector3, up: Vector3, result: Matrix): void;
+        static OrthoLH(width: number, height: number, znear: number, zfar: number): Matrix;
+        static OrthoOffCenterLH(left: number, right: number, bottom: number, top: number, znear: number, zfar: number): Matrix;
+        static OrthoOffCenterLHToRef(left: number, right: any, bottom: number, top: number, znear: number, zfar: number, result: Matrix): void;
+        static PerspectiveLH(width: number, height: number, znear: number, zfar: number): Matrix;
+        static PerspectiveFovLH(fov: number, aspect: number, znear: number, zfar: number): Matrix;
+        static PerspectiveFovLHToRef(fov: number, aspect: number, znear: number, zfar: number, result: Matrix): void;
+        static GetFinalMatrix(viewport: Viewport, world: Matrix, view: Matrix, projection: Matrix, zmin: number, zmax: number): Matrix;
+        static Transpose(matrix: Matrix): Matrix;
+        static Reflection(plane: Plane): Matrix;
+        static ReflectionToRef(plane: Plane, result: Matrix): void;
+    }
+    class Plane {
+        public normal: Vector3;
+        public d: number;
+        constructor(a: number, b: number, c: number, d: number);
+        public asArray(): number[];
+        public clone(): Plane;
+        public normalize(): void;
+        public transform(transformation: Matrix): Plane;
+        public dotCoordinate(point: any): number;
+        public copyFromPoints(point1: Vector3, point2: Vector3, point3: Vector3): void;
+        public isFrontFacingTo(direction: Vector3, epsilon: number): boolean;
+        public signedDistanceTo(point: Vector3): number;
+        static FromArray(array: number[]): Plane;
+        static FromPoints(point1: any, point2: any, point3: any): Plane;
+        static FromPositionAndNormal(origin: Vector3, normal: Vector3): Plane;
+        static SignedDistanceToPlaneFromPositionAndNormal(origin: Vector3, normal: Vector3, point: Vector3): number;
+    }
+    class Viewport {
+        public x: number;
+        public y: number;
+        public width: number;
+        public height: number;
+        constructor(x: number, y: number, width: number, height: number);
+        public toGlobal(engine: any): Viewport;
+    }
+    class Frustum {
+        static GetPlanes(transform: Matrix): Plane[];
+        static GetPlanesToRef(transform: Matrix, frustumPlanes: Plane[]): void;
+    }
+    class Ray {
+        public origin: Vector3;
+        public direction: Vector3;
+        public length: number;
+        private _edge1;
+        private _edge2;
+        private _pvec;
+        private _tvec;
+        private _qvec;
+        constructor(origin: Vector3, direction: Vector3, length?: number);
+        public intersectsBoxMinMax(minimum: Vector3, maximum: Vector3): boolean;
+        public intersectsBox(box: BoundingBox): boolean;
+        public intersectsSphere(sphere: any): boolean;
+        public intersectsTriangle(vertex0: Vector3, vertex1: Vector3, vertex2: Vector3): IntersectionInfo;
+        static CreateNew(x: number, y: number, viewportWidth: number, viewportHeight: number, world: Matrix, view: Matrix, projection: Matrix): Ray;
+        /**
+        * Function will create a new transformed ray starting from origin and ending at the end point. Ray's length will be set, and ray will be
+        * transformed to the given world matrix.
+        * @param origin The origin point
+        * @param end The end point
+        * @param world a matrix to transform the ray to. Default is the identity matrix.
+        */
+        static CreateNewFromTo(origin: Vector3, end: Vector3, world?: Matrix): Ray;
+        static Transform(ray: Ray, matrix: Matrix): Ray;
+    }
+    enum Space {
+        LOCAL = 0,
+        WORLD = 1,
+    }
+    class Axis {
+        static X: Vector3;
+        static Y: Vector3;
+        static Z: Vector3;
+    }
+    class BezierCurve {
+        static interpolate(t: number, x1: number, y1: number, x2: number, y2: number): number;
+    }
+}

Babylon/Mesh/babylon.abstractMesh.d.ts

@@ -0,0 +1,143 @@
+declare module BABYLON {
+    class AbstractMesh extends Node implements IDisposable {
+        private static _BILLBOARDMODE_NONE;
+        private static _BILLBOARDMODE_X;
+        private static _BILLBOARDMODE_Y;
+        private static _BILLBOARDMODE_Z;
+        private static _BILLBOARDMODE_ALL;
+        static BILLBOARDMODE_NONE : number;
+        static BILLBOARDMODE_X : number;
+        static BILLBOARDMODE_Y : number;
+        static BILLBOARDMODE_Z : number;
+        static BILLBOARDMODE_ALL : number;
+        public position: Vector3;
+        public rotation: Vector3;
+        public rotationQuaternion: Quaternion;
+        public scaling: Vector3;
+        public billboardMode: number;
+        public visibility: number;
+        public alphaIndex: number;
+        public infiniteDistance: boolean;
+        public isVisible: boolean;
+        public isPickable: boolean;
+        public showBoundingBox: boolean;
+        public showSubMeshesBoundingBox: boolean;
+        public onDispose: any;
+        public checkCollisions: boolean;
+        public isBlocker: boolean;
+        public skeleton: Skeleton;
+        public renderingGroupId: number;
+        public material: Material;
+        public receiveShadows: boolean;
+        public actionManager: ActionManager;
+        public renderOutline: boolean;
+        public outlineColor: Color3;
+        public outlineWidth: number;
+        public renderOverlay: boolean;
+        public overlayColor: Color3;
+        public overlayAlpha: number;
+        public hasVertexAlpha: boolean;
+        public useVertexColors: boolean;
+        public applyFog: boolean;
+        public useOctreeForRenderingSelection: boolean;
+        public useOctreeForPicking: boolean;
+        public useOctreeForCollisions: boolean;
+        public layerMask: number;
+        public _physicImpostor: number;
+        public _physicsMass: number;
+        public _physicsFriction: number;
+        public _physicRestitution: number;
+        public ellipsoid: Vector3;
+        public ellipsoidOffset: Vector3;
+        private _collider;
+        private _oldPositionForCollisions;
+        private _diffPositionForCollisions;
+        private _newPositionForCollisions;
+        private _localScaling;
+        private _localRotation;
+        private _localTranslation;
+        private _localBillboard;
+        private _localPivotScaling;
+        private _localPivotScalingRotation;
+        private _localWorld;
+        public _worldMatrix: Matrix;
+        private _rotateYByPI;
+        private _absolutePosition;
+        private _collisionsTransformMatrix;
+        private _collisionsScalingMatrix;
+        public _positions: Vector3[];
+        private _isDirty;
+        public _masterMesh: AbstractMesh;
+        public _boundingInfo: BoundingInfo;
+        private _pivotMatrix;
+        public _isDisposed: boolean;
+        public _renderId: number;
+        public subMeshes: SubMesh[];
+        public _submeshesOctree: Octree<SubMesh>;
+        public _intersectionsInProgress: AbstractMesh[];
+        private _onAfterWorldMatrixUpdate;
+        constructor(name: string, scene: Scene);
+        public isBlocked : boolean;
+        public getLOD(camera: Camera): AbstractMesh;
+        public getTotalVertices(): number;
+        public getIndices(): number[];
+        public getVerticesData(kind: string): number[];
+        public isVerticesDataPresent(kind: string): boolean;
+        public getBoundingInfo(): BoundingInfo;
+        public _preActivate(): void;
+        public _activate(renderId: number): void;
+        public getWorldMatrix(): Matrix;
+        public worldMatrixFromCache : Matrix;
+        public absolutePosition : Vector3;
+        public rotate(axis: Vector3, amount: number, space: Space): void;
+        public translate(axis: Vector3, distance: number, space: Space): void;
+        public getAbsolutePosition(): Vector3;
+        public setAbsolutePosition(absolutePosition: Vector3): void;
+        public setPivotMatrix(matrix: Matrix): void;
+        public getPivotMatrix(): Matrix;
+        public _isSynchronized(): boolean;
+        public _initCache(): void;
+        public markAsDirty(property: string): void;
+        public _updateBoundingInfo(): void;
+        public _updateSubMeshesBoundingInfo(matrix: Matrix): void;
+        public computeWorldMatrix(force?: boolean): Matrix;
+        /**
+        * If you'd like to be callbacked after the mesh position, rotation or scaling has been updated
+        * @param func: callback function to add
+        */
+        public registerAfterWorldMatrixUpdate(func: (mesh: AbstractMesh) => void): void;
+        public unregisterAfterWorldMatrixUpdate(func: (mesh: AbstractMesh) => void): void;
+        public setPositionWithLocalVector(vector3: Vector3): void;
+        public getPositionExpressedInLocalSpace(): Vector3;
+        public locallyTranslate(vector3: Vector3): void;
+        public lookAt(targetPoint: Vector3, yawCor: number, pitchCor: number, rollCor: number): void;
+        public isInFrustum(frustumPlanes: Plane[]): boolean;
+        public isCompletelyInFrustum(camera?: Camera): boolean;
+        public intersectsMesh(mesh: AbstractMesh, precise?: boolean): boolean;
+        public intersectsPoint(point: Vector3): boolean;
+        public setPhysicsState(impostor?: any, options?: PhysicsBodyCreationOptions): any;
+        public getPhysicsImpostor(): number;
+        public getPhysicsMass(): number;
+        public getPhysicsFriction(): number;
+        public getPhysicsRestitution(): number;
+        public getPositionInCameraSpace(camera?: Camera): Vector3;
+        public getDistanceToCamera(camera?: Camera): number;
+        public applyImpulse(force: Vector3, contactPoint: Vector3): void;
+        public setPhysicsLinkWith(otherMesh: Mesh, pivot1: Vector3, pivot2: Vector3, options?: any): void;
+        public updatePhysicsBodyPosition(): void;
+        public moveWithCollisions(velocity: Vector3): void;
+        /**
+        * This function will create an octree to help select the right submeshes for rendering, picking and collisions
+        * Please note that you must have a decent number of submeshes to get performance improvements when using octree
+        */
+        public createOrUpdateSubmeshesOctree(maxCapacity?: number, maxDepth?: number): Octree<SubMesh>;
+        public _collideForSubMesh(subMesh: SubMesh, transformMatrix: Matrix, collider: Collider): void;
+        public _processCollisionsForSubMeshes(collider: Collider, transformMatrix: Matrix): void;
+        public _checkCollision(collider: Collider): void;
+        public _generatePointsArray(): boolean;
+        public intersects(ray: Ray, fastCheck?: boolean): PickingInfo;
+        public clone(name: string, newParent: Node, doNotCloneChildren?: boolean): AbstractMesh;
+        public releaseSubMeshes(): void;
+        public dispose(doNotRecurse?: boolean): void;
+    }
+}

Babylon/Mesh/babylon.csg.d.ts

@@ -0,0 +1,24 @@
+declare module BABYLON {
+    class CSG {
+        private polygons;
+        public matrix: Matrix;
+        public position: Vector3;
+        public rotation: Vector3;
+        public scaling: Vector3;
+        static FromMesh(mesh: Mesh): CSG;
+        private static FromPolygons(polygons);
+        public clone(): CSG;
+        private toPolygons();
+        public union(csg: CSG): CSG;
+        public unionInPlace(csg: CSG): void;
+        public subtract(csg: CSG): CSG;
+        public subtractInPlace(csg: CSG): void;
+        public intersect(csg: CSG): CSG;
+        public intersectInPlace(csg: CSG): void;
+        public inverse(): CSG;
+        public inverseInPlace(): void;
+        public copyTransformAttributes(csg: CSG): CSG;
+        public buildMeshGeometry(name: string, scene: Scene, keepSubMeshes: boolean): Mesh;
+        public toMesh(name: string, material: Material, scene: Scene, keepSubMeshes: boolean): Mesh;
+    }
+}

Babylon/Mesh/babylon.geometry.d.ts

@@ -0,0 +1,136 @@
+declare module BABYLON {
+    class Geometry implements IGetSetVerticesData {
+        public id: string;
+        public delayLoadState: number;
+        public delayLoadingFile: string;
+        private _scene;
+        private _engine;
+        private _meshes;
+        private _totalVertices;
+        private _indices;
+        private _vertexBuffers;
+        public _delayInfo: any;
+        private _indexBuffer;
+        public _boundingInfo: BoundingInfo;
+        public _delayLoadingFunction: (any: any, Geometry: any) => void;
+        constructor(id: string, scene: Scene, vertexData?: VertexData, updatable?: boolean, mesh?: Mesh);
+        public getScene(): Scene;
+        public getEngine(): Engine;
+        public isReady(): boolean;
+        public setAllVerticesData(vertexData: VertexData, updatable?: boolean): void;
+        public setVerticesData(kind: string, data: number[], updatable?: boolean, stride?: number): void;
+        public updateVerticesDataDirectly(kind: string, data: Float32Array, offset: number): void;
+        public updateVerticesData(kind: string, data: number[], updateExtends?: boolean): void;
+        public getTotalVertices(): number;
+        public getVerticesData(kind: string): number[];
+        public getVertexBuffer(kind: string): VertexBuffer;
+        public getVertexBuffers(): VertexBuffer[];
+        public isVerticesDataPresent(kind: string): boolean;
+        public getVerticesDataKinds(): string[];
+        public setIndices(indices: number[], totalVertices?: number): void;
+        public getTotalIndices(): number;
+        public getIndices(): number[];
+        public getIndexBuffer(): any;
+        public releaseForMesh(mesh: Mesh, shouldDispose?: boolean): void;
+        public applyToMesh(mesh: Mesh): void;
+        private _applyToMesh(mesh);
+        public load(scene: Scene, onLoaded?: () => void): void;
+        public dispose(): void;
+        public copy(id: string): Geometry;
+        static ExtractFromMesh(mesh: Mesh, id: string): Geometry;
+        static RandomId(): string;
+    }
+    module Geometry.Primitives {
+        class _Primitive extends Geometry {
+            private _beingRegenerated;
+            private _canBeRegenerated;
+            constructor(id: string, scene: Scene, vertexData?: VertexData, canBeRegenerated?: boolean, mesh?: Mesh);
+            public canBeRegenerated(): boolean;
+            public regenerate(): void;
+            public asNewGeometry(id: string): Geometry;
+            public setAllVerticesData(vertexData: VertexData, updatable?: boolean): void;
+            public setVerticesData(kind: string, data: number[], updatable?: boolean): void;
+            public _regenerateVertexData(): VertexData;
+            public copy(id: string): Geometry;
+        }
+        class Box extends _Primitive {
+            public size: number;
+            constructor(id: string, scene: Scene, size: number, canBeRegenerated?: boolean, mesh?: Mesh);
+            public _regenerateVertexData(): VertexData;
+            public copy(id: string): Geometry;
+        }
+        class Sphere extends _Primitive {
+            public segments: number;
+            public diameter: number;
+            constructor(id: string, scene: Scene, segments: number, diameter: number, canBeRegenerated?: boolean, mesh?: Mesh);
+            public _regenerateVertexData(): VertexData;
+            public copy(id: string): Geometry;
+        }
+        class Cylinder extends _Primitive {
+            public height: number;
+            public diameterTop: number;
+            public diameterBottom: number;
+            public tessellation: number;
+            public subdivisions: number;
+            constructor(id: string, scene: Scene, height: number, diameterTop: number, diameterBottom: number, tessellation: number, subdivisions?: number, canBeRegenerated?: boolean, mesh?: Mesh);
+            public _regenerateVertexData(): VertexData;
+            public copy(id: string): Geometry;
+        }
+        class Torus extends _Primitive {
+            public diameter: number;
+            public thickness: number;
+            public tessellation: number;
+            constructor(id: string, scene: Scene, diameter: number, thickness: number, tessellation: number, canBeRegenerated?: boolean, mesh?: Mesh);
+            public _regenerateVertexData(): VertexData;
+            public copy(id: string): Geometry;
+        }
+        class Ground extends _Primitive {
+            public width: number;
+            public height: number;
+            public subdivisions: number;
+            constructor(id: string, scene: Scene, width: number, height: number, subdivisions: number, canBeRegenerated?: boolean, mesh?: Mesh);
+            public _regenerateVertexData(): VertexData;
+            public copy(id: string): Geometry;
+        }
+        class TiledGround extends _Primitive {
+            public xmin: number;
+            public zmin: number;
+            public xmax: number;
+            public zmax: number;
+            public subdivisions: {
+                w: number;
+                h: number;
+            };
+            public precision: {
+                w: number;
+                h: number;
+            };
+            constructor(id: string, scene: Scene, xmin: number, zmin: number, xmax: number, zmax: number, subdivisions: {
+                w: number;
+                h: number;
+            }, precision: {
+                w: number;
+                h: number;
+            }, canBeRegenerated?: boolean, mesh?: Mesh);
+            public _regenerateVertexData(): VertexData;
+            public copy(id: string): Geometry;
+        }
+        class Plane extends _Primitive {
+            public size: number;
+            constructor(id: string, scene: Scene, size: number, canBeRegenerated?: boolean, mesh?: Mesh);
+            public _regenerateVertexData(): VertexData;
+            public copy(id: string): Geometry;
+        }
+        class TorusKnot extends _Primitive {
+            public radius: number;
+            public tube: number;
+            public radialSegments: number;
+            public tubularSegments: number;
+            public p: number;
+            public q: number;
+            constructor(id: string, scene: Scene, radius: number, tube: number, radialSegments: number, tubularSegments: number, p: number, q: number, canBeRegenerated?: boolean, mesh?: Mesh);
+            public _regenerateVertexData(): VertexData;
+            public copy(id: string): Geometry;
+        }
+    }
+}

Babylon/Mesh/babylon.groundMesh.d.ts

@@ -0,0 +1,11 @@
+declare module BABYLON {
+    class GroundMesh extends Mesh {
+        public generateOctree: boolean;
+        private _worldInverse;
+        public _subdivisions: number;
+        constructor(name: string, scene: Scene);
+        public subdivisions : number;
+        public optimize(chunksCount: number): void;
+        public getHeightAtCoordinates(x: number, z: number): number;
+    }
+}

Babylon/Mesh/babylon.instancedMesh.d.ts

@@ -0,0 +1,25 @@
+declare module BABYLON {
+    class InstancedMesh extends AbstractMesh {
+        private _sourceMesh;
+        private _currentLOD;
+        constructor(name: string, source: Mesh);
+        public receiveShadows : boolean;
+        public material : Material;
+        public visibility : number;
+        public skeleton : Skeleton;
+        public getTotalVertices(): number;
+        public sourceMesh : Mesh;
+        public getVerticesData(kind: string): number[];
+        public isVerticesDataPresent(kind: string): boolean;
+        public getIndices(): number[];
+        public _positions : Vector3[];
+        public refreshBoundingInfo(): void;
+        public _preActivate(): void;
+        public _activate(renderId: number): void;
+        public getLOD(camera: Camera): AbstractMesh;
+        public _syncSubMeshes(): void;
+        public _generatePointsArray(): boolean;
+        public clone(name: string, newParent: Node, doNotCloneChildren?: boolean): InstancedMesh;
+        public dispose(doNotRecurse?: boolean): void;
+    }
+}

Babylon/Mesh/babylon.linesMesh.d.ts

@@ -0,0 +1,18 @@
+declare module BABYLON {
+    class LinesMesh extends Mesh {
+        public color: Color3;
+        public alpha: number;
+        private _colorShader;
+        private _ib;
+        private _indicesLength;
+        private _indices;
+        constructor(name: string, scene: Scene, updatable?: boolean);
+        public material : Material;
+        public isPickable : boolean;
+        public checkCollisions : boolean;
+        public _bind(subMesh: SubMesh, effect: Effect, fillMode: number): void;
+        public _draw(subMesh: SubMesh, fillMode: number, instancesCount?: number): void;
+        public intersects(ray: Ray, fastCheck?: boolean): any;
+        public dispose(doNotRecurse?: boolean): void;
+    }
+}

Babylon/Mesh/babylon.mesh.d.ts

@@ -0,0 +1,102 @@
+declare module BABYLON {
+    class _InstancesBatch {
+        public mustReturn: boolean;
+        public visibleInstances: InstancedMesh[][];
+        public renderSelf: boolean[];
+    }
+    class Mesh extends AbstractMesh implements IGetSetVerticesData {
+        public delayLoadState: number;
+        public instances: InstancedMesh[];
+        public delayLoadingFile: string;
+        public _binaryInfo: any;
+        private _LODLevels;
+        public _geometry: Geometry;
+        private _onBeforeRenderCallbacks;
+        private _onAfterRenderCallbacks;
+        public _delayInfo: any;
+        public _delayLoadingFunction: (any: any, Mesh: any) => void;
+        public _visibleInstances: any;
+        private _renderIdForInstances;
+        private _batchCache;
+        private _worldMatricesInstancesBuffer;
+        private _worldMatricesInstancesArray;
+        private _instancesBufferSize;
+        public _shouldGenerateFlatShading: boolean;
+        private _preActivateId;
+        constructor(name: string, scene: Scene);
+        public hasLODLevels : boolean;
+        private _sortLODLevels();
+        public addLODLevel(distance: number, mesh: Mesh): Mesh;
+        public removeLODLevel(mesh: Mesh): Mesh;
+        public getLOD(camera: Camera, boundingSphere?: BoundingSphere): AbstractMesh;
+        public geometry : Geometry;
+        public getTotalVertices(): number;
+        public getVerticesData(kind: string): number[];
+        public getVertexBuffer(kind: any): VertexBuffer;
+        public isVerticesDataPresent(kind: string): boolean;
+        public getVerticesDataKinds(): string[];
+        public getTotalIndices(): number;
+        public getIndices(): number[];
+        public isBlocked : boolean;
+        public isReady(): boolean;
+        public isDisposed(): boolean;
+        public _preActivate(): void;
+        public _registerInstanceForRenderId(instance: InstancedMesh, renderId: number): void;
+        public refreshBoundingInfo(): void;
+        public _createGlobalSubMesh(): SubMesh;
+        public subdivide(count: number): void;
+        public setVerticesData(kind: any, data: any, updatable?: boolean, stride?: number): void;
+        public updateVerticesData(kind: string, data: number[], updateExtends?: boolean, makeItUnique?: boolean): void;
+        public updateVerticesDataDirectly(kind: string, data: Float32Array, offset?: number, makeItUnique?: boolean): void;
+        public makeGeometryUnique(): void;
+        public setIndices(indices: number[], totalVertices?: number): void;
+        public _bind(subMesh: SubMesh, effect: Effect, fillMode: number): void;
+        public _draw(subMesh: SubMesh, fillMode: number, instancesCount?: number): void;
+        public registerBeforeRender(func: () => void): void;
+        public unregisterBeforeRender(func: () => void): void;
+        public registerAfterRender(func: () => void): void;
+        public unregisterAfterRender(func: () => void): void;
+        public _getInstancesRenderList(subMeshId: number): _InstancesBatch;
+        public _renderWithInstances(subMesh: SubMesh, fillMode: number, batch: _InstancesBatch, effect: Effect, engine: Engine): void;
+        public render(subMesh: SubMesh): void;
+        public getEmittedParticleSystems(): ParticleSystem[];
+        public getHierarchyEmittedParticleSystems(): ParticleSystem[];
+        public getChildren(): Node[];
+        public _checkDelayState(): void;
+        public isInFrustum(frustumPlanes: Plane[]): boolean;
+        public setMaterialByID(id: string): void;
+        public getAnimatables(): IAnimatable[];
+        public bakeTransformIntoVertices(transform: Matrix): void;
+        public _resetPointsArrayCache(): void;
+        public _generatePointsArray(): boolean;
+        public clone(name: string, newParent: Node, doNotCloneChildren?: boolean): Mesh;
+        public dispose(doNotRecurse?: boolean): void;
+        public applyDisplacementMap(url: string, minHeight: number, maxHeight: number): void;
+        public applyDisplacementMapFromBuffer(buffer: Uint8Array, heightMapWidth: number, heightMapHeight: number, minHeight: number, maxHeight: number): void;
+        public convertToFlatShadedMesh(): void;
+        public createInstance(name: string): InstancedMesh;
+        public synchronizeInstances(): void;
+        static CreateBox(name: string, size: number, scene: Scene, updatable?: boolean): Mesh;
+        static CreateSphere(name: string, segments: number, diameter: number, scene: Scene, updatable?: boolean): Mesh;
+        static CreateCylinder(name: string, height: number, diameterTop: number, diameterBottom: number, tessellation: number, subdivisions: any, scene: Scene, updatable?: any): Mesh;
+        static CreateTorus(name: string, diameter: number, thickness: number, tessellation: number, scene: Scene, updatable?: boolean): Mesh;
+        static CreateTorusKnot(name: string, radius: number, tube: number, radialSegments: number, tubularSegments: number, p: number, q: number, scene: Scene, updatable?: boolean): Mesh;
+        static CreateLines(name: string, points: Vector3[], scene: Scene, updatable?: boolean): LinesMesh;
+        static CreatePlane(name: string, size: number, scene: Scene, updatable?: boolean): Mesh;
+        static CreateGround(name: string, width: number, height: number, subdivisions: number, scene: Scene, updatable?: boolean): Mesh;
+        static CreateTiledGround(name: string, xmin: number, zmin: number, xmax: number, zmax: number, subdivisions: {
+            w: number;
+            h: number;
+        }, precision: {
+            w: number;
+            h: number;
+        }, scene: Scene, updatable?: boolean): Mesh;
+        static CreateGroundFromHeightMap(name: string, url: string, width: number, height: number, subdivisions: number, minHeight: number, maxHeight: number, scene: Scene, updatable?: boolean): GroundMesh;
+        static MinMax(meshes: AbstractMesh[]): {
+            min: Vector3;
+            max: Vector3;
+        };
+        static Center(meshesOrMinMaxVector: any): Vector3;
+        static MergeMeshes(meshes: Mesh[], disposeSource?: boolean, allow32BitsIndices?: boolean): Mesh;
+    }
+}

Babylon/Mesh/babylon.mesh.vertexData.d.ts

@@ -0,0 +1,49 @@
+declare module BABYLON {
+    interface IGetSetVerticesData {
+        isVerticesDataPresent(kind: string): boolean;
+        getVerticesData(kind: string): number[];
+        getIndices(): number[];
+        setVerticesData(kind: string, data: number[], updatable?: boolean): void;
+        updateVerticesData(kind: string, data: number[], updateExtends?: boolean, makeItUnique?: boolean): void;
+        setIndices(indices: number[]): void;
+    }
+    class VertexData {
+        public positions: number[];
+        public normals: number[];
+        public uvs: number[];
+        public uv2s: number[];
+        public colors: number[];
+        public matricesIndices: number[];
+        public matricesWeights: number[];
+        public indices: number[];
+        public set(data: number[], kind: string): void;
+        public applyToMesh(mesh: Mesh, updatable?: boolean): void;
+        public applyToGeometry(geometry: Geometry, updatable?: boolean): void;
+        public updateMesh(mesh: Mesh, updateExtends?: boolean, makeItUnique?: boolean): void;
+        public updateGeometry(geometry: Geometry, updateExtends?: boolean, makeItUnique?: boolean): void;
+        private _applyTo(meshOrGeometry, updatable?);
+        private _update(meshOrGeometry, updateExtends?, makeItUnique?);
+        public transform(matrix: Matrix): void;
+        public merge(other: VertexData): void;
+        static ExtractFromMesh(mesh: Mesh): VertexData;
+        static ExtractFromGeometry(geometry: Geometry): VertexData;
+        private static _ExtractFrom(meshOrGeometry);
+        static CreateBox(size: number): VertexData;
+        static CreateSphere(segments: number, diameter: number): VertexData;
+        static CreateCylinder(height: number, diameterTop: number, diameterBottom: number, tessellation: number, subdivisions?: number): VertexData;
+        static CreateTorus(diameter: any, thickness: any, tessellation: any): VertexData;
+        static CreateLines(points: Vector3[]): VertexData;
+        static CreateGround(width: number, height: number, subdivisions: number): VertexData;
+        static CreateTiledGround(xmin: number, zmin: number, xmax: number, zmax: number, subdivisions?: {
+            w: number;
+            h: number;
+        }, precision?: {
+            w: number;
+            h: number;
+        }): VertexData;
+        static CreateGroundFromHeightMap(width: number, height: number, subdivisions: number, minHeight: number, maxHeight: number, buffer: Uint8Array, bufferWidth: number, bufferHeight: number): VertexData;
+        static CreatePlane(size: number): VertexData;
+        static CreateTorusKnot(radius: number, tube: number, radialSegments: number, tubularSegments: number, p: number, q: number): VertexData;
+        static ComputeNormals(positions: number[], indices: number[], normals: number[]): void;
+    }
+}

Babylon/Mesh/babylon.meshLODLevel.d.ts

@@ -0,0 +1,7 @@
+declare module BABYLON.Internals {
+    class MeshLODLevel {
+        public distance: number;
+        public mesh: Mesh;
+        constructor(distance: number, mesh: Mesh);
+    }
+}

Babylon/Mesh/babylon.subMesh.d.ts

@@ -0,0 +1,37 @@
+declare module BABYLON {
+    class SubMesh {
+        public materialIndex: number;
+        public verticesStart: number;
+        public verticesCount: number;
+        public indexStart: any;
+        public indexCount: number;
+        public linesIndexCount: number;
+        private _mesh;
+        private _renderingMesh;
+        private _boundingInfo;
+        private _linesIndexBuffer;
+        public _lastColliderWorldVertices: Vector3[];
+        public _trianglePlanes: Plane[];
+        public _lastColliderTransformMatrix: Matrix;
+        public _renderId: number;
+        public _alphaIndex: number;
+        public _distanceToCamera: number;
+        public _id: number;
+        constructor(materialIndex: number, verticesStart: number, verticesCount: number, indexStart: any, indexCount: number, mesh: AbstractMesh, renderingMesh?: Mesh, createBoundingBox?: boolean);
+        public getBoundingInfo(): BoundingInfo;
+        public getMesh(): AbstractMesh;
+        public getRenderingMesh(): Mesh;
+        public getMaterial(): Material;
+        public refreshBoundingInfo(): void;
+        public _checkCollision(collider: Collider): boolean;
+        public updateBoundingInfo(world: Matrix): void;
+        public isInFrustum(frustumPlanes: Plane[]): boolean;
+        public render(): void;
+        public getLinesIndexBuffer(indices: number[], engine: any): WebGLBuffer;
+        public canIntersects(ray: Ray): boolean;
+        public intersects(ray: Ray, positions: Vector3[], indices: number[], fastCheck?: boolean): IntersectionInfo;
+        public clone(newMesh: AbstractMesh, newRenderingMesh?: Mesh): SubMesh;
+        public dispose(): void;
+        static CreateFromIndices(materialIndex: number, startIndex: number, indexCount: number, mesh: AbstractMesh, renderingMesh?: Mesh): SubMesh;
+    }
+}

Babylon/Mesh/babylon.vertexBuffer.d.ts

@@ -0,0 +1,34 @@
+declare module BABYLON {
+    class VertexBuffer {
+        private _mesh;
+        private _engine;
+        private _buffer;
+        private _data;
+        private _updatable;
+        private _kind;
+        private _strideSize;
+        constructor(engine: any, data: number[], kind: string, updatable: boolean, postponeInternalCreation?: boolean, stride?: number);
+        public isUpdatable(): boolean;
+        public getData(): number[];
+        public getBuffer(): WebGLBuffer;
+        public getStrideSize(): number;
+        public create(data?: number[]): void;
+        public update(data: number[]): void;
+        public updateDirectly(data: Float32Array, offset: number): void;
+        public dispose(): void;
+        private static _PositionKind;
+        private static _NormalKind;
+        private static _UVKind;
+        private static _UV2Kind;
+        private static _ColorKind;
+        private static _MatricesIndicesKind;
+        private static _MatricesWeightsKind;
+        static PositionKind : string;
+        static NormalKind : string;
+        static UVKind : string;
+        static UV2Kind : string;
+        static ColorKind : string;
+        static MatricesIndicesKind : string;
+        static MatricesWeightsKind : string;
+    }
+}

Babylon/Particles/babylon.particle.d.ts

@@ -0,0 +1,13 @@
+declare module BABYLON {
+    class Particle {
+        public position: Vector3;
+        public direction: Vector3;
+        public color: Color4;
+        public colorStep: Color4;
+        public lifeTime: number;
+        public age: number;
+        public size: number;
+        public angle: number;
+        public angularSpeed: number;
+    }
+}

Babylon/Particles/babylon.particleSystem.d.ts

@@ -0,0 +1,75 @@
+declare module BABYLON {
+    class ParticleSystem implements IDisposable {
+        public name: string;
+        static BLENDMODE_ONEONE: number;
+        static BLENDMODE_STANDARD: number;
+        public id: string;
+        public renderingGroupId: number;
+        public emitter: any;
+        public emitRate: number;
+        public manualEmitCount: number;
+        public updateSpeed: number;
+        public targetStopDuration: number;
+        public disposeOnStop: boolean;
+        public minEmitPower: number;
+        public maxEmitPower: number;
+        public minLifeTime: number;
+        public maxLifeTime: number;
+        public minSize: number;
+        public maxSize: number;
+        public minAngularSpeed: number;
+        public maxAngularSpeed: number;
+        public particleTexture: Texture;
+        public onDispose: () => void;
+        public updateFunction: (particles: Particle[]) => void;
+        public blendMode: number;
+        public forceDepthWrite: boolean;
+        public gravity: Vector3;
+        public direction1: Vector3;
+        public direction2: Vector3;
+        public minEmitBox: Vector3;
+        public maxEmitBox: Vector3;
+        public color1: Color4;
+        public color2: Color4;
+        public colorDead: Color4;
+        public textureMask: Color4;
+        public startDirectionFunction: (emitPower: number, worldMatrix: Matrix, directionToUpdate: Vector3) => void;
+        public startPositionFunction: (worldMatrix: Matrix, positionToUpdate: Vector3) => void;
+        private particles;
+        private _capacity;
+        private _scene;
+        private _vertexDeclaration;
+        private _vertexStrideSize;
+        private _stockParticles;
+        private _newPartsExcess;
+        private _vertexBuffer;
+        private _indexBuffer;
+        private _vertices;
+        private _effect;
+        private _customEffect;
+        private _cachedDefines;
+        private _scaledColorStep;
+        private _colorDiff;
+        private _scaledDirection;
+        private _scaledGravity;
+        private _currentRenderId;
+        private _alive;
+        private _started;
+        private _stopped;
+        private _actualFrame;
+        private _scaledUpdateSpeed;
+        constructor(name: string, capacity: number, scene: Scene, customEffect?: Effect);
+        public getCapacity(): number;
+        public isAlive(): boolean;
+        public isStarted(): boolean;
+        public start(): void;
+        public stop(): void;
+        public _appendParticleVertex(index: number, particle: Particle, offsetX: number, offsetY: number): void;
+        private _update(newParticles);
+        private _getEffect();
+        public animate(): void;
+        public render(): number;
+        public dispose(): void;
+        public clone(name: string, newEmitter: any): ParticleSystem;
+    }
+}

Babylon/Physics/Plugins/babylon.cannonJSPlugin.d.ts

@@ -0,0 +1,27 @@
+declare module BABYLON {
+    class CannonJSPlugin implements IPhysicsEnginePlugin {
+        public checkWithEpsilon: (value: number) => number;
+        private _world;
+        private _registeredMeshes;
+        private _physicsMaterials;
+        public initialize(iterations?: number): void;
+        private _checkWithEpsilon(value);
+        public runOneStep(delta: number): void;
+        public setGravity(gravity: Vector3): void;
+        public registerMesh(mesh: AbstractMesh, impostor: number, options?: PhysicsBodyCreationOptions): any;
+        private _createSphere(radius, mesh, options?);
+        private _createBox(x, y, z, mesh, options?);
+        private _createPlane(mesh, options?);
+        private _createConvexPolyhedron(rawVerts, rawFaces, mesh, options?);
+        private _addMaterial(friction, restitution);
+        private _createRigidBodyFromShape(shape, mesh, mass, friction, restitution);
+        public registerMeshesAsCompound(parts: PhysicsCompoundBodyPart[], options: PhysicsBodyCreationOptions): any;
+        private _unbindBody(body);
+        public unregisterMesh(mesh: AbstractMesh): void;
+        public applyImpulse(mesh: AbstractMesh, force: Vector3, contactPoint: Vector3): void;
+        public updateBodyPosition: (mesh: AbstractMesh) => void;
+        public createLink(mesh1: AbstractMesh, mesh2: AbstractMesh, pivot1: Vector3, pivot2: Vector3): boolean;
+        public dispose(): void;
+        public isSupported(): boolean;
+    }
+}

Babylon/Physics/Plugins/babylon.oimoJSPlugin.d.ts

@@ -0,0 +1,25 @@
+declare module BABYLON {
+    class OimoJSPlugin implements IPhysicsEnginePlugin {
+        private _world;
+        private _registeredMeshes;
+        private _checkWithEpsilon(value);
+        public initialize(iterations?: number): void;
+        public setGravity(gravity: Vector3): void;
+        public registerMesh(mesh: AbstractMesh, impostor: number, options: PhysicsBodyCreationOptions): any;
+        public registerMeshesAsCompound(parts: PhysicsCompoundBodyPart[], options: PhysicsBodyCreationOptions): any;
+        private _createBodyAsCompound(part, options, initialMesh);
+        public unregisterMesh(mesh: AbstractMesh): void;
+        private _unbindBody(body);
+        /**
+        * Update the body position according to the mesh position
+        * @param mesh
+        */
+        public updateBodyPosition: (mesh: AbstractMesh) => void;
+        public applyImpulse(mesh: AbstractMesh, force: Vector3, contactPoint: Vector3): void;
+        public createLink(mesh1: AbstractMesh, mesh2: AbstractMesh, pivot1: Vector3, pivot2: Vector3, options?: any): boolean;
+        public dispose(): void;
+        public isSupported(): boolean;
+        private _getLastShape(body);
+        public runOneStep(time: number): void;
+    }
+}

Babylon/Physics/babylon.physicsEngine.d.ts

@@ -0,0 +1,50 @@
+declare module BABYLON {
+    interface IPhysicsEnginePlugin {
+        initialize(iterations?: number): any;
+        setGravity(gravity: Vector3): void;
+        runOneStep(delta: number): void;
+        registerMesh(mesh: AbstractMesh, impostor: number, options: PhysicsBodyCreationOptions): any;
+        registerMeshesAsCompound(parts: PhysicsCompoundBodyPart[], options: PhysicsBodyCreationOptions): any;
+        unregisterMesh(mesh: AbstractMesh): any;
+        applyImpulse(mesh: AbstractMesh, force: Vector3, contactPoint: Vector3): void;
+        createLink(mesh1: AbstractMesh, mesh2: AbstractMesh, pivot1: Vector3, pivot2: Vector3, options?: any): boolean;
+        dispose(): void;
+        isSupported(): boolean;
+        updateBodyPosition(mesh: AbstractMesh): void;
+    }
+    interface PhysicsBodyCreationOptions {
+        mass: number;
+        friction: number;
+        restitution: number;
+    }
+    interface PhysicsCompoundBodyPart {
+        mesh: Mesh;
+        impostor: number;
+    }
+    class PhysicsEngine {
+        public gravity: Vector3;
+        private _currentPlugin;
+        constructor(plugin?: IPhysicsEnginePlugin);
+        public _initialize(gravity?: Vector3): void;
+        public _runOneStep(delta: number): void;
+        public _setGravity(gravity: Vector3): void;
+        public _registerMesh(mesh: AbstractMesh, impostor: number, options: PhysicsBodyCreationOptions): any;
+        public _registerMeshesAsCompound(parts: PhysicsCompoundBodyPart[], options: PhysicsBodyCreationOptions): any;
+        public _unregisterMesh(mesh: AbstractMesh): void;
+        public _applyImpulse(mesh: AbstractMesh, force: Vector3, contactPoint: Vector3): void;
+        public _createLink(mesh1: AbstractMesh, mesh2: AbstractMesh, pivot1: Vector3, pivot2: Vector3, options?: any): boolean;
+        public _updateBodyPosition(mesh: AbstractMesh): void;
+        public dispose(): void;
+        public isSupported(): boolean;
+        static NoImpostor: number;
+        static SphereImpostor: number;
+        static BoxImpostor: number;
+        static PlaneImpostor: number;
+        static MeshImpostor: number;
+        static CapsuleImpostor: number;
+        static ConeImpostor: number;
+        static CylinderImpostor: number;
+        static ConvexHullImpostor: number;
+        static Epsilon: number;
+    }
+}

Babylon/PostProcess/RenderPipeline/babylon.postProcessRenderEffect.d.ts

@@ -0,0 +1,32 @@
+declare module BABYLON {
+    class PostProcessRenderEffect {
+        private _engine;
+        private _postProcesses;
+        private _getPostProcess;
+        private _singleInstance;
+        private _cameras;
+        private _indicesForCamera;
+        private _renderPasses;
+        private _renderEffectAsPasses;
+        public _name: string;
+        public applyParameters: (postProcess: PostProcess) => void;
+        constructor(engine: Engine, name: string, getPostProcess: () => PostProcess, singleInstance?: boolean);
+        public _update(): void;
+        public addPass(renderPass: PostProcessRenderPass): void;
+        public removePass(renderPass: PostProcessRenderPass): void;
+        public addRenderEffectAsPass(renderEffect: PostProcessRenderEffect): void;
+        public getPass(passName: string): void;
+        public emptyPasses(): void;
+        public _attachCameras(cameras: Camera): any;
+        public _attachCameras(cameras: Camera[]): any;
+        public _detachCameras(cameras: Camera): any;
+        public _detachCameras(cameras: Camera[]): any;
+        public _enable(cameras: Camera): any;
+        public _enable(cameras: Camera[]): any;
+        public _disable(cameras: Camera): any;
+        public _disable(cameras: Camera[]): any;
+        public getPostProcess(camera?: Camera): PostProcess;
+        private _linkParameters();
+        private _linkTextures(effect);
+    }
+}

Babylon/PostProcess/RenderPipeline/babylon.postProcessRenderPass.d.ts

@@ -0,0 +1,16 @@
+declare module BABYLON {
+    class PostProcessRenderPass {
+        private _enabled;
+        private _renderList;
+        private _renderTexture;
+        private _scene;
+        private _refCount;
+        public _name: string;
+        constructor(scene: Scene, name: string, size: number, renderList: Mesh[], beforeRender: () => void, afterRender: () => void);
+        public _incRefCount(): number;
+        public _decRefCount(): number;
+        public _update(): void;
+        public setRenderList(renderList: Mesh[]): void;
+        public getRenderTexture(): RenderTargetTexture;
+    }
+}

Babylon/PostProcess/RenderPipeline/babylon.postProcessRenderPipeline.d.ts

@@ -0,0 +1,26 @@
+declare module BABYLON {
+    class PostProcessRenderPipeline {
+        private _engine;
+        private _renderEffects;
+        private _renderEffectsForIsolatedPass;
+        private _cameras;
+        public _name: string;
+        private static PASS_EFFECT_NAME;
+        private static PASS_SAMPLER_NAME;
+        constructor(engine: Engine, name: string);
+        public addEffect(renderEffect: PostProcessRenderEffect): void;
+        public _enableEffect(renderEffectName: string, cameras: Camera): any;
+        public _enableEffect(renderEffectName: string, cameras: Camera[]): any;
+        public _disableEffect(renderEffectName: string, cameras: Camera): any;
+        public _disableEffect(renderEffectName: string, cameras: Camera[]): any;
+        public _attachCameras(cameras: Camera, unique: boolean): any;
+        public _attachCameras(cameras: Camera[], unique: boolean): any;
+        public _detachCameras(cameras: Camera): any;
+        public _detachCameras(cameras: Camera[]): any;
+        public _enableDisplayOnlyPass(passName: any, cameras: Camera): any;
+        public _enableDisplayOnlyPass(passName: any, cameras: Camera[]): any;
+        public _disableDisplayOnlyPass(cameras: Camera): any;
+        public _disableDisplayOnlyPass(cameras: Camera[]): any;
+        public _update(): void;
+    }
+}

Babylon/PostProcess/RenderPipeline/babylon.postProcessRenderPipelineManager.d.ts

@@ -0,0 +1,20 @@
+declare module BABYLON {
+    class PostProcessRenderPipelineManager {
+        private _renderPipelines;
+        constructor();
+        public addPipeline(renderPipeline: PostProcessRenderPipeline): void;
+        public attachCamerasToRenderPipeline(renderPipelineName: string, cameras: Camera, unique?: boolean): any;
+        public attachCamerasToRenderPipeline(renderPipelineName: string, cameras: Camera[], unique?: boolean): any;
+        public detachCamerasFromRenderPipeline(renderPipelineName: string, cameras: Camera): any;
+        public detachCamerasFromRenderPipeline(renderPipelineName: string, cameras: Camera[]): any;
+        public enableEffectInPipeline(renderPipelineName: string, renderEffectName: string, cameras: Camera): any;
+        public enableEffectInPipeline(renderPipelineName: string, renderEffectName: string, cameras: Camera[]): any;
+        public disableEffectInPipeline(renderPipelineName: string, renderEffectName: string, cameras: Camera): any;
+        public disableEffectInPipeline(renderPipelineName: string, renderEffectName: string, cameras: Camera[]): any;
+        public enableDisplayOnlyPassInPipeline(renderPipelineName: string, passName: string, cameras: Camera): any;
+        public enableDisplayOnlyPassInPipeline(renderPipelineName: string, passName: string, cameras: Camera[]): any;
+        public disableDisplayOnlyPassInPipeline(renderPipelineName: string, cameras: Camera): any;
+        public disableDisplayOnlyPassInPipeline(renderPipelineName: string, cameras: Camera[]): any;
+        public update(): void;
+    }
+}

Babylon/PostProcess/babylon.anaglyphPostProcess.d.ts

@@ -0,0 +1,5 @@
+declare module BABYLON {
+    class AnaglyphPostProcess extends PostProcess {
+        constructor(name: string, ratio: number, camera: Camera, samplingMode?: number, engine?: Engine, reusable?: boolean);
+    }
+}

Babylon/PostProcess/babylon.blackAndWhitePostProcess.d.ts

@@ -0,0 +1,5 @@
+declare module BABYLON {
+    class BlackAndWhitePostProcess extends PostProcess {
+        constructor(name: string, ratio: number, camera: Camera, samplingMode?: number, engine?: Engine, reusable?: boolean);
+    }
+}

Babylon/PostProcess/babylon.blurPostProcess.d.ts

@@ -0,0 +1,7 @@
+declare module BABYLON {
+    class BlurPostProcess extends PostProcess {
+        public direction: Vector2;
+        public blurWidth: number;
+        constructor(name: string, direction: Vector2, blurWidth: number, ratio: number, camera: Camera, samplingMode?: number, engine?: Engine, reusable?: boolean);
+    }
+}

Babylon/PostProcess/babylon.convolutionPostProcess.d.ts

@@ -0,0 +1,12 @@
+declare module BABYLON {
+    class ConvolutionPostProcess extends PostProcess {
+        public kernel: number[];
+        constructor(name: string, kernel: number[], ratio: number, camera: Camera, samplingMode?: number, engine?: Engine, reusable?: boolean);
+        static EdgeDetect0Kernel: number[];
+        static EdgeDetect1Kernel: number[];
+        static EdgeDetect2Kernel: number[];
+        static SharpenKernel: number[];
+        static EmbossKernel: number[];
+        static GaussianKernel: number[];
+    }
+}