immports from z - p

src/Particles/EmitterTypes/IParticleEmitterType.ts

@@ -1,3 +1,6 @@
+import { Vector3, Matrix } from "Math";
+import { Effect } from "Materials";
+import { IParticleEmitterType, Particle } from "Particles";
     /**
      * Particle emitter represents a volume emitting particles.
      * This is the responsibility of the implementation to define the volume shape like cone/sphere/box.
@@ -54,4 +57,4 @@
          * @param serializationObject defines the JSON object
          */
         parse(serializationObject: any): void;
-    }
+    }

src/Particles/EmitterTypes/boxParticleEmitter.ts

@@ -1,3 +1,7 @@
+import { Tools } from "Tools";
+import { Vector3, Matrix, Scalar } from "Math";
+import { Effect } from "Materials";
+import { IParticleEmitterType, Particle } from "Particles";
     /**
      * Particle emitter emitting particles from the inside of a box.
      * It emits the particles randomly between 2 given directions.
@@ -123,4 +127,4 @@
             Vector3.FromArrayToRef(serializationObject.minEmitBox, 0, this.minEmitBox);
             Vector3.FromArrayToRef(serializationObject.maxEmitBox, 0, this.maxEmitBox);
         }
-    }
+    }

src/Particles/EmitterTypes/coneParticleEmitter.ts

@@ -1,3 +1,7 @@
+import { Tools } from "Tools";
+import { Vector3, Matrix, Scalar } from "Math";
+import { Effect } from "Materials";
+import { IParticleEmitterType, Particle } from "Particles";
     /**
      * Particle emitter emitting particles from the inside of a cone.
      * It emits the particles alongside the cone volume from the base to the particle.
@@ -190,4 +194,4 @@
             this.angle = serializationObject.angle;
             this.directionRandomizer = serializationObject.directionRandomizer;
         }
-    }
+    }

src/Particles/EmitterTypes/cylinderParticleEmitter.ts

@@ -1,3 +1,7 @@
+import { Tools } from "Tools";
+import { Vector3, Matrix, Scalar } from "Math";
+import { Effect } from "Materials";
+import { IParticleEmitterType, Particle } from "Particles";
     /**
      * Particle emitter emitting particles from the inside of a cylinder.
      * It emits the particles alongside the cylinder radius. The emission direction might be randomized.

src/Particles/EmitterTypes/hemisphericParticleEmitter.ts

@@ -1,3 +1,7 @@
+import { Tools } from "Tools";
+import { Vector3, Matrix, Scalar } from "Math";
+import { Effect } from "Materials";
+import { IParticleEmitterType, Particle } from "Particles";
     /**
      * Particle emitter emitting particles from the inside of a hemisphere.
      * It emits the particles alongside the hemisphere radius. The emission direction might be randomized.

src/Particles/EmitterTypes/pointParticleEmitter.ts

@@ -1,3 +1,7 @@
+import { Tools } from "Tools";
+import { Vector3, Matrix, Scalar } from "Math";
+import { Effect } from "Materials";
+import { IParticleEmitterType, Particle } from "Particles";
     /**
      * Particle emitter emitting particles from a point.
      * It emits the particles randomly between 2 given directions.
@@ -104,4 +108,4 @@
             Vector3.FromArrayToRef(serializationObject.direction1, 0, this.direction1);
             Vector3.FromArrayToRef(serializationObject.direction2, 0, this.direction2);
         }
-    }
+    }

src/Particles/EmitterTypes/sphereParticleEmitter.ts

@@ -1,3 +1,7 @@
+import { Tools } from "Tools";
+import { Vector3, Matrix, Scalar } from "Math";
+import { Effect } from "Materials";
+import { IParticleEmitterType, Particle } from "Particles";
     /**
      * Particle emitter emitting particles from the inside of a sphere.
      * It emits the particles alongside the sphere radius. The emission direction might be randomized.

src/Particles/IParticleSystem.ts

@@ -1,3 +1,12 @@
+import { Nullable } from "types";
+import { Color4, Color3, Vector2, Vector3 } from "Math";
+import { AbstractMesh } from "Mesh";
+import { IParticleSystem } from "Particles";
+import { BaseTexture, Texture } from "Materials";
+import { BoxParticleEmitter, IParticleEmitterType, PointParticleEmitter, HemisphericParticleEmitter, SphereParticleEmitter, SphereDirectedParticleEmitter, CylinderParticleEmitter, ConeParticleEmitter } from "Particles";
+import { Scene } from "scene";
+import { ColorGradient, FactorGradient, Color3Gradient } from "Tools";
+
     /**
      * Interface representing a particle system in Babylon.js.
      * This groups the common functionalities that needs to be implemented in order to create a particle system.
@@ -610,4 +619,4 @@
          * @returns the scene
          */
         getScene(): Scene;
-    }
+    }

src/Particles/baseParticleSystem.ts

@@ -1,3 +1,11 @@
+import { Nullable } from "types";
+import { Color4, Vector2, Vector3 } from "Math";
+import { AbstractMesh } from "Mesh";
+import { ImageProcessingConfiguration, Texture, ProceduralTexture, ImageProcessingConfigurationDefines, RawTexture } from "Materials";
+import { Scene } from "scene";
+import { ColorGradient, FactorGradient, Color3Gradient, IValueGradient } from "Tools";
+import { BoxParticleEmitter, IParticleEmitterType, ParticleSystem, PointParticleEmitter, HemisphericParticleEmitter, SphereParticleEmitter, SphereDirectedParticleEmitter, CylinderParticleEmitter, CylinderDirectedParticleEmitter, ConeParticleEmitter } from "Particles";
+    
     /**
      * This represents the base class for particle system in Babylon.
      * Particles are often small sprites used to simulate hard-to-reproduce phenomena like fire, smoke, water, or abstract visual effects like magic glitter and faery dust.
@@ -716,4 +724,4 @@
             this.maxEmitBox = maxEmitBox;
             return particleEmitter;
         }
-    }
+    }

src/Particles/gpuParticleSystem.ts

@@ -1,3 +1,12 @@
+import { Nullable, float } from "types";
+import { IAnimatable, Observable, Tools, IValueGradient, ColorGradient, FactorGradient, Color3Gradient } from "Tools";
+import { Color4, Color3, Vector3, Matrix, Tmp, Scalar } from "Math";
+import { AbstractMesh, VertexBuffer } from "Mesh";
+import { IParticleSystem, BaseParticleSystem } from "Particles";
+import { Material, ImageProcessingConfiguration, Effect, Texture, RawTexture, EffectCreationOptions, MaterialHelper } from "Materials";
+import { Engine } from "Engine";
+import { BoxParticleEmitter, ParticleSystem } from "Particles";
+import { Scene, IDisposable } from "scene";
     /**
      * This represents a GPU particle system in Babylon
      * This is the fastest particle system in Babylon as it uses the GPU to update the individual particle data
@@ -482,7 +491,7 @@
          * @param gradient defines the gradient to remove
          * @returns the current particle system
          */
