More Targetted import

src/Loading/Plugins/babylonFileLoader.ts

@@ -2,21 +2,27 @@ import { Tools } from "Tools";
 import { Nullable } from "types";
 import { Camera } from "Cameras";
 import { Scene } from "scene";
-import { Vector3, Color3, Color4 } from "Math";
-import { Mesh, AbstractMesh, Geometry, TransformNode, BoxGeometry, SphereGeometry, CylinderGeometry, TorusGeometry, GroundGeometry, PlaneGeometry, TorusKnotGeometry } from "Mesh";
-import { Material, CubeTexture, HDRCubeTexture } from "Materials";
-import { Animation, AnimationGroup } from "Animations";
-import { Light } from "Lights";
+import { Vector3, Color3, Color4 } from "Math/math";
+import { Mesh } from "Mesh/mesh";
+import { AbstractMesh } from "Mesh/abstractMesh";
+import { Geometry, BoxGeometry, SphereGeometry, CylinderGeometry, TorusGeometry, GroundGeometry, PlaneGeometry, TorusKnotGeometry } from "Mesh/geometry";
+import { TransformNode } from "Mesh/transformNode";
+import { Material } from "Materials/material";
+import { CubeTexture } from "Materials/Textures/cubeTexture";
+import { HDRCubeTexture } from "Materials/Textures/hdrCubeTexture";
+import { Animation } from "Animations/animation";
+import { AnimationGroup } from "Animations/animationGroup";
+import { Light } from "Lights/light";
 import { SceneComponentConstants } from "sceneComponent";
-import { _TimeToken } from "Instrumentation";
-import { SceneLoader } from "Loading";
+import { _TimeToken } from "Instrumentation/timeToken";
+import { SceneLoader } from "Loading/sceneLoader";
 import { _DepthCullingState, _StencilState, _AlphaState } from "States";
 import { AbstractScene } from "abstractScene";
 import { AssetContainer } from "assetContainer";