-        public removeColorRemapGradient(gradient: number): IParticleSystem {
+        public removeColorRemapGradient(): IParticleSystem {
             // Do nothing as start size is not supported by GPUParticleSystem
 
             return this;
@@ -506,7 +515,7 @@
          * @param gradient defines the gradient to remove
          * @returns the current particle system
          */
-        public removeAlphaRemapGradient(gradient: number): IParticleSystem {
+        public removeAlphaRemapGradient(): IParticleSystem {
             // Do nothing as start size is not supported by GPUParticleSystem
 
             return this;
@@ -529,7 +538,7 @@
          * @param gradient defines the gradient to remove
          * @returns the current particle system
          */
-        public removeRampGradient(gradient: number): IParticleSystem {
+        public removeRampGradient(): IParticleSystem {
             //Not supported by GPUParticleSystem
 
             return this;
@@ -1505,4 +1514,4 @@
 
             return particleSystem;
         }
-    }
+    }

src/Particles/particle.ts

@@ -1,3 +1,8 @@
+import { Nullable } from "types";
+import { Color4, Vector2, Vector3, Tmp, Vector4, Scalar } from "Math";
+import { AbstractMesh } from "Mesh";
+import { ParticleSystem, SubEmitter } from "Particles";
+import { ColorGradient, FactorGradient } from "Tools";
     /**
      * A particle represents one of the element emitted by a particle system.
      * This is mainly define by its coordinates, direction, velocity and age.
@@ -293,4 +298,4 @@
                 }
             }
         }
-    }
+    }

src/Particles/particleHelper.ts

@@ -1,3 +1,12 @@
+import { Nullable } from "types";
+import { Tools } from "Tools";
+import { Vector3 } from "Math";
+import { AbstractMesh } from "Mesh";
+import { IParticleSystem, GPUParticleSystem, ParticleSystemSet } from "Particles";
+import { Texture } from "Materials";
+import { Engine } from "Engine";
+import { ParticleSystem } from "Particles";
+import { Scene } from "scene";
     /**
      * This class is made for on one-liner static method to help creating particle system set.
      */
@@ -72,11 +81,11 @@
                     return reject("Particle system with GPU is not supported.");
                 }
 
-                Tools.LoadFile(`${ParticleHelper.BaseAssetsUrl}/systems/${type}.json`, (data, response) => {
+                Tools.LoadFile(`${ParticleHelper.BaseAssetsUrl}/systems/${type}.json`, (data) => {
                     scene!._removePendingData(token);
                     const newData = JSON.parse(data.toString());
                     return resolve(ParticleSystemSet.Parse(newData, scene!, gpu));
-                }, undefined, undefined, undefined, (req, exception) => {
+                }, undefined, undefined, undefined, () => {
                     scene!._removePendingData(token);
                     return reject(`An error occured while the creation of your particle system. Check if your type '${type}' exists.`);
                 });

src/Particles/particleSystem.ts

@@ -1,3 +1,11 @@
+import { Nullable } from "types";
+import { IAnimatable, Observable, Observer, Tools, FactorGradient, ColorGradient, Color3Gradient } from "Tools";
+import { Color4, Color3, Vector3, Matrix, Tmp, ISize, Scalar, Vector4 } from "Math";
+import { AbstractMesh, VertexBuffer } from "Mesh";
+import { IParticleSystem, BaseParticleSystem, Particle, SubEmitter, SubEmitterType, BoxParticleEmitter, IParticleEmitterType, HemisphericParticleEmitter, SphereParticleEmitter, SphereDirectedParticleEmitter, CylinderParticleEmitter, ConeParticleEmitter } from "Particles";
+import { Material, ImageProcessingConfiguration, Effect, Texture, RawTexture, ProceduralTexture, MaterialHelper } from "Materials";
+import { Engine } from "Engine";
+import { Scene, IDisposable } from "scene";
     /**
      * This represents a particle system in Babylon.
      * Particles are often small sprites used to simulate hard-to-reproduce phenomena like fire, smoke, water, or abstract visual effects like magic glitter and faery dust.
@@ -1290,7 +1298,7 @@
                 // Life time
                 if (this.targetStopDuration && this._lifeTimeGradients && this._lifeTimeGradients.length > 0) {
                     let ratio = Scalar.Clamp(this._actualFrame / this.targetStopDuration);
-                    Tools.GetCurrentGradient(ratio, this._lifeTimeGradients, (currentGradient, nextGradient, scale) => {
+                    Tools.GetCurrentGradient(ratio, this._lifeTimeGradients, (currentGradient, nextGradient) => {
                         let factorGradient1 = (<FactorGradient>currentGradient);
                         let factorGradient2 = (<FactorGradient>nextGradient);
                         let lifeTime1 = factorGradient1.getFactor();

src/Particles/particleSystemComponent.ts

@@ -1,3 +1,11 @@
+import { Mesh } from "Mesh";
+import { IParticleSystem } from "Particles";
+import { AbstractScene } from "abstractScene";
+import { Effect } from "Materials";
+import { Engine } from "Engine";
+import { ParticleSystem } from "Particles";
+import { Scene } from "scene";
+import { SceneComponentConstants } from "sceneComponent";
     // Adds the parsers to the scene parsers.
     AbstractScene.AddParser(SceneComponentConstants.NAME_PARTICLESYSTEM, (parsedData: any, scene: Scene, container: AssetContainer, rootUrl: string) => {
 
@@ -107,4 +115,4 @@
         }
 
         return results;
-    };
+    };

src/Particles/particleSystemSet.ts

@@ -1,3 +1,10 @@
+import { Nullable } from "types";
+import { Color3 } from "Math";
+import { TransformNode, AbstractMesh, MeshBuilder } from "Mesh";
+import { IParticleSystem, ParticleHelper, GPUParticleSystem } from "Particles";
+import { Engine } from "Engine";
+import { ParticleSystem } from "Particles";
+import { Scene, IDisposable } from "scene";
     /** Internal class used to store shapes for emitters */
     class ParticleSystemSetEmitterCreationOptions {
         public kind: string;

src/Particles/solidParticle.ts

@@ -1,3 +1,8 @@
+import { Nullable } from "types";
+import { Color4, Vector3, Matrix, Tmp, Quaternion, Vector4 } from "Math";
+import { Mesh } from "Mesh";
+import { BoundingInfo, BoundingSphere } from "Culling";
+import { SolidParticleSystem } from "Particles";
     /**
      * Represents one particle of a solid particle system.
      */

src/Particles/solidParticleSystem.ts

@@ -1,3 +1,11 @@
+import { Nullable, IndicesArray, FloatArray } from "types";
+import { Color4, Vector3, Matrix, Tmp, Quaternion, Axis } from "Math";
+import { Mesh, MeshBuilder, VertexData, VertexBuffer } from "Mesh";
+import { Engine } from "Engine";
+import { Scene, IDisposable } from "scene";
+import { DepthSortedParticle, SolidParticle, ModelShape } from "Particles";
+import { TargetCamera } from "Cameras";
+import { BoundingInfo } from "Culling";
     const depthSortFunction = (p1: DepthSortedParticle, p2: DepthSortedParticle) => p2.sqDistance - p1.sqDistance;
 
     /**
@@ -595,7 +603,7 @@
             }
 
             // custom beforeUpdate
-            this.beforeUpdateParticles(start, end, update);
+            this.beforeUpdateParticles();
 
             const rotMatrix = Tmp.Matrix[0];
             const invertedMatrix = Tmp.Matrix[1];
@@ -781,7 +789,7 @@
                         const tmpVertex = tempVectors[0];
                         tmpVertex.copyFrom(shape[pt]);
                         if (this._computeParticleVertex) {
-                            this.updateParticleVertex(particle, tmpVertex, pt);
+                            this.updateParticleVertex(tmpVertex);
                         }
 
                         // positions
@@ -956,7 +964,7 @@
                     mesh._boundingInfo = new BoundingInfo(minimum, maximum, mesh._worldMatrix);
                 }
             }
-            this.afterUpdateParticles(start, end, update);
+            this.afterUpdateParticles();
             return this;
         }
 
@@ -1176,7 +1184,7 @@
          * @example : just set a vertex particle position
          * @returns the updated vertex
          */
-        public updateParticleVertex(particle: SolidParticle, vertex: Vector3, pt: number): Vector3 {
+        public updateParticleVertex(vertex: Vector3): Vector3 {
             return vertex;
         }
 
@@ -1187,7 +1195,7 @@
          * @param stop the particle index in the particle array where to stop to iterate, same than the value passed to setParticle()
          * @param update the boolean update value actually passed to setParticles()
          */
-        public beforeUpdateParticles(start?: number, stop?: number, update?: boolean): void {
+        public beforeUpdateParticles(): void {
         }
         /**
          * This will be called  by `setParticles()` after all the other treatments and just before the actual mesh update.
@@ -1197,6 +1205,6 @@
          * @param stop the particle index in the particle array where to stop to iterate, same than the value passed to setParticle()
          * @param update the boolean update value actually passed to setParticles()
          */
-        public afterUpdateParticles(start?: number, stop?: number, update?: boolean): void {
+        public afterUpdateParticles(): void {
         }
-    }
+    }

src/Particles/subEmitter.ts

@@ -1,3 +1,7 @@
+import { Vector3 } from "Math";
+import { Mesh, AbstractMesh } from "Mesh";
+import { ParticleSystem } from "Particles";
+import { Scene } from "scene";
     /**
      * Type of sub emitter
      */
@@ -115,4 +119,4 @@
         public dispose() {
             this.particleSystem.dispose();
         }
-    }
+    }

src/Physics/IPhysicsEngine.ts

@@ -1,3 +1,7 @@
+import { Nullable } from "types";
+import { Vector3, Quaternion } from "Math";
+import { AbstractMesh } from "Mesh";
+import { PhysicsImpostor, PhysicsJoint, IMotorEnabledJoint, IPhysicsEnabledObject } from "Physics";
     /**
      * Interface used to describe a physics joint
      */

src/Physics/Plugins/cannonJSPlugin.ts

@@ -1,3 +1,8 @@
+import { Nullable, FloatArray } from "types";
+import { Tools } from "Tools";
+import { Vector3, Matrix, Quaternion } from "Math";
+import { AbstractMesh, VertexBuffer } from "Mesh";
+import { IPhysicsEnginePlugin, PhysicsImpostor, PhysicsImpostorJoint, PhysicsJoint, DistanceJointData, SpringJointData, PhysicsEngine, IPhysicsEnabledObject, IMotorEnabledJoint } from "Physics";
     //declare var require: any;
     declare var CANNON: any;
 
@@ -36,7 +41,7 @@
             return this._fixedTimeStep;
         }
 
-        public executeStep(delta: number, impostors: Array<PhysicsImpostor>): void {
+        public executeStep(delta: number): void {
             this.world.step(this._fixedTimeStep, this._useDeltaForWorldStep ? delta : 0, 3);
         }
 
@@ -543,7 +548,7 @@
             impostor.physicsBody.wakeUp();
         }
 
-        public updateDistanceJoint(joint: PhysicsJoint, maxDistance: number, minDistance?: number) {
+        public updateDistanceJoint(joint: PhysicsJoint, maxDistance: number) {
             joint.physicsJoint.distance = maxDistance;
         }
 

src/Physics/Plugins/oimoJSPlugin.ts

@@ -1,3 +1,8 @@
+import { IPhysicsEnginePlugin, PhysicsImpostor, IPhysicsEnabledObject, PhysicsEngine, PhysicsImpostorJoint, PhysicsJoint, SpringJointData, DistanceJointData, IMotorEnabledJoint, AbstractMesh } from "Physics";
+import { Vector3, Quaternion } from "Math";
+import { Nullable } from "types";
+import { Tools } from "Tools";
+
     declare var OIMO: any;
 
     /** @hidden */

src/Physics/physicsEngine.ts

@@ -1,3 +1,6 @@
+import { Nullable } from "types";
+import { Vector3 } from "Math";
+import { IPhysicsEngine, PhysicsImpostor, PhysicsImpostorJoint, IPhysicsEnginePlugin, CannonJSPlugin, PhysicsJoint, IPhysicsEnabledObject } from "Physics";
     /**
      * Class used to control physics engine
      * @see http://doc.babylonjs.com/how_to/using_the_physics_engine

src/Physics/physicsEngineComponent.ts

@@ -1,3 +1,10 @@
+import { Nullable } from "types";
+import { Observable, Observer, Tools } from "Tools";
+import { Vector3 } from "Math";
+import { Mesh, AbstractMesh } from "Mesh";
+import { ISceneComponent, SceneComponentConstants } from "sceneComponent";
+import { IPhysicsEngine, IPhysicsEnginePlugin, PhysicsEngine, PhysicsImpostor, PhysicsJoint } from "Physics";
+import { Scene } from "scene";
     export interface Scene {
         /** @hidden (Backing field) */
         _physicsEngine: Nullable<IPhysicsEngine>;
@@ -292,4 +299,4 @@
                 this.scene.disablePhysicsEngine();
             }
         }
-    }
+    }

src/Physics/physicsHelper.ts

@@ -1,3 +1,10 @@
+import { Nullable } from "types";
+import { Tools } from "Tools";
+import { Vector3 } from "Math";
+import { Mesh, AbstractMesh, MeshBuilder } from "Mesh";
+import { Ray } from "Culling";
+import { Scene } from "scene";
+import { IPhysicsEngine, PhysicsImpostor, PhysicsEngine } from "Physics";
     /**
      * A helper for physics simulations
      * @see https://doc.babylonjs.com/how_to/using_the_physics_engine

src/Physics/physicsImpostor.ts

@@ -1,3 +1,10 @@
+import { Nullable, IndicesArray } from "types";
+import { Tools } from "Tools";
+import { Vector3, Matrix, Quaternion, Space } from "Math";
+import { TransformNode, AbstractMesh, Scene } from "Mesh";
+import { Bone } from "Bones";
+import { BoundingInfo } from "Culling";
+import { IPhysicsEngine, PhysicsJoint, PhysicsJointData } from "Physics";
     /**
      * The interface for the physics imposter parameters
      * @see https://doc.babylonjs.com/how_to/using_the_physics_engine
@@ -331,7 +338,7 @@
          * Sets the updated scaling
          * @param updated Specifies if the scaling is updated
          */
-        public setScalingUpdated(updated: boolean) {
+        public setScalingUpdated() {
             this.forceUpdate();
         }
 

src/Physics/physicsJoint.ts

@@ -1,3 +1,5 @@
+import { Vector3 } from "Math";
+import { IPhysicsEnginePlugin } from "Physics";
     /**
      * Interface for Physics-Joint data
      * @see https://doc.babylonjs.com/how_to/using_the_physics_engine

src/PostProcess/RenderPipeline/Pipelines/defaultRenderingPipeline.ts

@@ -1,3 +1,12 @@
+import { Nullable } from "types";
+import { IAnimatable, Observer, serialize, SerializationHelper } from "Tools";
+import { Camera } from "Cameras";
+import { ImageProcessingConfiguration, Texture } from "Materials";
+import { PostProcess, PostProcessRenderPipeline, Scene, SharpenPostProcess, PostProcessRenderEffect, BloomEffect, DepthOfFieldEffect, FxaaPostProcess, ImageProcessingPostProcess, ChromaticAberrationPostProcess, GrainPostProcess, DepthOfFieldEffectBlurLevel } from "PostProcess";
+import { Engine } from "Engine";
+import { IDisposable } from "scene";
+import { GlowLayer } from "Layer";
+    
     /**
 	 * The default rendering pipeline can be added to a scene to apply common post processing effects such as anti-aliasing or depth of field.
      * See https://doc.babylonjs.com/how_to/using_default_rendering_pipeline

src/PostProcess/RenderPipeline/Pipelines/lensRenderingPipeline.ts

@@ -1,4 +1,7 @@
 
+import { Camera } from "Cameras";
+import { RenderTargetTexture, Effect, Texture, DynamicTexture } from "Materials";
+import { PostProcess, PostProcessRenderPipeline, Scene, PostProcessRenderEffect } from "PostProcess";
     /**
      * BABYLON.JS Chromatic Aberration GLSL Shader
      * Author: Olivier Guyot
@@ -239,7 +242,7 @@
             this._grainTexture.dispose();
 
             if (disableDepthRender) {
-                this._scene.disableDepthRenderer();
+                this._scene.disableDepthRenderer();
             }
         }
 

src/PostProcess/RenderPipeline/Pipelines/ssao2RenderingPipeline.ts

@@ -1,3 +1,10 @@
+import { Tools, serialize, SerializationHelper } from "Tools";
+import { Vector3, Tmp } from "Math";
+import { Camera } from "Cameras";
+import { Effect, Texture, DynamicTexture } from "Materials";
+import { PostProcess, PostProcessRenderPipeline, Scene, PassPostProcess, PostProcessRenderEffect } from "PostProcess";
+import { Engine } from "Engine";
+import { GeometryBufferRenderer } from "index";
     /**
      * Render pipeline to produce ssao effect
      */
@@ -196,7 +203,7 @@
             // Finish
             scene.postProcessRenderPipelineManager.addPipeline(this);
             if (cameras) {
-                scene.postProcessRenderPipelineManager.attachCamerasToRenderPipeline(name, cameras);
+                scene.postProcessRenderPipelineManager.attachCamerasToRenderPipeline(name, cameras);
             }
 
         }
@@ -220,7 +227,7 @@
             this._randomTexture.dispose();
 
             if (disableGeometryBufferRenderer) {
-                this._scene.disableGeometryBufferRenderer();
+                this._scene.disableGeometryBufferRenderer();
             }
 
             this._scene.postProcessRenderPipelineManager.detachCamerasFromRenderPipeline(this._name, this._scene.cameras);
@@ -444,4 +451,4 @@
         public static Parse(source: any, scene: Scene, rootUrl: string): SSAO2RenderingPipeline {
             return SerializationHelper.Parse(() => new SSAO2RenderingPipeline(source._name, scene, source._ratio), source, scene, rootUrl);
         }
-    }
+    }

src/PostProcess/RenderPipeline/Pipelines/ssaoRenderingPipeline.ts

@@ -1,3 +1,9 @@
+import { Vector2, Vector3, Tmp } from "Math";
+import { Camera } from "Cameras";
+import { RenderTargetTexture, Effect, Texture, DynamicTexture } from "Materials";
+import { PostProcess, PostProcessRenderPipeline, Scene, PassPostProcess, BlurPostProcess, PostProcessRenderEffect } from "PostProcess";
+import { Engine } from "Engine";
+import { serialize } from "Tools";
     /**
      * Render pipeline to produce ssao effect
      */