-import { ActionManager } from "Actions";
-import { IParticleSystem } from "Particles";
-import { Skeleton } from "Bones";
-import { MorphTargetManager } from "Morph";
+import { ActionManager } from "Actions/actionManager";
+import { IParticleSystem } from "Particles/IParticleSystem";
+import { Skeleton } from "Bones/skeleton";
+import { MorphTargetManager } from "Morph/morphTargetManager";
 import { CannonJSPlugin, OimoJSPlugin } from "Physics";
     var parseMaterialById = (id: string, parsedData: any, scene: Scene, rootUrl: string) => {
         for (var index = 0, cache = parsedData.materials.length; index < cache; index++) {

src/Loading/loadingScreen.ts

@@ -1,6 +1,5 @@
 import { Nullable } from "types";
-import { _TimeToken } from "Instrumentation";
-import { ILoadingScreen } from "Loading";
+import { _TimeToken } from "Instrumentation/timeToken";
 import { _DepthCullingState, _StencilState, _AlphaState } from "States";
     /**
      * Interface used to present a loading screen while loading a scene

src/Loading/sceneLoader.ts

@@ -1,15 +1,17 @@
-import { Observable, Tools, IFileRequest, FilesInput } from "Tools";
+import { IFileRequest, Tools } from "Tools/tools";
+import { Observable } from "Tools/observable";
+import { FilesInput } from "Tools/filesInput";
 import { Nullable } from "types";
 import { Scene } from "scene";
-import { Engine } from "Engine";
-import { AbstractMesh } from "Mesh";
-import { AnimationGroup } from "Animations";
-import { _TimeToken } from "Instrumentation";
-import { IOfflineProvider } from "Offline";
+import { Engine } from "Engine/engine";
+import { AbstractMesh } from "Mesh/abstractMesh";
+import { AnimationGroup } from "Animations/animationGroup";
+import { _TimeToken } from "Instrumentation/timeToken";
+import { IOfflineProvider } from "Offline/IOfflineProvider";
 import { _DepthCullingState, _StencilState, _AlphaState } from "States";
 import { AssetContainer } from "assetContainer";
-import { IParticleSystem } from "Particles";
-import { Skeleton } from "Bones";
+import { IParticleSystem } from "Particles/IParticleSystem";
+import { Skeleton } from "Bones/skeleton";
     /**
      * Class used to represent data loading progression
      */

src/Materials/Background/backgroundMaterial.ts

@@ -1,15 +1,27 @@
-import { serialize, serializeAsColor3, expandToProperty, serializeAsTexture, serializeAsVector3, serializeAsImageProcessingConfiguration } from "Tools/decorators";
-import { Observer, Tools, SmartArray, SerializationHelper } from "Tools";
+import { SerializationHelper, serialize, serializeAsColor3, expandToProperty, serializeAsTexture, serializeAsVector3, serializeAsImageProcessingConfiguration } from "Tools/decorators";
+import { SmartArray } from "Tools/smartArray";
+import { Observer } from "Tools/observable";
+import { Tools } from "Tools/tools";
 import { Nullable, int, float } from "types";
 import { Scene } from "scene";
-import { Matrix, Vector3, Color3, Vector4 } from "Math";
-import { Engine } from "Engine";
-import { Mesh, AbstractMesh, VertexBuffer, SubMesh } from "Mesh";
-import { MaterialDefines } from "../material";
-import { PushMaterial } from "../pushMaterial";
-import { StandardMaterial, ImageProcessingConfiguration, RenderTargetTexture, Texture, Effect, BaseTexture, MaterialHelper, IImageProcessingConfigurationDefines, ColorCurves, EffectFallbacks, EffectCreationOptions } from "Materials";
-import { IShadowLight } from "Lights";
-import { _TimeToken } from "Instrumentation";
+import { Matrix, Vector3, Color3, Vector4 } from "Math/math";
+import { Engine } from "Engine/engine";
+import { VertexBuffer } from "Mesh/vertexBuffer";
+import { SubMesh } from "Mesh/subMesh";
+import { AbstractMesh } from "Mesh/abstractMesh";
+import { Mesh } from "Mesh/mesh";
+import { Effect, EffectFallbacks, EffectCreationOptions } from "Materials/effect";
+import { MaterialHelper } from "Materials/materialHelper";
+import { MaterialDefines } from "Materials/material";
+import { PushMaterial } from "Materials/pushMaterial";
+import { StandardMaterial } from "Materials/standardMaterial";
+import { ColorCurves } from "Materials/colorCurves";
+import { ImageProcessingConfiguration, IImageProcessingConfigurationDefines } from "Materials/imageProcessingConfiguration";
+import { BaseTexture } from "Materials/Textures/baseTexture";
+import { Texture } from "Materials/Textures/texture";
+import { RenderTargetTexture } from "Materials/Textures/renderTargetTexture";
+import { IShadowLight } from "Lights/shadowLight";
+import { _TimeToken } from "Instrumentation/timeToken";
 import { _DepthCullingState, _StencilState, _AlphaState } from "States";
 
 import "Shaders/background.fragment";

src/Materials/imageProcessingConfiguration.ts

@@ -1,9 +1,12 @@
-import { serialize, serializeAsTexture, serializeAsColorCurves, serializeAsColor4 } from "Tools/decorators";
-import { Observable, Tools, SerializationHelper } from "Tools";
+import { serialize, SerializationHelper, serializeAsTexture, serializeAsColorCurves, serializeAsColor4 } from "Tools/decorators";
+import { Observable } from "Tools/observable";
+import { Tools } from "Tools/tools";
 import { Nullable } from "types";
-import { Color4 } from "Math";
+import { Color4 } from "Math/math";
 import { MaterialDefines } from "Materials/material";
-import { Effect, BaseTexture, ColorCurves } from "Materials";
+import { Effect } from "Materials/effect";
+import { BaseTexture } from "Materials/Textures/baseTexture";
+import { ColorCurves } from "Materials/colorCurves";
     /**
      * Interface to follow in your material defines to integrate easily the
      * Image proccessing functions.

src/Materials/material.ts

@@ -1,12 +1,23 @@
-import { serialize } from "Tools/decorators";
-import { Observer, Observable, Tools, SmartArray, SerializationHelper, IAnimatable, Tags } from "Tools";
+import { serialize, SerializationHelper } from "Tools/decorators";
+import { Tools, IAnimatable } from "Tools/tools";
+import { SmartArray } from "Tools/smartArray";
+import { Observer, Observable } from "Tools/observable";
+import { Tags } from "Tools/tags";
 import { Nullable } from "types";
 import { Scene } from "scene";
-import { Plane, Matrix } from "Math";
-import { Engine } from "Engine";
-import { Mesh, AbstractMesh, Geometry, BaseSubMesh, SubMesh } from "Mesh";
-import { StandardMaterial, RenderTargetTexture, UniformBuffer, Effect, BaseTexture, MultiMaterial } from "Materials";
-import { Animation } from "Animations";
+import { Plane, Matrix } from "Math/math";
+import { Engine } from "Engine/engine";
+import { BaseSubMesh, SubMesh } from "Mesh/subMesh";
+import { Geometry } from "Mesh/geometry";
+import { AbstractMesh } from "Mesh/abstractMesh";
+import { Mesh } from "Mesh/mesh";
+import { StandardMaterial } from "Materials/standardMaterial";
+import { MultiMaterial } from "Materials/multiMaterial";
+import { UniformBuffer } from "Materials/uniformBuffer";
+import { Effect } from "Materials/effect";
+import { BaseTexture } from "Materials/Textures/baseTexture";
+import { RenderTargetTexture } from "Materials/Textures/renderTargetTexture";
+import { Animation } from "Animations/animation";
 
 declare var BABYLON: any;
     /**

src/Materials/pushMaterial.ts

@@ -1,7 +1,8 @@
 import { Nullable } from "types";
 import { Scene } from "scene";
-import { Matrix } from "Math";
-import { Mesh, AbstractMesh } from "Mesh";
+import { Matrix } from "Math/math";
+import { AbstractMesh } from "Mesh/abstractMesh";
+import { Mesh } from "Mesh/mesh";
 import { Material } from "Materials/material";
 import { Effect } from "Materials/effect";
     /**

src/Materials/standardMaterial.ts

@@ -1,10 +1,26 @@
 import { serialize, Observer, SmartArray, SerializationHelper, serializeAsColor3, expandToProperty, IAnimatable, serializeAsTexture, serializeAsFresnelParameters } from "Tools";
 import { Nullable } from "types";
 import { Scene } from "scene";
-import { Matrix, Color3 } from "Math";
-import { Engine } from "Engine";
-import { Mesh, AbstractMesh, VertexBuffer, SubMesh } from "Mesh";
-import { ImageProcessingConfiguration, RenderTargetTexture, Material, Texture, BaseTexture, CubeTexture, MaterialHelper, IImageProcessingConfigurationDefines, PushMaterial, ColorCurves, EffectFallbacks, EffectCreationOptions, MaterialDefines, FresnelParameters } from "Materials";
+import { Matrix, Color3 } from "Math/math";
+import { Engine } from "Engine/engine";
+import { VertexBuffer } from "Mesh/vertexBuffer";
+import { SubMesh } from "Mesh/subMesh";
+import { AbstractMesh } from "Mesh/abstractMesh";
+import { Mesh } from "Mesh/mesh";
+
+import { ImageProcessingConfiguration, IImageProcessingConfigurationDefines } from "./imageProcessingConfiguration";
+import { ColorCurves } from "./colorCurves";
+import { FresnelParameters } from "./fresnelParameters";
+import { EffectFallbacks, EffectCreationOptions } from "./effect";
+import { Material, MaterialDefines } from "./material";
+import { PushMaterial } from "./pushMaterial";
+import { MaterialHelper } from "./materialHelper";
+
+import { BaseTexture } from "Materials/Textures/baseTexture";
+import { Texture } from "Materials/Textures/texture";
+import { CubeTexture } from "Materials/Textures/cubeTexture";
+import { RenderTargetTexture } from "Materials/Textures/renderTargetTexture";
+
 import "Shaders/default.fragment";
 import "Shaders/default.vertex";
 

src/Math/math.ts

@@ -1,4 +1,4 @@
-import { Tools } from "../Tools/tools";
+import { Tools } from "Tools/tools";
 import { Nullable, FloatArray, float } from "types";
 import { Scalar } from "Math/math.scalar";
 import { Engine } from "Engine/engine";

src/Mesh/Compression/dracoCompression.ts

@@ -1,7 +1,7 @@
-import { Tools } from "Tools";
+import { Tools } from "Tools/tools";
 import { Nullable } from "types";
 import { IDisposable } from "scene";
-import { VertexData } from "Mesh";
+import { VertexData } from "Mesh/mesh.vertexData";
 
 declare var DracoDecoderModule: any;
 declare var WebAssembly: any;

src/Mesh/abstractMesh.ts

@@ -1,19 +1,26 @@
-import { Observer, Observable, Tools } from "Tools";
+import { Tools } from "Tools/tools";
+import { Observer, Observable } from "Tools/observable";
 import { Nullable, FloatArray, IndicesArray } from "types";
-import { Camera } from "Cameras";
+import { Camera } from "Cameras/camera";
 import { Scene, IDisposable } from "scene";
-import { Quaternion, Matrix, Vector3, Color3, Color4, Plane, Tmp, Epsilon, Axis, Vector2 } from "Math";
-import { Engine } from "Engine";
-import { Node } from "Node";
-import { InstancedMesh, VertexBuffer, TransformNode, SubMesh, IGetSetVerticesData, VertexData } from "Mesh";
-import { PickingInfo, Collider, IntersectionInfo } from "Collisions";
-import { Ray, ICullable, BoundingInfo } from "Culling";
-import { Material, MaterialDefines } from "Materials";
-import { Light } from "Lights";
-import { ActionManager } from "Actions";
-import { Skeleton } from "Bones";
-import { IEdgesRenderer } from "Rendering";
-import { SolidParticle } from "Particles";
+import { Quaternion, Matrix, Vector3, Color3, Color4, Plane, Tmp, Epsilon, Axis, Vector2 } from "Math/math";
+import { Engine } from "Engine/engine";
+import { Node } from "node";
+import { VertexBuffer } from "Mesh/vertexBuffer";
+import { VertexData, IGetSetVerticesData } from "Mesh/mesh.vertexData";
+import { TransformNode } from "Mesh/transformNode";
+import { SubMesh } from "Mesh/subMesh";
+import { InstancedMesh } from "Mesh/instancedMesh";
+import { PickingInfo, IntersectionInfo } from "Collisions/pickingInfo";
+import { Collider } from "Collisions/collider";
+import { Ray } from "Culling/ray";
+import { ICullable, BoundingInfo } from "Culling/boundingInfo";
+import { Material, MaterialDefines } from "Materials/material";
+import { Light } from "Lights/light";
+import { ActionManager } from "Actions/actionManager";
+import { Skeleton } from "Bones/skeleton";
+import { IEdgesRenderer } from "Rendering/edgesRenderer";
+import { SolidParticle } from "Particles/solidParticle";
 
     /** @hidden */
     class _FacetDataStorage {

src/Mesh/buffer.ts

@@ -1,6 +1,7 @@
 import { Nullable, DataArray } from "types";
-import { Engine } from "Engine";
-import { Mesh, VertexBuffer } from "Mesh";
+import { Engine } from "Engine/engine";
+import { VertexBuffer } from "Mesh/vertexBuffer";
+import { Mesh } from "Mesh/mesh";
     /**
      * Class used to store data that will be store in GPU memory
      */

src/Mesh/csg.ts

@@ -1,8 +1,11 @@
 import { Nullable, FloatArray, IndicesArray } from "types";
 import { Scene } from "scene";
-import { Quaternion, Matrix, Vector3, Vector2 } from "Math";
-import { Mesh, AbstractMesh, VertexBuffer, SubMesh } from "Mesh";
-import { Material } from "Materials";
+import { Quaternion, Matrix, Vector3, Vector2 } from "Math/math";
+import { VertexBuffer } from "Mesh/vertexBuffer";
+import { AbstractMesh } from "Mesh/abstractMesh";
+import { SubMesh } from "Mesh/subMesh";
+import { Mesh } from "Mesh/mesh";
+import { Material } from "Materials/material";
     /**
      * Unique ID when we import meshes from Babylon to CSG
      */

src/Mesh/geometry.ts

@@ -1,12 +1,16 @@
     import { Tools, Tags } from "Tools";
     import { Nullable, FloatArray, DataArray, IndicesArray } from "types";
     import { Scene } from "scene";
-    import { Vector3, Vector2, Color4 } from "Math";
-    import { Engine } from "Engine";
-    import { Mesh, AbstractMesh, VertexBuffer, SubMesh, IGetSetVerticesData, VertexData } from "Mesh";
-    import { Effect } from "Materials";
-    import { SceneLoader } from "Loading";
-    import { BoundingInfo } from "index";
+    import { Vector3, Vector2, Color4 } from "Math/math";
+    import { Engine } from "Engine/engine";
+    import { IGetSetVerticesData, VertexData } from "Mesh/mesh.vertexData";
+    import { VertexBuffer } from "Mesh/vertexBuffer";
+    import { SubMesh } from "Mesh/subMesh";
+    import { AbstractMesh } from "Mesh/abstractMesh";
+    import { Mesh } from "Mesh/mesh";
+    import { Effect } from "Materials/effect";
+    import { SceneLoader } from "Loading/sceneLoader";
+    import { BoundingInfo } from "Culling/boundingInfo";
     /**
      * Class used to store geometry data (vertex buffers + index buffer)
      */

src/Mesh/groundMesh.ts

@@ -1,6 +1,7 @@
 import { Scene } from "scene";
-import { Vector3, Vector2, Tmp, Vector4 } from "Math";
-import { Mesh, VertexBuffer } from "Mesh";
+import { Vector3, Vector2, Tmp, Vector4 } from "Math/math";
+import { VertexBuffer } from "Mesh/vertexBuffer";
+import { Mesh } from "Mesh/mesh";
     /**
      * Mesh representing the gorund
      */

src/Mesh/instancedMesh.ts

@@ -1,11 +1,12 @@
-import { Tools } from "Tools";
+import { Tools } from "Tools/tools";
 import { Nullable, FloatArray, IndicesArray } from "types";
-import { Camera } from "Cameras";
-import { Vector3 } from "Math";
-import { Node } from "Node";
-import { Mesh, AbstractMesh } from "Mesh";
-import { Material } from "Materials";
-import { Skeleton } from "Bones";
+import { Camera } from "Cameras/camera";
+import { Vector3 } from "Math/math";
+import { Node } from "node";
+import { AbstractMesh } from "Mesh/abstractMesh";
+import { Mesh } from "Mesh/mesh";
+import { Material } from "Materials/material";
+import { Skeleton } from "Bones/skeleton";
 
     /**
      * Creates an instance based on a source mesh.

src/Mesh/linesMesh.ts

@@ -1,9 +1,14 @@
 import { Nullable } from "types";
 import { Scene } from "scene";
-import { Color3 } from "Math";
-import { Node } from "Node";
-import { Mesh, InstancedMesh, VertexBuffer, SubMesh } from "Mesh";
-import { Material, Effect, ShaderMaterial } from "Materials";
+import { Color3 } from "Math/math";
+import { Node } from "node";
+import { VertexBuffer } from "Mesh/vertexBuffer";
+import { SubMesh } from "Mesh/subMesh";
+import { Mesh } from "Mesh/mesh";
+import { InstancedMesh } from "Mesh/instancedMesh";
+import { Effect } from "Materials/effect";
+import { Material } from "Materials/material";
+import { ShaderMaterial } from "Materials/shaderMaterial";
     /**
      * Line mesh
      * @see https://doc.babylonjs.com/babylon101/parametric_shapes

src/Mesh/mesh.ts

@@ -1,18 +1,34 @@
-import { Observer, Observable, Tools, IAnimatable, Tags, AsyncLoop } from "Tools";
+import { Observer, Observable } from "Tools/observable";
+import { Tools, IAnimatable, AsyncLoop } from "Tools/tools";
+import { Tags } from "Tools/tags";
 import { Nullable, FloatArray, IndicesArray } from "types";
-import { Camera } from "Cameras";
+import { Camera } from "Cameras/camera";
 import { Scene } from "scene";
-import { Quaternion, Matrix, Vector3, Vector2, Color3, Color4, Plane, Vector4, Path3D } from "Math";
-import { Engine } from "Engine";
-import { Node } from "Node";
-import { AbstractMesh, Geometry, InstancedMesh, VertexBuffer, SubMesh, LinesMesh, IGetSetVerticesData, MeshLODLevel, VertexData, GroundMesh, MeshBuilder, Buffer } from "Mesh";
-import { BoundingSphere, BoundingInfo } from "Culling";
-import { Material, Effect } from "Materials";
-import { Animation } from "Animations";
-import { SceneLoader } from "Loading";
-import { Skeleton } from "Bones";
-import { MorphTargetManager } from "Morph";
-import { PhysicsImpostor } from "Physics";
+import { Quaternion, Matrix, Vector3, Vector2, Color3, Color4, Plane, Vector4, Path3D } from "Math/math";
+import { Engine } from "Engine/engine";
+import { Node } from "node";
+
+import { VertexBuffer } from "./vertexBuffer";
+import { VertexData, IGetSetVerticesData } from "./mesh.vertexData";
+import { Buffer } from "./buffer";
+import { Geometry } from "./geometry";
+import { AbstractMesh } from "./abstractMesh";
+import { SubMesh } from "./subMesh";
+import { InstancedMesh } from "./instancedMesh";
+import { LinesMesh } from "./linesMesh";
+import { GroundMesh } from "./groundMesh";
+import { MeshBuilder } from "./meshBuilder";
+import { MeshLODLevel } from "./meshLODLevel";
+
+import { BoundingInfo } from "Culling/boundingInfo";
+import { BoundingSphere } from "Culling/boundingSphere";
+import { Effect } from "Materials/effect";
+import { Material } from "Materials/material";
+import { Animation } from "Animations/animation";
+import { SceneLoader } from "Loading/sceneLoader";
+import { Skeleton } from "Bones/skeleton";
+import { MorphTargetManager } from "Morph/morphTargetManager";
+import { PhysicsImpostor } from "Physics/physicsImpostor";
     /**
      * @hidden
      **/

src/Mesh/mesh.vertexData.ts

@@ -1,6 +1,8 @@
 import { Nullable, FloatArray, IndicesArray } from "types";
-import { Matrix, Vector3, Vector2, Color3, Color4, Vector4, Axis, Epsilon } from "Math";
-import { Mesh, Geometry, VertexBuffer } from "Mesh";
+import { Matrix, Vector3, Vector2, Color3, Color4, Vector4, Axis, Epsilon } from "Math/math";
+import { VertexBuffer } from "Mesh/vertexBuffer";
+import { Geometry } from "Mesh/geometry";
+import { Mesh } from "Mesh/mesh";
     /**
      * Define an interface for all classes that will get and set the data on vertices
      */

src/Mesh/meshBuilder.ts

@@ -1,10 +1,16 @@
-import { Tools } from "Tools";
+import { Tools } from "Tools/tools";
 import { Nullable, FloatArray, IndicesArray } from "types";
-import { Camera } from "Cameras";
+import { Camera } from "Cameras/camera";
 import { Scene } from "scene";
-import { Matrix, Vector3, Vector2, Color3, Color4, Plane, Tmp, Epsilon, Vector4, Axis, Path3D, PositionNormalVertex } from "Math";
-import { Mesh, AbstractMesh, VertexBuffer, LinesMesh, VertexData, _CreationDataStorage, GroundMesh, PolygonMeshBuilder } from "Mesh";
-import { BoundingInfo } from "Culling";
+import { Matrix, Vector3, Vector2, Color3, Color4, Plane, Tmp, Epsilon, Vector4, Axis, Path3D, PositionNormalVertex } from "Math/math";
+import { Mesh, _CreationDataStorage } from "./mesh";
+import { AbstractMesh } from "./abstractMesh";
+import { VertexBuffer } from "./VertexBuffer";
+import { LinesMesh } from "./linesMesh";
+import { VertexData } from "./mesh.vertexData";
+import { GroundMesh } from "./groundMesh";
+import { PolygonMeshBuilder } from "./polygonMesh";
+import { BoundingInfo } from "Culling/boundingInfo";
 
     /**
      * Class containing static functions to help procedurally build meshes

src/Mesh/meshLODLevel.ts

@@ -1,5 +1,5 @@
 import { Nullable } from "types";
-import { Mesh } from "Mesh";
+import { Mesh } from "Mesh/mesh";
     /**
      * Class used to represent a specific level of detail of a mesh
      * @see http://doc.babylonjs.com/how_to/how_to_use_lod

src/Mesh/meshSimplification.ts

@@ -1,7 +1,9 @@
 import { IndicesArray } from "types";
-import { Vector3, Epsilon } from "Math";
-import { Mesh, VertexBuffer, SubMesh } from "Mesh";
-import { AsyncLoop } from "index";
+import { Vector3, Epsilon } from "Math/math";
+import { VertexBuffer } from "Mesh/vertexBuffer";
+import { SubMesh } from "Mesh/subMesh";
+import { Mesh } from "Mesh/mesh";
+import { AsyncLoop } from "Tools/tools";
     /**
      * A simplifier interface for future simplification implementations
      * @see http://doc.babylonjs.com/how_to/in-browser_mesh_simplification

src/Mesh/meshSimplificationSceneComponent.ts

@@ -1,5 +1,6 @@
 import { Scene } from "scene";
-import { Mesh, SimplificationQueue, ISimplificationSettings, SimplificationType } from "Mesh";
+import { Mesh } from "./mesh";
+import { SimplificationQueue, ISimplificationSettings, SimplificationType } from "./meshSimplification";
 import { SceneComponentConstants, ISceneComponent } from "sceneComponent";
 
 declare module "scene" {

src/Mesh/polygonMesh.ts

@@ -1,7 +1,9 @@
-import { Tools } from "Tools";
+import { Tools } from "Tools/tools";
 import { Scene } from "scene";
-import { Vector3, Vector2, Path2 } from "Math";
-import { Mesh, VertexBuffer } from "Mesh";
+import { Vector3, Vector2, Path2 } from "Math/math";
+import { VertexBuffer } from "Mesh/vertexBuffer";
+import { Mesh } from "Mesh/mesh";
+
     declare var earcut: any;
     /**
      * Vector2 wth index property

src/Mesh/subMesh.ts

@@ -1,11 +1,18 @@
-import { Tools } from "Tools";
+import { Tools } from "Tools/tools";
 import { Nullable, IndicesArray } from "types";
-import { Matrix, Vector3, Plane } from "Math";
-import { Engine } from "Engine";
-import { Mesh, AbstractMesh, VertexBuffer, LinesMesh } from "Mesh";
-import { Collider, IntersectionInfo } from "Collisions";
-import { Ray, ICullable, BoundingInfo } from "Culling";
-import { Material, Effect, MaterialDefines, MultiMaterial } from "Materials";
+import { Matrix, Vector3, Plane } from "Math/math";
+import { Engine } from "Engine/engine";
+import { Mesh } from "./mesh";
+import { AbstractMesh } from "./abstractMesh";
+import { LinesMesh } from "./linesMesh";
+import { VertexBuffer } from "./vertexBuffer";
+import { Collider } from "Collisions/collider";
+import { IntersectionInfo } from "Collisions/pickingInfo";
+import { Ray } from "Culling/ray";
+import { ICullable, BoundingInfo } from "Culling/boundingInfo";
+import { Effect } from "Materials/effect";
+import { Material, MaterialDefines } from "Materials/material";
+import { MultiMaterial } from "Materials/multiMaterial";
     /**
      * Base class for submeshes
      */

src/Mesh/vertexBuffer.ts

@@ -1,5 +1,5 @@
 import { Nullable, DataArray } from "types";
-import { Buffer } from ".";
+import { Buffer } from "./buffer";
     /**
      * Specialized buffer used to store vertex data
      */

src/Morph/morphTarget.ts

@@ -1,9 +1,12 @@
-import { Observable, IAnimatable } from "Tools";
+import { IAnimatable } from "Tools/tools";
+import { Observable } from "Tools/observable";
 import { Nullable, FloatArray } from "types";
 import { Scene } from "scene";
-import { Engine } from "Engine";
-import { AbstractMesh, VertexBuffer } from "Mesh";
-import { Animation, AnimationPropertiesOverride } from "Animations";
+import { Engine } from "Engine/engine";
+import { AbstractMesh } from "Mesh/abstractMesh";
+import { VertexBuffer } from "Mesh/vertexBuffer";
+import { Animation } from "Animations/animation";
+import { AnimationPropertiesOverride } from "Animations/animationPropertiesOverride";
     /**
      * Defines a target to use with MorphTargetManager
      * @see http://doc.babylonjs.com/how_to/how_to_use_morphtargets

src/Morph/morphTargetManager.ts

@@ -1,9 +1,11 @@
-import { Observer, Tools, SmartArray } from "Tools";
+import { Observer } from "Tools/observable";
+import { SmartArray } from "Tools/smartArray";
+import { Tools } from "Tools/tools";
 import { Nullable } from "types";
 import { Scene } from "scene";
-import { Engine } from "Engine";
-import { Mesh } from "Mesh";
-import { MorphTarget } from "Morph";
+import { Engine } from "Engine/engine";
+import { Mesh } from "Mesh/mesh";
+import { MorphTarget } from "./morphTarget";
     /**
      * This class is used to deform meshes using morphing between different targets
      * @see http://doc.babylonjs.com/how_to/how_to_use_morphtargets

src/Offline/database.ts

@@ -1,7 +1,7 @@
-import { Tools } from "Tools";
+import { Tools } from "Tools/tools";
 import { Nullable } from "types";
-import { Engine } from "Engine";
-import { IOfflineProvider } from "Offline";
+import { Engine } from "Engine/engine";
+import { IOfflineProvider } from "./IOfflineProvider";
     // Sets the default offline provider to Babylon.js
     Engine.OfflineProviderFactory = (urlToScene: string, callbackManifestChecked: (checked: boolean) => any, disableManifestCheck = false) => { return new Database(urlToScene, callbackManifestChecked, disableManifestCheck); };
 

src/Particles/EmitterTypes/IParticleEmitterType.ts

@@ -1,6 +1,6 @@
-import { Vector3, Matrix } from "Math";
-import { Effect } from "Materials";
-import { IParticleEmitterType, Particle } from "Particles";
+import { Vector3, Matrix } from "Math/math";
+import { Effect } from "Materials/effect";
+import { Particle } from "Particles/particle";
     /**
      * Particle emitter represents a volume emitting particles.
      * This is the responsibility of the implementation to define the volume shape like cone/sphere/box.

src/Particles/EmitterTypes/boxParticleEmitter.ts

@@ -1,7 +1,9 @@
-import { Tools } from "Tools";
-import { Vector3, Matrix, Scalar } from "Math";
-import { Effect } from "Materials";
-import { IParticleEmitterType, Particle } from "Particles";
+import { Tools } from "Tools/tools";
+import { Vector3, Matrix } from "Math/math";
+import { Scalar } from "Math/math.scalar";
+import { Effect } from "Materials/effect";
+import { Particle } from "Particles/particle";
+import { IParticleEmitterType } from "./IParticleEmitterType";
     /**
      * Particle emitter emitting particles from the inside of a box.
      * It emits the particles randomly between 2 given directions.

src/Particles/EmitterTypes/coneParticleEmitter.ts

@@ -1,7 +1,9 @@
-import { Tools } from "Tools";
-import { Vector3, Matrix, Scalar } from "Math";
-import { Effect } from "Materials";
-import { IParticleEmitterType, Particle } from "Particles";
+import { Tools } from "Tools/tools";
+import { Vector3, Matrix } from "Math/math";
+import { Scalar } from "Math/math.scalar";
+import { Effect } from "Materials/effect";
+import { Particle } from "Particles/particle";
+import { IParticleEmitterType } from "./IParticleEmitterType";
     /**
      * Particle emitter emitting particles from the inside of a cone.
      * It emits the particles alongside the cone volume from the base to the particle.

src/Particles/EmitterTypes/cylinderParticleEmitter.ts

@@ -1,7 +1,9 @@
-import { Tools } from "Tools";
-import { Vector3, Matrix, Scalar } from "Math";
-import { Effect } from "Materials";
-import { IParticleEmitterType, Particle } from "Particles";
+import { Tools } from "Tools/tools";
+import { Vector3, Matrix } from "Math/math";
+import { Scalar } from "Math/math.scalar";
+import { Effect } from "Materials/effect";
+import { Particle } from "Particles/particle";
+import { IParticleEmitterType } from "./IParticleEmitterType";
     /**
      * 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,7 +1,9 @@
-import { Tools } from "Tools";
-import { Vector3, Matrix, Scalar } from "Math";
-import { Effect } from "Materials";
-import { IParticleEmitterType, Particle } from "Particles";
+import { Tools } from "Tools/tools";
+import { Vector3, Matrix } from "Math/math";
+import { Scalar } from "Math/math.scalar";
+import { Effect } from "Materials/effect";
+import { Particle } from "Particles/particle";
+import { IParticleEmitterType } from "./IParticleEmitterType";
     /**
      * 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,7 +1,9 @@
-import { Tools } from "Tools";
-import { Vector3, Matrix, Scalar } from "Math";
-import { Effect } from "Materials";
-import { IParticleEmitterType, Particle } from "Particles";
+import { Tools } from "Tools/tools";
+import { Vector3, Matrix } from "Math/math";
+import { Scalar } from "Math/math.scalar";
+import { Effect } from "Materials/effect";
+import { Particle } from "Particles/particle";
+import { IParticleEmitterType } from "./IParticleEmitterType";
     /**
      * Particle emitter emitting particles from a point.
      * It emits the particles randomly between 2 given directions.

src/Particles/EmitterTypes/sphereParticleEmitter.ts

@@ -1,7 +1,9 @@
-import { Tools } from "Tools";
-import { Vector3, Matrix, Scalar } from "Math";
-import { Effect } from "Materials";
-import { IParticleEmitterType, Particle } from "Particles";
+import { Tools } from "Tools/tools";
+import { Vector3, Matrix } from "Math/math";
+import { Scalar } from "Math/math.scalar";
+import { Effect } from "Materials/effect";
+import { Particle } from "Particles/particle";
+import { IParticleEmitterType } from "./IParticleEmitterType";
     /**
      * 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,12 +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 { Color4, Color3, Vector2, Vector3 } from "Math/math";
+import { AbstractMesh } from "Mesh/abstractMesh";
+import { BaseTexture } from "Materials/Textures/baseTexture";
+import { Texture } from "Materials/Textures/texture";
+import { BoxParticleEmitter, IParticleEmitterType, PointParticleEmitter, HemisphericParticleEmitter, SphereParticleEmitter, SphereDirectedParticleEmitter, CylinderParticleEmitter, ConeParticleEmitter } from "Particles/EmitterTypes";
 import { Scene } from "scene";
-import { ColorGradient, FactorGradient, Color3Gradient } from "Tools";
-import { Animation } from "Animations";
+import { ColorGradient, FactorGradient, Color3Gradient } from "Tools/tools";
+import { Animation } from "Animations/animation";
 
     /**
      * Interface representing a particle system in Babylon.js.

src/Particles/baseParticleSystem.ts

@@ -1,11 +1,15 @@
 import { Nullable } from "types";
-import { Color4, Vector2, Vector3 } from "Math";
-import { AbstractMesh } from "Mesh";
-import { ImageProcessingConfiguration, Texture, ProceduralTexture, ImageProcessingConfigurationDefines, RawTexture } from "Materials";
+import { Color4, Vector2, Vector3 } from "Math/math";
+import { AbstractMesh } from "Mesh/abstractMesh";
+import { ImageProcessingConfiguration, ImageProcessingConfigurationDefines } from "Materials/imageProcessingConfiguration";
+import { Texture } from "Materials/Textures/texture";
+import { ProceduralTexture } from "Materials/Textures/Procedurals/proceduralTexture";
+import { RawTexture } from "Materials/Textures/rawTexture";
 import { Scene } from "scene";
-import { ColorGradient, FactorGradient, Color3Gradient, IValueGradient } from "Tools";
-import { BoxParticleEmitter, IParticleEmitterType, ParticleSystem, PointParticleEmitter, HemisphericParticleEmitter, SphereParticleEmitter, SphereDirectedParticleEmitter, CylinderParticleEmitter, CylinderDirectedParticleEmitter, ConeParticleEmitter } from "Particles";
-import { Animation } from "Animations";
+import { ColorGradient, FactorGradient, Color3Gradient, IValueGradient } from "Tools/tools";
+import { Animation } from "Animations/animation";
+import { BoxParticleEmitter, IParticleEmitterType, PointParticleEmitter, HemisphericParticleEmitter, SphereParticleEmitter, SphereDirectedParticleEmitter, CylinderParticleEmitter, CylinderDirectedParticleEmitter, ConeParticleEmitter } from "Particles/EmitterTypes";
+import { ParticleSystem } from "./particleSystem";
 
     /**
      * This represents the base class for particle system in Babylon.

src/Particles/gpuParticleSystem.ts

@@ -1,12 +1,23 @@
 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, Buffer } 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 { IAnimatable, Tools, IValueGradient, ColorGradient, FactorGradient, Color3Gradient } from "Tools/tools";
+import { Observable } from "Tools/observable";
+import { Color4, Color3, Vector3, Matrix, Tmp } from "Math/math";
+import { Scalar } from "Math/math.scalar";
+import { VertexBuffer } from "Mesh/vertexBuffer";
+import { Buffer } from "Mesh/buffer";
+import { AbstractMesh } from "Mesh/abstractMesh";
+import { IParticleSystem } from "./IParticleSystem";
+import { BaseParticleSystem } from "./baseParticleSystem";
+import { ParticleSystem } from "./particleSystem";
+import { Engine } from "Engine/engine";
+import { BoxParticleEmitter } from "Particles/EmitterTypes/boxParticleEmitter";
 import { Scene, IDisposable } from "scene";
+import { Effect, EffectCreationOptions } from "Materials/effect";
+import { Material } from "Materials/material";
+import { MaterialHelper } from "Materials/MaterialHelper";
+import { ImageProcessingConfiguration } from "Materials/imageProcessingConfiguration";
+import { Texture } from "Materials/Textures/texture";
+import { RawTexture } from "Materials/Textures/rawTexture";
 
     /**
      * This represents a GPU particle system in Babylon

src/Particles/particle.ts

@@ -1,8 +1,10 @@
 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";
+import { Color4, Vector2, Vector3, Tmp, Vector4 } from "Math/math";
+import { Scalar } from "Math/math.scalar";
+import { AbstractMesh } from "Mesh/abstractMesh";
+import { ParticleSystem } from "./particleSystem";
+import { SubEmitter } from "./subEmitter";
+import { ColorGradient, FactorGradient } from "Tools/tools";
     /**
      * A particle represents one of the element emitted by a particle system.
      * This is mainly define by its coordinates, direction, velocity and age.

src/Particles/particleHelper.ts

@@ -1,12 +1,14 @@
 import { Nullable } from "types";
-import { Tools } from "Tools";
-import { Vector3, Color4 } 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";
+import { Tools } from "Tools/tools";
+import { Vector3, Color4 } from "Math/math";
+import { AbstractMesh } from "Mesh/abstractMesh";
+import { Texture } from "Materials/Textures/texture";
+import { Engine } from "Engine/engine";
+import { IParticleSystem } from "./IParticleSystem";
+import { GPUParticleSystem } from "./gpuParticleSystem";
+import { ParticleSystemSet } from "./particleSystemSet";
+import { ParticleSystem } from "./particleSystem";
     /**
      * This class is made for on one-liner static method to help creating particle system set.
      */

src/Particles/particleSystem.ts

@@ -1,12 +1,27 @@
 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, Buffer } 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 { IAnimatable, Tools, FactorGradient, ColorGradient, Color3Gradient } from "Tools/tools";
+import { Observable, Observer } from "Tools/observable";
+import { Color4, Color3, Vector3, Matrix, Tmp, ISize, Vector4 } from "Math/math";
+import { Scalar } from "Math/math.scalar";
+import { VertexBuffer } from "Mesh/vertexBuffer";
+import { Buffer } from "Mesh/buffer";
+import { AbstractMesh } from "Mesh/abstractMesh";
+import { Material } from "Materials/material";
+import { MaterialHelper } from "Materials/materialHelper";
+import { Effect } from "Materials/effect";
+import { ImageProcessingConfiguration } from "Materials/imageProcessingConfiguration";
+import { Texture } from "Materials/Textures/texture";
+import { RawTexture } from "Materials/Textures/rawTexture";
+import { ProceduralTexture } from "Materials/Textures/Procedurals/proceduralTexture";
+import { Engine } from "Engine/engine";
 import { Scene, IDisposable } from "scene";
-import { Animation } from "Animations";
+import { Animation } from "Animations/animation";
+import { BoxParticleEmitter, IParticleEmitterType, HemisphericParticleEmitter, SphereParticleEmitter, SphereDirectedParticleEmitter, CylinderParticleEmitter, ConeParticleEmitter } from "Particles/EmitterTypes";
+import { IParticleSystem } from "./IParticleSystem";
+import { BaseParticleSystem } from "./baseParticleSystem";
+import { Particle } from "./particle";
+import { SubEmitter, SubEmitterType } from "./subEmitter";
+
     /**
      * 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.

src/Particles/particleSystemComponent.ts

@@ -1,12 +1,13 @@
-import { Mesh } from "Mesh";
-import { IParticleSystem, GPUParticleSystem } from "Particles";
+import { Mesh } from "Mesh/mesh";
+import { IParticleSystem } from "./IParticleSystem";
+import { GPUParticleSystem } from "./gpuParticleSystem";
 import { AbstractScene } from "abstractScene";
-import { Effect, EffectFallbacks } from "Materials";
-import { Engine } from "Engine";
-import { ParticleSystem } from "Particles";
+import { Effect, EffectFallbacks } from "Materials/effect";
+import { Engine } from "Engine/engine";
+import { ParticleSystem } from "./particleSystem";
 import { Scene } from "scene";
 import { SceneComponentConstants } from "sceneComponent";
-import { AssetContainer } from "index";
+import { AssetContainer } from "assetContainer";
     // Adds the parsers to the scene parsers.
     AbstractScene.AddParser(SceneComponentConstants.NAME_PARTICLESYSTEM, (parsedData: any, scene: Scene, container: AssetContainer, rootUrl: string) => {
 

src/Particles/particleSystemSet.ts

@@ -1,11 +1,15 @@
 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 { Color3 } from "Math/math";
+import { TransformNode } from "Mesh/transformNode";
+import { AbstractMesh } from "Mesh/abstractMesh";
+import { MeshBuilder } from "Mesh/meshBuilder";
+import { IParticleSystem } from "./IParticleSystem";
+import { ParticleHelper } from "./particleHelper";
+import { GPUParticleSystem } from "./gpuParticleSystem";
+import { Engine } from "Engine/engine";
+import { ParticleSystem } from "Particles/particleSystem";
 import { Scene, IDisposable } from "scene";
-import { StandardMaterial } from "Materials";
+import { StandardMaterial } from "Materials/standardMaterial";
     /** Internal class used to store shapes for emitters */
     class ParticleSystemSetEmitterCreationOptions {
         public kind: string;

src/Particles/solidParticle.ts

@@ -1,8 +1,9 @@
 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";
+import { Color4, Vector3, Matrix, Tmp, Quaternion, Vector4 } from "Math/math";
+import { Mesh } from "Mesh/mesh";
+import { BoundingInfo } from "Culling/boundingInfo";
+import { BoundingSphere } from "Culling/boundingSphere";
+import { SolidParticleSystem } from "./solidParticleSystem";
     /**
      * Represents one particle of a solid particle system.
      */

src/Particles/solidParticleSystem.ts

@@ -1,11 +1,14 @@
 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 { Color4, Vector3, Matrix, Tmp, Quaternion, Axis } from "Math/math";
+import { VertexBuffer } from "Mesh/vertexBuffer";
+import { VertexData } from "Mesh/mesh.vertexData";
+import { Mesh } from "Mesh/mesh";
+import { MeshBuilder } from "Mesh/meshBuilder";
+import { Engine } from "Engine/engine";
 import { Scene, IDisposable } from "scene";
-import { DepthSortedParticle, SolidParticle, ModelShape } from "Particles";
-import { TargetCamera } from "Cameras";
-import { BoundingInfo } from "Culling";
+import { DepthSortedParticle, SolidParticle, ModelShape } from "./solidParticle";
+import { TargetCamera } from "Cameras/targetCamera";
+import { BoundingInfo } from "Culling/boundingInfo";
     const depthSortFunction = (p1: DepthSortedParticle, p2: DepthSortedParticle) => p2.sqDistance - p1.sqDistance;
 
     /**

src/Particles/subEmitter.ts

@@ -1,6 +1,7 @@
-import { Vector3 } from "Math";
-import { Mesh, AbstractMesh } from "Mesh";
-import { ParticleSystem } from "Particles";
+import { Vector3 } from "Math/math";
+import { AbstractMesh } from "Mesh/abstractMesh";
+import { Mesh } from "Mesh/mesh";
+import { ParticleSystem } from "Particles/particleSystem";
 import { Scene } from "scene";
     /**
      * Type of sub emitter

src/Physics/IPhysicsEngine.ts

@@ -1,7 +1,8 @@
 import { Nullable } from "types";
-import { Vector3, Quaternion } from "Math";
-import { AbstractMesh } from "Mesh";
-import { PhysicsImpostor, PhysicsJoint, IMotorEnabledJoint, IPhysicsEnabledObject } from "Physics";
+import { Vector3, Quaternion } from "Math/math";
+import { AbstractMesh } from "Mesh/abstractMesh";
+import { PhysicsImpostor, IPhysicsEnabledObject } from "./physicsImpostor";
+import { PhysicsJoint, IMotorEnabledJoint } from "./physicsJoint";
     /**
      * Interface used to describe a physics joint
      */
@@ -157,4 +158,3 @@ import { PhysicsImpostor, PhysicsJoint, IMotorEnabledJoint, IPhysicsEnabledObjec
          */
         _step(delta: number): void;
     }
-

src/Physics/Plugins/cannonJSPlugin.ts

@@ -1,8 +1,10 @@
 import { Nullable, FloatArray } from "types";
-import { Tools } from "Tools";
-import { Vector3, Matrix, Quaternion } from "Math";
-import { AbstractMesh, VertexBuffer } from "Mesh";
+import { Tools } from "Tools/tools";
+import { Vector3, Matrix, Quaternion } from "Math/math";
+import { VertexBuffer } from "Mesh/vertexBuffer";
+import { AbstractMesh } from "Mesh/abstractMesh";
 import { IPhysicsEnginePlugin, PhysicsImpostor, PhysicsImpostorJoint, PhysicsJoint, DistanceJointData, SpringJointData, PhysicsEngine, IPhysicsEnabledObject, IMotorEnabledJoint } from "Physics";
+
     //declare var require: any;
     declare var CANNON: any;
 

src/Physics/Plugins/oimoJSPlugin.ts

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

src/Physics/physicsEngine.ts

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

src/Physics/physicsEngineComponent.ts

@@ -1,12 +1,18 @@
 import { Nullable } from "types";
-import { Observable, Observer, Tools } from "Tools";
+import { Tools } from "Tools/tools";
+import { Observable, Observer } from "Tools/observable";
 import { Vector3 } from "Math";
-import { Mesh, AbstractMesh } from "Mesh";
+import { Mesh } from "Mesh/mesh";
+import { AbstractMesh } from "Mesh/abstractMesh";
 import { ISceneComponent, SceneComponentConstants } from "sceneComponent";
-import { IPhysicsEngine, IPhysicsEnginePlugin, PhysicsEngine, PhysicsImpostor, PhysicsJoint } from "Physics";
 import { Scene } from "scene";
 import { Node } from "node";
 
+import { IPhysicsEngine, IPhysicsEnginePlugin } from "./IPhysicsEngine";
+import { PhysicsEngine } from "./physicsEngine";
+import { PhysicsImpostor } from "./physicsImpostor";
+import { PhysicsJoint } from "./physicsJoint";
+
 declare module "scene" {
     export interface Scene {
         /** @hidden (Backing field) */

src/Physics/physicsHelper.ts

@@ -1,10 +1,14 @@
 import { Nullable } from "types";
-import { Tools } from "Tools";
-import { Vector3 } from "Math";
-import { Mesh, AbstractMesh, MeshBuilder } from "Mesh";
-import { Ray } from "Culling";
+import { Tools } from "Tools/tools";
+import { Vector3 } from "Math/math";
+import { AbstractMesh } from "Mesh/abstractMesh";
+import { Mesh } from "Mesh/mesh";
+import { MeshBuilder } from "Mesh/meshBuilder";
+import { Ray } from "Culling/ray";
 import { Scene } from "scene";
-import { IPhysicsEngine, PhysicsImpostor, PhysicsEngine } from "Physics";
+import { IPhysicsEngine } from "./IPhysicsEngine";
+import { PhysicsEngine } from "./physicsEngine";
+import { PhysicsImpostor } from "./physicsImpostor";
     /**
      * A helper for physics simulations
      * @see https://doc.babylonjs.com/how_to/using_the_physics_engine
@@ -769,4 +773,3 @@ import { IPhysicsEngine, PhysicsImpostor, PhysicsEngine } from "Physics";
          */
         cylinder: Mesh;
     }
-

src/Physics/physicsImpostor.ts

@@ -1,11 +1,13 @@
 import { Nullable, IndicesArray } from "types";
-import { Tools } from "Tools";
-import { Vector3, Matrix, Quaternion, Space } from "Math";
-import { TransformNode, AbstractMesh } from "Mesh";
+import { Tools } from "Tools/tools";
+import { Vector3, Matrix, Quaternion, Space } from "Math/math";
+import { TransformNode } from "Mesh/transformNode";
+import { AbstractMesh } from "Mesh/abstractMesh";
 import { Scene } from "scene";
-import { Bone } from "Bones";
-import { BoundingInfo } from "Culling";
-import { IPhysicsEngine, PhysicsJoint, PhysicsJointData } from "Physics";
+import { Bone } from "Bones/bone";
+import { BoundingInfo } from "Culling/boundingInfo";
+import { IPhysicsEngine } from "./IPhysicsEngine";
+import { PhysicsJoint, PhysicsJointData } from "./physicsJoint";
     /**
      * The interface for the physics imposter parameters
      * @see https://doc.babylonjs.com/how_to/using_the_physics_engine

src/Physics/physicsJoint.ts

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

src/Probes/reflectionProbe.ts

@@ -1,9 +1,9 @@
-import { RenderTargetTexture } from "Materials";
-import { Matrix, Vector3 } from "Math";
-import { AbstractMesh } from "Mesh";
+import { RenderTargetTexture } from "Materials/Textures/renderTargetTexture";
+import { Matrix, Vector3 } from "Math/math";
+import { AbstractMesh } from "Mesh/abstractMesh";
 import { Nullable } from "types";
 import { Scene } from "scene";
-import { Engine } from "Engine";
+import { Engine } from "Engine/engine";
 
 declare module "scene" {
     export interface Scene {