@@ -112,7 +118,7 @@
             // Finish
             scene.postProcessRenderPipelineManager.addPipeline(this);
             if (cameras) {
-                scene.postProcessRenderPipelineManager.attachCamerasToRenderPipeline(name, cameras);
+                scene.postProcessRenderPipelineManager.attachCamerasToRenderPipeline(name, cameras);
             }
         }
 
@@ -135,7 +141,7 @@
             this._randomTexture.dispose();
 
             if (disableDepthRender) {
-                this._scene.disableDepthRenderer();
+                this._scene.disableDepthRenderer();
             }
 
             this._scene.postProcessRenderPipelineManager.detachCamerasFromRenderPipeline(this._name, this._scene.cameras);
@@ -256,4 +262,4 @@
 
             this._randomTexture.update(false);
         }
-    }
+    }

src/PostProcess/RenderPipeline/Pipelines/standardRenderingPipeline.ts

@@ -1,3 +1,13 @@
+import { Nullable } from "types";
+import { IAnimatable, Tools, serialize, serializeAsTexture, SerializationHelper } from "Tools";
+import { Vector2, Vector3, Matrix, Vector4, Scalar } from "Math";
+import { Camera } from "Cameras";
+import { Effect, Texture } from "Materials";
+import { PostProcess, PostProcessRenderPipeline, BlurPostProcess, FxaaPostProcess, Scene, PostProcessRenderEffect } from "PostProcess";
+import { Engine } from "Engine";
+import { IDisposable } from "scene";
+import { SpotLight, DirectionalLight } from "Lights";
+import { GeometryBufferRenderer } from "Rendering";
     /**
      * Standard rendering pipeline
      * Default pipeline should be used going forward but the standard pipeline will be kept for backwards compatibility.
@@ -478,7 +488,7 @@
             // Create pass post-process
             if (!this._basePostProcess) {
                 this.originalPostProcess = new PostProcess("HDRPass", "standard", [], [], ratio, null, Texture.BILINEAR_SAMPLINGMODE, scene.getEngine(), false, "#define PASS_POST_PROCESS", this._floatTextureType);
-                this.originalPostProcess.onApply = (effect: Effect) => {
+                this.originalPostProcess.onApply = () => {
                     this._currentDepthOfFieldSource = this.originalPostProcess;
                 };
             }
@@ -786,7 +796,7 @@
                 };
 
                 if (index === this.luminanceDownSamplePostProcesses.length - 1) {
-                    pp.onAfterRender = (effect: Effect) => {
+                    pp.onAfterRender = () => {
                         var pixel = scene.getEngine().readPixels(0, 0, 1, 1);
                         var bit_shift = new Vector4(1.0 / (255.0 * 255.0 * 255.0), 1.0 / (255.0 * 255.0), 1.0 / 255.0, 1.0);
                         this._hdrCurrentLuminance = (pixel[0] * bit_shift.x + pixel[1] * bit_shift.y + pixel[2] * bit_shift.z + pixel[3] * bit_shift.w) / 100.0;

src/PostProcess/RenderPipeline/postProcessRenderEffect.ts

@@ -1,3 +1,7 @@
+import { Nullable } from "types";
+import { Tools } from "Tools";
+import { Camera } from "Cameras";
+import { PostProcess } from "PostProcess";
     /**
      * This represents a set of one or more post processes in Babylon.
      * A post process can be used to apply a shader to a texture after it is rendered.
@@ -26,7 +30,7 @@
          * @param getPostProcesses A function that returns a set of post processes which the effect will run in order to be run.
          * @param singleInstance False if this post process can be run on multiple cameras. (default: true)
          */
-        constructor(engine: Engine, name: string, getPostProcesses: () => Nullable<PostProcess | Array<PostProcess>>, singleInstance?: boolean) {
+        constructor(name: string, getPostProcesses: () => Nullable<PostProcess | Array<PostProcess>>, singleInstance?: boolean) {
             this._name = name;
             this._singleInstance = singleInstance || true;
 
@@ -248,4 +252,4 @@
                 return this._postProcesses[camera.name];
             }
         }
-    }
+    }

src/PostProcess/RenderPipeline/postProcessRenderPipeline.ts

@@ -1,3 +1,8 @@
+import { Nullable } from "types";
+import { Tools } from "Tools";
+import { Camera } from "Cameras";
+import { Engine } from "Engine";
+import { PostProcessRenderEffect } from "PostProcess";
     /**
      * PostProcessRenderPipeline
      * @see https://doc.babylonjs.com/how_to/how_to_use_postprocessrenderpipeline
@@ -199,4 +204,4 @@
         public dispose() {
             // Must be implemented by children
         }
-    }
+    }

src/PostProcess/RenderPipeline/postProcessRenderPipelineManager.ts

@@ -1,3 +1,5 @@
+import { Camera } from "Cameras";
+import { PostProcessRenderPipeline } from "PostProcess";
     /**
      * PostProcessRenderPipelineManager class
      * @see https://doc.babylonjs.com/how_to/how_to_use_postprocessrenderpipeline
@@ -122,4 +124,4 @@
                 }
             }
         }
-    }
+    }

src/PostProcess/RenderPipeline/postProcessRenderPipelineManagerSceneComponent.ts

@@ -1,3 +1,6 @@
+import { ISceneComponent } from "sceneComponent";
+import { PostProcessRenderPipelineManager } from "PostProcess";
+import { Scene } from "scene";
     export interface Scene {
         /** @hidden (Backing field) */
         _postProcessRenderPipelineManager: PostProcessRenderPipelineManager;
@@ -76,9 +79,9 @@
             }
         }
 
-        private _gatherRenderTargets(renderTargets: SmartArrayNoDuplicate<RenderTargetTexture>): void {
+        private _gatherRenderTargets(): void {
             if (this.scene._postProcessRenderPipelineManager) {
                 this.scene._postProcessRenderPipelineManager.update();
             }
         }
-    }
+    }

src/PostProcess/anaglyphPostProcess.ts

@@ -1,3 +1,9 @@
+import { Nullable } from "types";
+import { Engine } from "Particles";
+import { PostProcess, PostProcessOptions } from "PostProcess";
+import { Camera } from "Cameras";
+import { Effect } from "Materials";
+
     /**
      * Postprocess used to generate anaglyphic rendering
      */
@@ -21,4 +27,4 @@
                 effect.setTextureFromPostProcess("leftSampler", this._passedProcess);
             });
         }
-    }
+    }

src/PostProcess/blackAndWhitePostProcess.ts

@@ -1,3 +1,7 @@
+import { PostProcess, PostProcessOptions } from "PostProcess";
+import { Camera } from "Cameras";
+import { Effect } from "Materials";
+
     /**
      * Post process used to render in black and white
      */
@@ -24,4 +28,4 @@
                 effect.setFloat("degree", this.degree);
             });
         }
-    }
+    }

src/PostProcess/bloomEffect.ts

@@ -1,3 +1,7 @@
+import { PostProcessRenderEffect, PostProcess, ExtractHighlightsPostProcess, BlurPostProcess, BloomMergePostProcess, Scene } from "PostProcess";
+import { Vector2 } from "Math";
+import { Camera } from "Cameras";
+
     /**
      * The bloom effect spreads bright areas of an image to simulate artifacts seen in cameras
      */
@@ -110,4 +114,4 @@
             }
             return true;
         }
-    }
+    }

src/PostProcess/bloomMergePostProcess.ts

@@ -1,3 +1,9 @@
+import { PostProcess, PostProcessOptions } from "PostProcess";
+import { Nullable } from "types";
+import { Engine } from "Engine";
+import { Effect } from "Materials";
+import { Camera } from "Cameras";
+
     /**
      * The BloomMergePostProcess merges blurred images with the original based on the values of the circle of confusion.
      */
@@ -32,4 +38,4 @@
                 this.updateEffect();
             }
         }
-    }
+    }

src/PostProcess/blurPostProcess.ts

@@ -1,3 +1,10 @@
+import { Vector2 } from "Math";
+import { Nullable } from "types";
+import { PostProcess, PostProcessOptions } from "PostProcess";
+import { Camera } from "Cameras";
+import { Texture, Effect } from "Materials";
+import { Engine } from "Engine";
+
     /**
      * The Blur Post Process which blurs an image based on a kernel and direction.
      * Can be used twice in x and y directions to perform a guassian blur in two passes.
@@ -242,4 +249,4 @@
         protected _glslFloat(x: number, decimalFigures = 8) {
             return x.toFixed(decimalFigures).replace(/0+$/, '');
         }
-    }
+    }

src/PostProcess/chromaticAberrationPostProcess.ts

@@ -1,3 +1,10 @@
+import { Vector2 } from "Math";
+import { Nullable } from "types";
+import { PostProcess, PostProcessOptions } from "PostProcess";
+import { Effect } from "Materials";
+import { Camera } from "Cameras";
+import { Engine } from "Engine";
+
     /**
      * The ChromaticAberrationPostProcess separates the rgb channels in an image to produce chromatic distortion around the edges of the screen
      */
@@ -46,4 +53,4 @@
                 effect.setFloat2('centerPosition', this.centerPosition.x, this.centerPosition.y);
             });
         }
-    }
+    }

src/PostProcess/circleOfConfusionPostProcess.ts

@@ -1,3 +1,9 @@
+import { Nullable } from "types";
+import { Engine } from "Particles";
+import { PostProcess, PostProcessOptions } from "PostProcess";
+import { RenderTargetTexture, Effect } from "Materials";
+import { Camera } from "Cameras";
+
     /**
      * The CircleOfConfusionPostProcess computes the circle of confusion value for each pixel given required lens parameters. See https://en.wikipedia.org/wiki/Circle_of_confusion
      */
@@ -58,4 +64,4 @@
         public set depthTexture(value: RenderTargetTexture) {
             this._depthTexture = value;
         }
-    }
+    }

src/PostProcess/colorCorrectionPostProcess.ts

@@ -1,3 +1,7 @@
+import { PostProcess, PostProcessOptions } from "PostProcess";
+import { Texture, Effect } from "Materials";
+import { Engine } from "Particles";
+import { Camera } from "Cameras";
 
     /**
      *
@@ -30,4 +34,4 @@
                 effect.setTexture("colorTable", this._colorTableTexture);
             };
         }
-    }
+    }

src/PostProcess/convolutionPostProcess.ts

@@ -1,3 +1,9 @@
+import { PostProcess, PostProcessOptions } from "PostProcess";
+import { Nullable } from "types";
+import { Camera } from "Cameras";
+import { Engine } from "Engine";
+import { Effect } from "Materials";
+
     /**
      * The ConvolutionPostProcess applies a 3x3 kernel to every pixel of the
      * input texture to perform effects such as edge detection or sharpening

src/PostProcess/depthOfFieldBlurPostProcess.ts

@@ -1,3 +1,10 @@
+import { Nullable } from "types";
+import { Vector2 } from "Math";
+import { Camera } from "Cameras";
+import { Effect, Texture } from "Materials";
+import { PostProcess, BlurPostProcess, Scene, PostProcessOptions } from "PostProcess";
+import { Engine } from "Engine";
+    
     /**
      * The DepthOfFieldBlurPostProcess applied a blur in a give direction.
      * This blur differs from the standard BlurPostProcess as it attempts to avoid blurring pixels
@@ -21,7 +28,7 @@
          * @param textureType Type of textures used when performing the post process. (default: 0)
          * @param blockCompilation If compilation of the shader should not be done in the constructor. The updateEffect method can be used to compile the shader at a later time. (default: false)
          */
-        constructor(name: string, scene: Scene, public direction: Vector2, kernel: number, options: number | PostProcessOptions, camera: Nullable<Camera>, circleOfConfusion: PostProcess, imageToBlur: Nullable<PostProcess> = null, samplingMode: number = Texture.BILINEAR_SAMPLINGMODE, engine?: Engine, reusable?: boolean, textureType: number = Engine.TEXTURETYPE_UNSIGNED_INT, blockCompilation = false) {
+        constructor(name: string, scene: Scene, public direction: Vector2, kernel: number, options: number | PostProcessOptions, camera: Nullable<Camera>, circleOfConfusion: PostProcess, imageToBlur: Nullable<PostProcess> = null, engine?: Engine, reusable?: boolean, blockCompilation = false) {
             super(name, direction, kernel, options, camera, samplingMode = Texture.BILINEAR_SAMPLINGMODE, engine, reusable, textureType = Engine.TEXTURETYPE_UNSIGNED_INT, `#define DOF 1\r\n`, blockCompilation);
 
             this.onApplyObservable.add((effect: Effect) => {
@@ -34,4 +41,4 @@
                 }
             });
         }
-    }
+    }

src/PostProcess/depthOfFieldEffect.ts

@@ -1,3 +1,9 @@
+import { Nullable } from "types";
+import { Vector2 } from "Math";
+import { Camera } from "Cameras";
+import { RenderTargetTexture, Texture } from "Materials";
+import { PostProcess, PostProcessRenderEffect, CircleOfConfusionPostProcess, DepthOfFieldBlurPostProcess, DepthOfFieldMergePostProcess, Scene } from "PostProcess";
+    
     /**
      * Specifies the level of max blur that should be applied when using the depth of field effect
      */

src/PostProcess/depthOfFieldMergePostProcess.ts

@@ -1,3 +1,8 @@
+import { Nullable } from "types";
+import { Camera } from "Cameras";
+import { Effect } from "Materials";
+import { PostProcess } from "PostProcess";
+import { Engine } from "Engine";
     /**
      * Options to be set when merging outputs from the default pipeline.
      */
@@ -72,4 +77,4 @@
             }
             super.updateEffect(defines, uniforms, samplers, indexParameters, onCompiled, onError);
         }
-    }
+    }

src/PostProcess/displayPassPostProcess.ts

@@ -1,4 +1,9 @@
-    /**
+import { Nullable } from "types";
+import { Camera } from "Cameras";
+import { PostProcess, PostProcessOptions } from "PostProcess";
+import { Engine } from "Engine";
+    
+    /**
      * DisplayPassPostProcess which produces an output the same as it's input
      */
     export class DisplayPassPostProcess extends PostProcess {
@@ -14,4 +19,4 @@
         constructor(name: string, options: number | PostProcessOptions, camera: Nullable<Camera>, samplingMode?: number, engine?: Engine, reusable?: boolean) {
             super(name, "displayPass", ["passSampler"], ["passSampler"], options, camera, samplingMode, engine, reusable);
         }
-    }
+    }

src/PostProcess/extractHighlightsPostProcess.ts

@@ -1,3 +1,9 @@
+import { Nullable } from "types";
+import { Camera } from "Cameras";
+import { Effect } from "Materials";
+import { PostProcess, PostProcessOptions } from "PostProcess";
+import { Engine } from "Engine";
+    
     /**
      * The extract highlights post process sets all pixels to black except pixels above the specified luminance threshold. Used as the first step for a bloom effect.
      */
@@ -24,4 +30,4 @@
                 effect.setFloat('exposure', this._exposure);
             });
         }
-    }
+    }

src/PostProcess/filterPostProcess.ts

@@ -1,3 +1,9 @@
+import { Nullable } from "types";
+import { Matrix } from "Math";
+import { Camera } from "Cameras";
+import { Effect } from "Materials";
+import { PostProcess, PostProcessOptions } from "PostProcess";
+import { Engine } from "Engine";
     /**
      * Applies a kernel filter to the image
      */
@@ -27,4 +33,4 @@
                 effect.setMatrix("kernelMatrix", this.kernelMatrix);
             };
         }
-    }
+    }

src/PostProcess/fxaaPostProcess.ts

@@ -1,4 +1,10 @@
-    /**
+import { Nullable } from "types";
+import { Camera } from "Cameras";
+import { Effect, Texture } from "Materials";
+import { PostProcess, PostProcessOptions } from "PostProcess";
+import { Engine } from "Engine";
+    
+    /**
      * Fxaa post process
      * @see https://doc.babylonjs.com/how_to/how_to_use_postprocesses#fxaa
      */
@@ -33,4 +39,4 @@
 
             return null;
         }
-    }
+    }

src/PostProcess/grainPostProcess.ts

@@ -1,3 +1,9 @@
+import { Nullable } from "types";
+import { Camera } from "Cameras";
+import { Effect } from "Materials";
+import { PostProcess, PostProcessOptions } from "PostProcess";
+import { Engine } from "Engine";
+    
     /**
      * The GrainPostProcess adds noise to the image at mid luminance levels
      */
@@ -29,4 +35,4 @@
                 effect.setFloat('animatedSeed', this.animated ? Math.random() + 1 : 1);
             });
         }
-    }
+    }

src/PostProcess/highlightsPostProcess.ts

@@ -1,3 +1,7 @@
+import { Nullable } from "types";
+import { Camera } from "Cameras";
+import { PostProcess, PostProcessOptions } from "PostProcess";
+import { Engine } from "Engine";
     /**
      * Extracts highlights from the image
      * @see https://doc.babylonjs.com/how_to/how_to_use_postprocesses
@@ -17,4 +21,4 @@
         constructor(name: string, options: number | PostProcessOptions, camera: Nullable<Camera>, samplingMode?: number, engine?: Engine, reusable?: boolean, textureType: number = Engine.TEXTURETYPE_UNSIGNED_INT) {
             super(name, "highlights", null, null, options, camera, samplingMode, engine, reusable, null, textureType);
         }
-    }
+    }

src/PostProcess/imageProcessingPostProcess.ts

@@ -1,3 +1,10 @@
+import { Nullable } from "types";
+import { Observer, serialize } from "Tools";
+import { Color4 } from "Math";
+import { Camera } from "Cameras";
+import { BaseTexture, ImageProcessingConfiguration, Effect, ColorCurves, IImageProcessingConfigurationDefines } from "Materials";
+import { PostProcess, Scene, PostProcessOptions } from "PostProcess";
+import { Engine } from "Engine";
     /**
      * ImageProcessingPostProcess
      * @see https://doc.babylonjs.com/how_to/how_to_use_postprocesses#imageprocessing
@@ -69,7 +76,7 @@
 
             // Attaches observer.
             if (this._imageProcessingConfiguration) {
-                this._imageProcessingObserver = this._imageProcessingConfiguration.onUpdateParameters.add((conf) => {
+                this._imageProcessingObserver = this._imageProcessingConfiguration.onUpdateParameters.add(() => {
                     this._updateParameters();
                 });
             }
@@ -380,4 +387,4 @@
                 this.imageProcessingConfiguration.applyByPostProcess = false;
             }
         }
-    }
+    }

src/PostProcess/motionBlurPostProcess.ts

@@ -1,3 +1,11 @@
+import { Nullable } from "types";
+import { Tools } from "Tools";
+import { Vector2 } from "Math";
+import { Camera } from "Cameras";
+import { Effect } from "Materials";
+import { PostProcess, Scene, PostProcessOptions } from "PostProcess";
+import { Engine } from "Engine";
+import { GeometryBufferRenderer } from "Rendering";
     /**
      * The Motion Blur Post Process which blurs an image based on the objects velocity in scene.
      * Velocity can be affected by each object's rotation, position and scale depending on the transformation speed.

src/PostProcess/passPostProcess.ts

@@ -1,3 +1,7 @@
+import { Nullable } from "types";
+import { Camera } from "Cameras";
+import { PostProcess, PostProcessOptions } from "PostProcess";
+import { Engine } from "Engine";
     /**
      * PassPostProcess which produces an output the same as it's input
      */
@@ -16,4 +20,4 @@
         constructor(name: string, options: number | PostProcessOptions, camera: Nullable<Camera> = null, samplingMode?: number, engine?: Engine, reusable?: boolean, textureType: number = Engine.TEXTURETYPE_UNSIGNED_INT, blockCompilation = false) {
             super(name, "pass", null, null, options, camera, samplingMode, engine, reusable, undefined, textureType, undefined, null, blockCompilation);
         }
-    }
+    }

src/PostProcess/postProcess.ts

@@ -1,3 +1,10 @@
+import { Nullable } from "types";
+import { Observable, Observer, SmartArray, Tools } from "Tools";
+import { Color4, Vector2 } from "Math";
+import { Camera, WebVRFreeCamera } from "Cameras";
+import { Effect, Texture, InternalTexture } from "Materials";
+import { Engine } from "Engine";
+import { Scene } from "Rendering/outlineRenderer";
     /**
      * Size options for a post process
      */
@@ -537,7 +544,7 @@
         public apply(): Nullable<Effect> {
             // Check
             if (!this._effect || !this._effect.isReady()) {
-                return null;
+                return null;
             }
 
             // States

src/PostProcess/postProcessManager.ts

@@ -1,3 +1,9 @@
+import { Nullable } from "types";
+import { Material, InternalTexture } from "Materials";
+import { PostProcess } from "PostProcess";
+import { Engine } from "Engine";
+import { Scene } from "scene";
+import { VertexBuffer } from "Mesh";
     /**
 	 * PostProcessManager is used to manage one or more post processes or post process pipelines
      * See https://doc.babylonjs.com/how_to/how_to_use_postprocesses
@@ -206,4 +212,4 @@
                 this._indexBuffer = null;
             }
         }
-    }
+    }

src/PostProcess/refractionPostProcess.ts

@@ -1,3 +1,8 @@
+import { Color3 } from "Math";
+import { Camera } from "Cameras";
+import { Effect, Texture } from "Materials";
+import { PostProcess, PostProcessOptions } from "PostProcess";
+import { Engine } from "Engine";
     /**
      * Post process which applies a refractin texture
      * @see https://doc.babylonjs.com/how_to/how_to_use_postprocesses#refraction
@@ -80,4 +85,4 @@
 
             super.dispose(camera);
         }
-    }
+    }

src/PostProcess/sharpenPostProcess.ts

@@ -1,3 +1,8 @@
+import { Nullable } from "types";
+import { Camera } from "Cameras";
+import { Effect } from "Materials";
+import { PostProcess, PostProcessOptions } from "PostProcess";
+import { Engine } from "Engine";
     /**
      * The SharpenPostProcess applies a sharpen kernel to every pixel
      * See http://en.wikipedia.org/wiki/Kernel_(image_processing)

src/PostProcess/stereoscopicInterlacePostProcess.ts

@@ -1,3 +1,9 @@
+import { Nullable } from "types";
+import { Vector2 } from "Math";
+import { Camera } from "Cameras";
+import { Effect } from "Materials";
+import { PostProcess } from "PostProcess";
+import { Engine } from "Engine";
     /**
      * StereoscopicInterlacePostProcess used to render stereo views from a rigged camera
      */

src/PostProcess/tonemapPostProcess.ts

@@ -1,3 +1,7 @@
+import { Camera } from "Cameras";
+import { Effect, Texture } from "Materials";
+import { PostProcess } from "PostProcess";
+import { Engine } from "Engine";
     /** Defines operator used for tonemapping */
     export enum TonemappingOperator {
         /** Hable */
@@ -33,16 +37,16 @@
             var defines = "#define ";
 
             if (this._operator === TonemappingOperator.Hable) {
-                defines += "HABLE_TONEMAPPING";
+                defines += "HABLE_TONEMAPPING";
             }
             else if (this._operator === TonemappingOperator.Reinhard) {
-                defines += "REINHARD_TONEMAPPING";
+                defines += "REINHARD_TONEMAPPING";
                  }
             else if (this._operator === TonemappingOperator.HejiDawson) {
-                defines += "OPTIMIZED_HEJIDAWSON_TONEMAPPING";
+                defines += "OPTIMIZED_HEJIDAWSON_TONEMAPPING";
                  }
             else if (this._operator === TonemappingOperator.Photographic) {
-                defines += "PHOTOGRAPHIC_TONEMAPPING";
+                defines += "PHOTOGRAPHIC_TONEMAPPING";
                  }
 
             //sadly a second call to create the effect.

src/PostProcess/volumetricLightScatteringPostProcess.ts

@@ -1,3 +1,10 @@
+import { SmartArray, Tools, serializeAsVector3, serialize, serializeAsMeshReference } from "Tools";
+import { Color4, Color3, Vector2, Vector3, Matrix, Viewport } from "Math";
+import { Mesh, SubMesh, AbstractMesh, Scene, VertexBuffer } from "Mesh";
+import { Camera } from "Cameras";
+import { Material, StandardMaterial, RenderTargetTexture, Effect, Texture } from "Materials";
+import { PostProcess } from "PostProcess";
+import { Engine } from "Engine";
     /**
      *  Inspired by http://http.developer.nvidia.com/GPUGems3/gpugems3_ch13.html
      */
@@ -424,7 +431,7 @@
             this._screenCoordinates.y = pos.y / this._viewPort.height;
 
             if (this.invert) {
-                this._screenCoordinates.y = 1.0 - this._screenCoordinates.y;
+                this._screenCoordinates.y = 1.0 - this._screenCoordinates.y;
             }
         }
 
@@ -446,4 +453,4 @@
 
             return mesh;
         }
-    }
+    }

src/PostProcess/vrDistortionCorrectionPostProcess.ts

@@ -1,3 +1,7 @@
+import { Vector2 } from "Math";
+import { Camera, VRCameraMetrics } from "Cameras";
+import { Effect, Texture } from "Materials";
+import { PostProcess } from "PostProcess";
     /**
      * VRDistortionCorrectionPostProcess used for mobile VR
      */

src/Probes/reflectionProbe.ts

@@ -1,3 +1,8 @@
+import { RenderTargetTexture } from "Materials";
+import { Matrix, Vector3 } from "Math";
+import { AbstractMesh } from "Mesh";
+import { Nullable } from "types";
+
     export interface Scene {
         /**
          * The list of reflection probes added to the scene
@@ -161,4 +166,4 @@
                 (<any>this._renderTargetTexture) = null;
             }
         }
-    }
+    }

src/Rendering/boundingBoxRenderer.ts

@@ -1,3 +1,12 @@
+import { Scene } from "scene";
+import { AbstractMesh, VertexBuffer, SubMesh, VertexData } from "Mesh";
+import { Color3, Matrix } from "Math";
+import { SmartArray } from "Tools";
+import { Nullable, FloatArray } from "types";
+import { ISceneComponent, SceneComponentConstants } from "sceneComponent";
+import { BoundingBox } from "Culling";
+import { ShaderMaterial, Material, Effect } from "Materials";
+
     export interface Scene {
         /** @hidden (Backing field) */
         _boundingBoxRenderer: BoundingBoxRenderer;
@@ -303,4 +312,4 @@
             }
             this.scene.getEngine()._releaseBuffer(this._indexBuffer);
         }
-    }
+    }

src/Rendering/depthRenderer.ts

@@ -1,3 +1,14 @@
+import { Nullable } from "types";
+import { Color4 } from "Math";
+import { SubMesh, VertexBuffer } from "Mesh";
+import { SmartArray } from "Tools";
+import { Scene } from "scene";
+import { RenderTargetTexture, Effect, Texture, Material } from "Materials";
+import { Camera } from "Cameras";
+import { Engine } from "Engine";
+import { SceneComponentConstants } from "sceneComponent";
+import { DepthRendererSceneComponent } from "Rendering";
+
     /**
      * This represents a depth renderer in Babylon.
      * A depth renderer will render to it's depth map every frame which can be displayed or used in post processing
@@ -208,4 +219,4 @@
         public dispose(): void {
             this._depthMap.dispose();
         }
-    }
+    }

src/Rendering/depthRendererSceneComponent.ts

@@ -1,3 +1,12 @@
+import { Nullable } from "types";
+import { Scene } from "scene";
+import { SmartArrayNoDuplicate } from "Tools";
+import { DepthRenderer } from "Rendering";
+import { Camera } from "Cameras";
+import { Engine } from "Engine";
+import { ISceneComponent, SceneComponentConstants } from "sceneComponent";
+import { RenderTargetTexture } from "Materials";
+
     export interface Scene {
         /** @hidden (Backing field) */
         _depthRenderer: { [id: string]: DepthRenderer };
@@ -119,4 +128,4 @@
                 }
             }
         }
-    }
+    }

src/Rendering/edgesRenderer.ts

@@ -1,3 +1,13 @@
+import { Nullable } from "types";
+import { AbstractMesh, LinesMesh, InstancedMesh, VertexBuffer } from "Mesh";
+import { Vector3 } from "Math";
+import { IDisposable } from "scene";
+import { Observer } from "Tools";
+import { LineEdgesRenderer } from "Rendering";
+import { ShaderMaterial, Effect, Material } from "Materials";
+import { Camera } from "Cameras";
+import { Engine } from "Engine";
+
     export interface AbstractMesh {
         /**
          * Disables the mesh edge rendering mode
@@ -485,4 +495,4 @@
             engine.drawElementsType(Material.TriangleFillMode, 0, this._indicesCount);
             this._lineShader.unbind();
         }
-    }
+    }

src/Rendering/geometryBufferRenderer.ts

@@ -1,3 +1,11 @@
+import { Matrix, Color4 } from "Math";
+import { Mesh, SubMesh, VertexBuffer } from "Mesh";
+import { Engine } from "Particles";
+import { SmartArray } from "Tools";
+import { MultiRenderTarget, Effect, Texture, Material } from "Materials";
+import { GeometryBufferRendererSceneComponent } from "Rendering";
+import { Scene } from "scene";
+
     /**
      * This renderer is helpfull to fill one of the render target with a geometry buffer.
      */
@@ -353,4 +361,4 @@
                 }
             };
         }
-    }
+    }

src/Rendering/geometryBufferRendererSceneComponent.ts

@@ -1,3 +1,10 @@
+import { Nullable } from "types";
+import { GeometryBufferRenderer } from "Rendering";
+import { Scene } from "scene";
+import { ISceneComponent, SceneComponentConstants } from "sceneComponent";
+import { SmartArrayNoDuplicate } from "Tools";
+import { RenderTargetTexture } from "Materials";
+
     export interface Scene {
         /** @hidden (Backing field) */
         _geometryBufferRenderer: Nullable<GeometryBufferRenderer>;
@@ -105,4 +112,4 @@
                 renderTargets.push(this.scene._geometryBufferRenderer.getGBuffer());
             }
         }
-    }
+    }

src/Rendering/lineEdgesRenderer.ts

@@ -1,3 +1,7 @@
+import { EdgesRenderer, AbstractMesh } from "Rendering";
+import { VertexBuffer } from "Mesh";
+import { Tmp, Vector3 } from "Math";
+
     /**
      * LineEdgesRenderer for LineMeshes to remove unnecessary triangulation
      */

src/Rendering/outlineRenderer.ts

@@ -1,3 +1,9 @@
+import { AbstractMesh, SubMesh, _InstancesBatch, VertexBuffer } from "Mesh";
+import { Scene } from "scene";
+import { Engine } from "Particles";
+import { ISceneComponent, SceneComponentConstants } from "sceneComponent";
+import { Effect, Material } from "Materials";
+
     export interface Scene {
         /** @hidden */
         _outlineRenderer: OutlineRenderer;
@@ -282,4 +288,4 @@
                 this._engine.setAlphaMode(currentMode);
             }
         }
-    }
+    }

src/Rendering/renderingGroup.ts

@@ -1,3 +1,15 @@
+import { Scene } from "./boundingBoxRenderer";
+import { SmartArray } from "Tools";
+import { SubMesh } from "Mesh";
+import { Nullable } from "types";
+import { AbstractMesh } from "Culling";
+import { Vector3 } from "Math";
+import { IParticleSystem } from "Particles";
+import { IEdgesRenderer } from "Rendering";
+import { ISpriteManager } from "Sprites";
+import { Engine } from "Engine";
+import { Material } from "Materials";
+
     /**
      * This represents the object necessary to create a rendering group.
      * This is exclusively used and created by the rendering manager.
@@ -404,4 +416,4 @@
             }
             this._scene.onAfterSpritesRenderingObservable.notifyObservers(this._scene);
         }
-    }
+    }

src/Rendering/renderingManager.ts

@@ -1,3 +1,13 @@
+import { Nullable } from "types";
+import { RenderingGroupInfo, Scene } from "scene";
+import { AbstractMesh } from "Culling";
+import { SubMesh } from "Mesh";
+import { RenderingGroup } from "Rendering";
+import { SmartArray } from "Tools";
+import { ISpriteManager } from "Sprites";
+import { IParticleSystem } from "Particles";
+import { Material } from "Materials";
+
     /**
      * Interface describing the different options available in the rendering manager
      * regarding Auto Clear between groups.
@@ -99,7 +109,7 @@
                 this._depthStencilBufferAlreadyCleaned = index === RenderingManager.MIN_RENDERINGGROUPS;
                 var renderingGroup = this._renderingGroups[index];
                 if (!renderingGroup) {
-                    continue;
+                    continue;
                 }
 
                 let renderingGroupMask = Math.pow(2, index);

src/Rendering/utilityLayerRenderer.ts

@@ -1,3 +1,10 @@
+import { IDisposable, Scene } from "scene";
+import { Nullable } from "types";
+import { Observable, Observer } from "Tools";
+import { AbstractMesh } from "Culling";
+import { PointerInfoPre, PointerInfo } from "Events";
+import { PickingInfo } from "Collisions";
+
     /**
      * Renders a layer on top of an existing scene
      */

src/Sprites/sprite.ts

@@ -1,3 +1,9 @@
+import { Vector3, Color4 } from "Math";
+import { Nullable } from "types";
+import { ActionManager } from "Actions";
+import { ISpriteManager } from "Sprites";
+
+
     /**
      * Class used to represent a sprite
      * @see http://doc.babylonjs.com/babylon101/sprites
@@ -104,7 +110,7 @@
         /** @hidden */
         public _animate(deltaTime: number): void {
             if (!this._animationStarted) {
-                return;
+                return;
             }
 
             this._time += deltaTime;
@@ -136,4 +142,4 @@
                 }
             }
         }
-    }
+    }

src/Sprites/spriteManager.ts

@@ -1,3 +1,9 @@
+import { IDisposable, Scene } from "scene";
+import { Nullable } from "types";
+import { Observable, Observer } from "Tools";
+import { VertexBuffer } from "Mesh";
+import { Vector3 } from "Math";
+
     /**
      * Defines the minimum interface to fullfil in order to be a sprite manager.
      */
@@ -182,17 +188,17 @@
             var arrayOffset = index * 16;
 
             if (offsetX === 0) {
-                offsetX = this._epsilon;
+                offsetX = this._epsilon;
             }
             else if (offsetX === 1) {
-                offsetX = 1 - this._epsilon;
+                offsetX = 1 - this._epsilon;
                  }
 
             if (offsetY === 0) {
-                offsetY = this._epsilon;
+                offsetY = this._epsilon;
             }
             else if (offsetY === 1) {
-                offsetY = 1 - this._epsilon;
+                offsetY = 1 - this._epsilon;
                  }
 
             this._vertexData[arrayOffset] = sprite.position.x;
@@ -284,7 +290,7 @@
         public render(): void {
             // Check
             if (!this._effectBase.isReady() || !this._effectFog.isReady() || !this._spriteTexture || !this._spriteTexture.isReady()) {
-                return;
+                return;
             }
 
             var engine = this._scene.getEngine();

src/Sprites/spriteSceneComponent.ts

@@ -1,3 +1,12 @@
+import { Nullable } from "types";
+import { Observable } from "Tools";
+import { Scene } from "scene";
+import { Sprite, ISpriteManager } from "Sprites";
+import { Ray } from "Culling";
+import { Camera } from "Cameras";
+import { PickingInfo } from "Collisions";
+import { ISceneComponent, SceneComponentConstants } from "sceneComponent";
+
     export interface Scene {
         /** @hidden */
         _pointerOverSprite: Nullable<Sprite>;
@@ -85,11 +94,11 @@
 
                 var result = spriteManager.intersects(ray, camera, predicate, fastCheck);
                 if (!result || !result.hit) {
-                    continue;
+                    continue;
                 }
 
                 if (!fastCheck && pickingInfo != null && result.distance >= pickingInfo.distance) {
-                    continue;
+                    continue;
                 }
 
                 pickingInfo = result;

src/States/alphaCullingState.ts

@@ -1,3 +1,5 @@
+import { Nullable } from "types";
+
     /**
      * @hidden
      **/
@@ -141,4 +143,4 @@
                 this._isBlendConstantsDirty = false;
             }
         }
-    }
+    }

src/States/depthCullingState.ts

@@ -1,3 +1,5 @@
+import { Nullable } from "types";
+
     /**
      * @hidden
      **/
@@ -201,4 +203,4 @@
                 this._isFrontFaceDirty = false;
             }
         }
-    }
+    }

src/States/stencilState.ts

@@ -1,3 +1,5 @@
+import { Engine } from "Engine";
+
     /**
      * @hidden
      **/
@@ -182,4 +184,4 @@
                 this._isStencilOpDirty = false;
             }
         }
-    }
+    }

src/Tools/HDR/cubemapToSphericalPolynomial.ts

@@ -1,3 +1,10 @@
+import { Vector3, SphericalPolynomial, SphericalHarmonics, Scalar, ToLinearSpace, Color3 } from "Math";
+import { BaseTexture } from "Materials";
+import { Nullable } from "types";
+import { Engine } from "Engine";
+import { CubeMapInfo } from "Tools";
+
+
     class FileFaceOrientation {
         public name: string;
         public worldAxisForNormal: Vector3; // the world axis corresponding to the normal to the face

src/Tools/HDR/hdr.ts

@@ -1,3 +1,5 @@
+import { CubeMapInfo, PanoramaToCubeMapTools } from ".";
+
     /**
      * Header information of HDR texture files.
      */

src/Tools/HDR/panoramaToCubemap.ts

@@ -1,3 +1,7 @@
+import { Nullable } from "types";
+import { Vector3 } from "Math";
+import { Engine } from "Engine";
+
     /**
      * CubeMap information grouping all the data for each faces as well as the cubemap size.
      */

src/Tools/assetsManager.ts

@@ -1,3 +1,11 @@
+import { Scene } from "scene";
+import { AbstractMesh } from "Mesh";
+import { IParticleSystem } from "Particles";
+import { Skeleton } from "Bones";
+import { SceneLoader } from "Loading";
+import { Tools, Observable } from "Tools";
+import { BaseTexture, Texture, CubeTexture, HDRCubeTexture } from "Materials";
+
     /**
      * Defines the list of states available for a task inside a AssetsManager
      */

src/abstractScene.ts

@@ -1,3 +1,16 @@
+import { Scene } from "Physics";
+import { Nullable } from "types";
+import { AbstractMesh, Geometry, TransformNode } from "Mesh";
+import { Skeleton } from "Bones";
+import { MorphTargetManager } from "Morph";
+import { AssetContainer } from "assetContainer";
+import { IParticleSystem } from "Particles";
+import { AnimationGroup } from "Animations";
+import { MultiMaterial, Material, BaseTexture } from "Materials";
+import { ActionManager } from "Actions";
+import { Camera } from "Cameras";
+import { Light } from "Lights";
+
     /**
      * Defines how the parser contract is defined.
      * These parsers are used to parse a list of specific assets (like particle systems, etc..)

src/scene.ts

@@ -1,3 +1,25 @@
+import { Nullable } from "types";
+import { IAnimatable, Observable, Observer, SmartArrayNoDuplicate, PerfCounter, IFileRequest, SmartArray, StringDictionary, Tools, ISmartArrayLike, Tags } from "Tools";
+import { Color4, Color3, Plane, Vector2, Vector3, Matrix, Tmp, Quaternion, Frustum } from "Math";
+import { Geometry, TransformNode, Mesh, SubMesh, AbstractMesh } from "Mesh";
+import { IParticleSystem } from "Particles";
+import { Skeleton, Bone } from "Bones";
+import { MorphTargetManager } from "Morph";
+import { Camera } from "Cameras";
+import { AbstractScene } from "abstractScene";
+import { BaseTexture, Material, ImageProcessingConfiguration, StandardMaterial, RenderTargetTexture, Effect, UniformBuffer, MultiMaterial, Texture } from "Materials";
+import { AnimationPropertiesOverride, Animatable, RuntimeAnimation, AnimationGroup } from "Animations";
+import { Light } from "Lights";
+import { PickingInfo, ICollisionCoordinator, CollisionCoordinatorLegacy, CollisionWorker, CollisionCoordinatorWorker } from "Collisions";
+import { PointerEventTypes, PointerInfoPre, PointerInfo, KeyboardInfoPre, KeyboardInfo, KeyboardEventTypes } from "Events";
+import { ActionManager, ActionEvent } from "Actions";
+import { PostProcess, PostProcessManager } from "PostProcess";
+import { IOfflineProvider } from "Offline";
+import { RenderingManager, IRenderingManagerAutoClearSetup } from "Rendering";
+import { ISceneComponent, ISceneSerializableComponent, Stage, SimpleStageAction, RenderTargetsStageAction, MeshStageAction, EvaluateSubMeshStageAction, ActiveMeshStageAction, CameraStageAction, RenderingGroupStageAction, RenderingMeshStageAction, PointerMoveStageAction, PointerUpDownStageAction } from "sceneComponent";
+import { Engine } from "Engine";
+import { Ray } from "Culling";
+
     /**
      * Define an interface for all classes that will hold resources
      */

src/sceneComponent.ts

@@ -1,3 +1,13 @@
+import { Scene } from "scene";
+import { AbstractScene } from "Audio/audioSceneComponent";
+import { AbstractMesh } from "Culling";
+import { SubMesh, _InstancesBatch } from "Mesh";
+import { SmartArrayNoDuplicate } from "Tools";
+import { Nullable } from "types";
+import { Camera } from "Cameras";
+import { RenderTargetTexture } from "Materials";
+import { PickingInfo } from "Collisions";
+
     /**
      * Groups all the scene component constants in one place to ease maintenance.
      * @hidden