Introducing babylon.core.js

Tools/Gulp/config.json

@@ -3,9 +3,10 @@
     "filename": "babylon.max.js",
     "minFilename": "babylon.js",
     "minNoWorkerFilename": "babylon.noworker.js",
+    "minCoreFilename": "babylon.core.js",
     "declarationFilename": "babylon.d.ts",
     "outputDirectory": "../../dist/",
-	"srcOutputDirectory": "../../src/"
+    "srcOutputDirectory": "../../src/"
   },
   "core": {
     "typescript": [
@@ -17,7 +18,6 @@
       "../../src/Math/babylon.math.js",
       "../../src/Tools/babylon.database.js",
       "../../src/Tools/babylon.tools.tga.js",
-      "../../src/Tools/babylon.tools.dds.js",
       "../../src/Tools/babylon.smartArray.js",
       "../../src/Tools/babylon.smartCollection.js",
       "../../src/Tools/babylon.tools.js",
@@ -43,9 +43,6 @@
       "../../src/Cameras/babylon.followCamera.js",
       "../../src/Cameras/babylon.touchCamera.js",
       "../../src/Cameras/babylon.arcRotateCamera.js",
-      "../../src/Cameras/babylon.deviceOrientationCamera.js",
-      "../../src/Tools/babylon.gamepads.js",
-      "../../src/Cameras/babylon.gamepadCamera.js",
       "../../src/Rendering/babylon.renderingManager.js",
       "../../src/Rendering/babylon.renderingGroup.js",
       "../../src/babylon.scene.js",
@@ -75,46 +72,22 @@
       "../../src/Layer/babylon.layer.js",
       "../../src/Particles/babylon.particle.js",
       "../../src/Particles/babylon.particleSystem.js",
-      "../../src/Particles/babylon.solidParticle.js",
-      "../../src/Particles/babylon.solidParticleSystem.js",
       "../../src/Animations/babylon.animation.js",
       "../../src/Animations/babylon.animatable.js",
       "../../src/Animations/babylon.easing.js",
-      "../../src/Culling/Octrees/babylon.octree.js",
-      "../../src/Culling/Octrees/babylon.octreeBlock.js",
       "../../src/Bones/babylon.bone.js",
       "../../src/Bones/babylon.skeleton.js",
-      "../../src/Bones/babylon.skeleton.js",
       "../../src/PostProcess/babylon.postProcess.js",
       "../../src/PostProcess/babylon.postProcessManager.js",
       "../../src/PostProcess/babylon.passPostProcess.js",
-      "../../src/PostProcess/babylon.blurPostProcess.js",
-      "../../src/PostProcess/babylon.refractionPostProcess.js",
-      "../../src/PostProcess/babylon.blackAndWhitePostProcess.js",
-      "../../src/PostProcess/babylon.convolutionPostProcess.js",
-      "../../src/PostProcess/babylon.filterPostProcess.js",
-      "../../src/PostProcess/babylon.fxaaPostProcess.js",
-      "../../src/PostProcess/babylon.stereoscopicInterlacePostProcess.js",
-      "../../src/LensFlare/babylon.lensFlare.js",
-      "../../src/LensFlare/babylon.lensFlareSystem.js",
-      "../../src/Physics/Plugins/babylon.cannonJSPlugin.js",
-      "../../src/Physics/Plugins/babylon.oimoJSPlugin.js",
       "../../src/Physics/babylon.physicsEngine.js",
-      "../../src/Tools/babylon.sceneSerializer.js",
-      "../../src/Mesh/babylon.csg.js",
-      "../../src/PostProcess/babylon.vrDistortionCorrectionPostProcess.js",
-      "../../src/Tools/babylon.virtualJoystick.js",
-      "../../src/Cameras/babylon.virtualJoysticksCamera.js",
-      "../../src/Materials/babylon.shaderMaterial.js",
       "../../src/Mesh/babylon.mesh.vertexData.js",
-      "../../src/PostProcess/babylon.anaglyphPostProcess.js",
       "../../src/Tools/babylon.tags.js",
       "../../src/Tools/babylon.andOrNotEvaluator.js",
       "../../src/PostProcess/RenderPipeline/babylon.postProcessRenderPass.js",
       "../../src/PostProcess/RenderPipeline/babylon.postProcessRenderEffect.js",
       "../../src/PostProcess/RenderPipeline/babylon.postProcessRenderPipeline.js",
       "../../src/PostProcess/RenderPipeline/babylon.postProcessRenderPipelineManager.js",
-      "../../src/PostProcess/babylon.displayPassPostProcess.js",
       "../../src/Rendering/babylon.boundingBoxRenderer.js",
       "../../src/Actions/babylon.condition.js",
       "../../src/Actions/babylon.action.js",
@@ -125,32 +98,11 @@
       "../../src/Mesh/babylon.groundMesh.js",
       "../../src/Mesh/babylon.instancedMesh.js",
       "../../src/Mesh/babylon.linesMesh.js",
-      "../../src/Rendering/babylon.outlineRenderer.js",
-      "../../src/Tools/babylon.assetsManager.js",
-      "../../src/Cameras/VR/babylon.vrDeviceOrientationCamera.js",
-      "../../src/Cameras/VR/babylon.webVRCamera.js",
-      "../../src/Tools/babylon.sceneOptimizer.js",
-      "../../src/Mesh/babylon.meshLODLevel.js",
+      "../../src/Debug/babylon.debugLayer.js",
+      "../../src/Tools/babylon.loadingScreen.js",
       "../../src/Audio/babylon.audioEngine.js",
       "../../src/Audio/babylon.sound.js",
-      "../../src/Audio/babylon.soundtrack.js",
-      "../../src/Debug/babylon.debugLayer.js",
-      "../../src/Materials/Textures/babylon.rawTexture.js",
-      "../../src/Mesh/babylon.polygonMesh.js",
-      "../../src/Mesh/babylon.meshSimplification.js",
-      "../../src/Audio/babylon.analyser.js",
-      "../../src/Rendering/babylon.depthRenderer.js",
-      "../../src/PostProcess/babylon.ssaoRenderingPipeline.js",
-      "../../src/PostProcess/babylon.volumetricLightScatteringPostProcess.js",
-      "../../src/PostProcess/babylon.lensRenderingPipeline.js",
-      "../../src/PostProcess/babylon.colorCorrectionPostProcess.js",
-      "../../src/Cameras/babylon.stereoscopicCameras.js",
-      "../../src/PostProcess/babylon.hdrRenderingPipeline.js",
-      "../../src/Rendering/babylon.edgesRenderer.js",
-      "../../src/PostProcess/babylon.tonemapPostProcess.js",
-	    "../../src/Tools/babylon.loadingScreen.js",
-      "../../src/Materials/babylon.pbrMaterial.js",
-      "../../src/Probes/babylon.reflectionProbe.js"
+      "../../src/Audio/babylon.soundtrack.js"
     ]
   },
   "shadersDirectories": [
@@ -171,7 +123,55 @@
     }
   ],
   "extras": {
-    "files": [
+    "files": [      
+      "../../src/Materials/babylon.shaderMaterial.js",
+      "../../src/Tools/babylon.tools.dds.js",
+      "../../src/Physics/Plugins/babylon.cannonJSPlugin.js",
+      "../../src/Physics/Plugins/babylon.oimoJSPlugin.js",
+      "../../src/PostProcess/babylon.displayPassPostProcess.js",
+      "../../src/Mesh/babylon.meshSimplification.js",
+      "../../src/Tools/babylon.sceneSerializer.js",
+      "../../src/Mesh/babylon.csg.js",
+      "../../src/PostProcess/babylon.vrDistortionCorrectionPostProcess.js",
+      "../../src/Tools/babylon.virtualJoystick.js",
+      "../../src/Cameras/babylon.virtualJoysticksCamera.js",
+      "../../src/PostProcess/babylon.anaglyphPostProcess.js",
+      "../../src/Rendering/babylon.outlineRenderer.js",
+      "../../src/Tools/babylon.assetsManager.js",
+      "../../src/Cameras/VR/babylon.vrDeviceOrientationCamera.js",
+      "../../src/Cameras/VR/babylon.webVRCamera.js",
+      "../../src/Tools/babylon.sceneOptimizer.js",
+      "../../src/Mesh/babylon.meshLODLevel.js",
+      "../../src/Materials/Textures/babylon.rawTexture.js",
+      "../../src/Mesh/babylon.polygonMesh.js",
+      "../../src/Culling/Octrees/babylon.octree.js",
+      "../../src/Culling/Octrees/babylon.octreeBlock.js",
+      "../../src/PostProcess/babylon.blurPostProcess.js",
+      "../../src/PostProcess/babylon.refractionPostProcess.js",
+      "../../src/PostProcess/babylon.blackAndWhitePostProcess.js",
+      "../../src/PostProcess/babylon.convolutionPostProcess.js",
+      "../../src/PostProcess/babylon.filterPostProcess.js",
+      "../../src/PostProcess/babylon.fxaaPostProcess.js",
+      "../../src/PostProcess/babylon.stereoscopicInterlacePostProcess.js",
+      "../../src/LensFlare/babylon.lensFlare.js",
+      "../../src/LensFlare/babylon.lensFlareSystem.js",
+      "../../src/Cameras/babylon.deviceOrientationCamera.js",
+      "../../src/Tools/babylon.gamepads.js",
+      "../../src/Cameras/babylon.gamepadCamera.js",
+      "../../src/Audio/babylon.analyser.js",
+      "../../src/Rendering/babylon.depthRenderer.js",
+      "../../src/PostProcess/babylon.ssaoRenderingPipeline.js",
+      "../../src/PostProcess/babylon.volumetricLightScatteringPostProcess.js",
+      "../../src/PostProcess/babylon.lensRenderingPipeline.js",
+      "../../src/PostProcess/babylon.colorCorrectionPostProcess.js",
+      "../../src/Cameras/babylon.stereoscopicCameras.js",
+      "../../src/PostProcess/babylon.hdrRenderingPipeline.js",
+      "../../src/Rendering/babylon.edgesRenderer.js",
+      "../../src/PostProcess/babylon.tonemapPostProcess.js",
+      "../../src/Materials/babylon.pbrMaterial.js",
+      "../../src/Probes/babylon.reflectionProbe.js",
+      "../../src/Particles/babylon.solidParticle.js",
+      "../../src/Particles/babylon.solidParticleSystem.js"
     ]
   }
-}
+}

Tools/Gulp/gulpfile.js

@@ -10,14 +10,14 @@ var rename = require("gulp-rename");
 var cleants = require('gulp-clean-ts-extends');
 var changed = require('gulp-changed');
 var runSequence = require('run-sequence');
-var replace = require("gulp-replace")
+var replace = require("gulp-replace");
 
 var config = require("./config.json");
 
 var shadersStream;
 var workersStream;
 
-var extendsSearchRegex = /var\s__extends[\s\S]+?\};/g
+var extendsSearchRegex = /var\s__extends[\s\S]+?\};/g;
 
 //function to convert the shaders' filenames to variable names.
 function shadersName(filename) {
@@ -50,10 +50,7 @@ gulp.task('typescript-compile', function() {
                     target: 'ES5', 
                     declarationFiles: true,
                     typescript: require('typescript')
-                })).on('error', function(error) {
-                    console.log('Typescript compile failed');
-                    process.exit(1);
-                });
+                }));
     return merge2([
         tsResult.dts
             .pipe(concat(config.build.declarationFilename))
@@ -77,33 +74,48 @@ gulp.task('typescript-sourcemaps', function() {
             .pipe(gulp.dest(config.build.srcOutputDirectory));
 });
 
+gulp.task("buildCore", ["shaders"], function () {
+    return merge2(
+            gulp.src(config.core.files),
+            shadersStream
+        )
+        .pipe(concat(config.build.minCoreFilename))
+        .pipe(cleants())
+        .pipe(replace(extendsSearchRegex, ""))
+        .pipe(addModuleExports("BABYLON"))
+        .pipe(uglify())
+        .pipe(gulp.dest(config.build.outputDirectory));
+});
+
 gulp.task("buildNoWorker", ["shaders"], function () {
     return merge2(
-        gulp.src(config.core.files, config.extras.files),
-        shadersStream
-    )
-    .pipe(concat(config.build.minNoWorkerFilename))
-    .pipe(cleants())
-    .pipe(replace(extendsSearchRegex, ""))
-    .pipe(addModuleExports("BABYLON"))
-    .pipe(uglify())
-    .pipe(gulp.dest(config.build.outputDirectory))
+            gulp.src(config.core.files),
+            gulp.src(config.extras.files),
+            shadersStream
+        )
+        .pipe(concat(config.build.minNoWorkerFilename))
+        .pipe(cleants())
+        .pipe(replace(extendsSearchRegex, ""))
+        .pipe(addModuleExports("BABYLON"))
+        .pipe(uglify())
+        .pipe(gulp.dest(config.build.outputDirectory));
 });
 
 gulp.task("build", ["workers", "shaders"], function () {
     return merge2(
-        gulp.src(config.core.files, config.extras.files),    
-        shadersStream,
-        workersStream
-    )
-    .pipe(concat(config.build.filename))
-    .pipe(cleants())
-    .pipe(replace(extendsSearchRegex, ""))
-    .pipe(addModuleExports("BABYLON"))
-    .pipe(gulp.dest(config.build.outputDirectory))
-    .pipe(rename(config.build.minFilename))
-    .pipe(uglify())
-    .pipe(gulp.dest(config.build.outputDirectory))
+            gulp.src(config.core.files),
+            gulp.src(config.extras.files),
+            shadersStream,
+            workersStream
+        )
+        .pipe(concat(config.build.filename))
+        .pipe(cleants())
+        .pipe(replace(extendsSearchRegex, ""))
+        .pipe(addModuleExports("BABYLON"))
+        .pipe(gulp.dest(config.build.outputDirectory))
+        .pipe(rename(config.build.minFilename))
+        .pipe(uglify())
+        .pipe(gulp.dest(config.build.outputDirectory));
 });
 
 gulp.task("typescript", function(cb) {
@@ -114,7 +126,7 @@ gulp.task("typescript", function(cb) {
  * The default task, call the tasks: build
  */
 gulp.task('default', function() {
-    return runSequence("buildNoWorker", "build");
+    return runSequence("buildNoWorker", "build", "buildCore");
 });
 
 /**

src/Actions/babylon.action.js

@@ -67,3 +67,4 @@ var BABYLON;
     })();
     BABYLON.Action = Action;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.action.js.map

src/Actions/babylon.actionManager.js

@@ -299,3 +299,4 @@ var BABYLON;
     })();
     BABYLON.ActionManager = ActionManager;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.actionManager.js.map

src/Actions/babylon.condition.js

@@ -115,3 +115,4 @@ var BABYLON;
     })(Condition);
     BABYLON.StateCondition = StateCondition;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.condition.js.map

src/Actions/babylon.directActions.js

@@ -202,3 +202,4 @@ var BABYLON;
     })(BABYLON.Action);
     BABYLON.StopSoundAction = StopSoundAction;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.directActions.js.map

src/Actions/babylon.interpolateValueAction.js

@@ -63,3 +63,4 @@ var BABYLON;
     })(BABYLON.Action);
     BABYLON.InterpolateValueAction = InterpolateValueAction;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.interpolateValueAction.js.map

src/Animations/babylon.animatable.js

@@ -100,3 +100,4 @@ var BABYLON;
     })();
     BABYLON.Animatable = Animatable;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.animatable.js.map

src/Animations/babylon.animation.js

@@ -389,3 +389,4 @@ var BABYLON;
     })();
     BABYLON.Animation = Animation;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.animation.js.map

src/Animations/babylon.easing.js

@@ -247,3 +247,4 @@ var BABYLON;
     })(EasingFunction);
     BABYLON.BezierCurveEase = BezierCurveEase;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.easing.js.map

src/Audio/babylon.analyser.js

@@ -109,3 +109,4 @@ var BABYLON;
     })();
     BABYLON.Analyser = Analyser;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.analyser.js.map

src/Audio/babylon.audioEngine.js

@@ -77,3 +77,4 @@ var BABYLON;
     })();
     BABYLON.AudioEngine = AudioEngine;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.audioEngine.js.map

src/Audio/babylon.sound.js

@@ -379,3 +379,4 @@ var BABYLON;
     })();
     BABYLON.Sound = Sound;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.sound.js.map

src/Audio/babylon.soundtrack.js

@@ -92,3 +92,4 @@ var BABYLON;
     })();
     BABYLON.SoundTrack = SoundTrack;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.soundtrack.js.map

src/Bones/babylon.bone.js

@@ -79,3 +79,4 @@ var BABYLON;
     })(BABYLON.Node);
     BABYLON.Bone = Bone;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.bone.js.map

src/Bones/babylon.skeleton.js

@@ -74,3 +74,4 @@ var BABYLON;
     })();
     BABYLON.Skeleton = Skeleton;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.skeleton.js.map

src/Cameras/VR/babylon.vrDeviceOrientationCamera.js

@@ -45,3 +45,4 @@ var BABYLON;
     })(BABYLON.FreeCamera);
     BABYLON.VRDeviceOrientationFreeCamera = VRDeviceOrientationFreeCamera;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.vrDeviceOrientationCamera.js.map

src/Cameras/VR/babylon.webVRCamera.js

@@ -71,3 +71,4 @@ var BABYLON;
     })(BABYLON.FreeCamera);
     BABYLON.WebVRFreeCamera = WebVRFreeCamera;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.webVRCamera.js.map

src/Cameras/babylon.arcRotateCamera.js

@@ -553,3 +553,4 @@ var BABYLON;
     })(BABYLON.TargetCamera);
     BABYLON.ArcRotateCamera = ArcRotateCamera;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.arcRotateCamera.js.map

src/Cameras/babylon.camera.js

@@ -529,3 +529,4 @@ var BABYLON;
     })(BABYLON.Node);
     BABYLON.Camera = Camera;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.camera.js.map

src/Cameras/babylon.deviceOrientationCamera.js

@@ -69,3 +69,4 @@ var BABYLON;
     })(BABYLON.FreeCamera);
     BABYLON.DeviceOrientationCamera = DeviceOrientationCamera;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.deviceOrientationCamera.js.map

src/Cameras/babylon.followCamera.js

@@ -84,3 +84,4 @@ var BABYLON;
     })(BABYLON.TargetCamera);
     BABYLON.ArcFollowCamera = ArcFollowCamera;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.followCamera.js.map

src/Cameras/babylon.freeCamera.js

@@ -226,3 +226,4 @@ var BABYLON;
     })(BABYLON.TargetCamera);
     BABYLON.FreeCamera = FreeCamera;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.freeCamera.js.map

src/Cameras/babylon.gamepadCamera.js

@@ -49,3 +49,4 @@ var BABYLON;
     })(BABYLON.FreeCamera);
     BABYLON.GamepadCamera = GamepadCamera;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.gamepadCamera.js.map

src/Cameras/babylon.stereoscopicCameras.js

@@ -60,3 +60,4 @@ var BABYLON;
     })(BABYLON.GamepadCamera);
     BABYLON.StereoscopicGamepadCamera = StereoscopicGamepadCamera;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.stereoscopicCameras.js.map

src/Cameras/babylon.targetCamera.js

@@ -244,3 +244,4 @@ var BABYLON;
     })(BABYLON.Camera);
     BABYLON.TargetCamera = TargetCamera;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.targetCamera.js.map

src/Cameras/babylon.touchCamera.js

@@ -113,3 +113,4 @@ var BABYLON;
     })(BABYLON.FreeCamera);
     BABYLON.TouchCamera = TouchCamera;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.touchCamera.js.map

src/Cameras/babylon.virtualJoysticksCamera.js

@@ -49,3 +49,4 @@ var BABYLON;
     })(BABYLON.FreeCamera);
     BABYLON.VirtualJoysticksCamera = VirtualJoysticksCamera;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.virtualJoysticksCamera.js.map

src/Collisions/babylon.collider.js

@@ -270,3 +270,4 @@ var BABYLON;
     })();
     BABYLON.Collider = Collider;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.collider.js.map

src/Collisions/babylon.collisionCoordinator.js

@@ -271,3 +271,4 @@ var BABYLON;
     })();
     BABYLON.CollisionCoordinatorLegacy = CollisionCoordinatorLegacy;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.collisionCoordinator.js.map

src/Collisions/babylon.collisionWorker.js

@@ -241,3 +241,4 @@ var BABYLON;
         console.log("single worker init");
     }
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.collisionWorker.js.map

src/Collisions/babylon.pickingInfo.js

@@ -74,3 +74,4 @@ var BABYLON;
     })();
     BABYLON.PickingInfo = PickingInfo;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.pickingInfo.js.map

src/Culling/Octrees/babylon.octree.js

@@ -86,3 +86,4 @@ var BABYLON;
     })();
     BABYLON.Octree = Octree;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.octree.js.map

src/Culling/Octrees/babylon.octreeBlock.js

@@ -120,3 +120,4 @@ var BABYLON;
     })();
     BABYLON.OctreeBlock = OctreeBlock;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.octreeBlock.js.map

src/Culling/babylon.boundingBox.js

@@ -137,3 +137,4 @@ var BABYLON;
     })();
     BABYLON.BoundingBox = BoundingBox;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.boundingBox.js.map

src/Culling/babylon.boundingInfo.js

@@ -103,3 +103,4 @@ var BABYLON;
     })();
     BABYLON.BoundingInfo = BoundingInfo;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.boundingInfo.js.map

src/Culling/babylon.boundingSphere.js

@@ -47,3 +47,4 @@ var BABYLON;
     })();
     BABYLON.BoundingSphere = BoundingSphere;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.boundingSphere.js.map

src/Debug/babylon.debugLayer.js

@@ -606,3 +606,4 @@ var BABYLON;
     })();
     BABYLON.DebugLayer = DebugLayer;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.debugLayer.js.map

src/Layer/babylon.layer.js

@@ -74,3 +74,4 @@ var BABYLON;
     })();
     BABYLON.Layer = Layer;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.layer.js.map

src/LensFlare/babylon.lensFlare.js

@@ -21,3 +21,4 @@ var BABYLON;
     })();
     BABYLON.LensFlare = LensFlare;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.lensFlare.js.map

src/LensFlare/babylon.lensFlareSystem.js

@@ -180,3 +180,4 @@ var BABYLON;
     })();
     BABYLON.LensFlareSystem = LensFlareSystem;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.lensFlareSystem.js.map

src/Lights/Shadows/babylon.shadowGenerator.js

@@ -333,3 +333,4 @@ var BABYLON;
     })();
     BABYLON.ShadowGenerator = ShadowGenerator;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.shadowGenerator.js.map

src/Lights/babylon.directionalLight.js

@@ -92,3 +92,4 @@ var BABYLON;
     })(BABYLON.Light);
     BABYLON.DirectionalLight = DirectionalLight;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.directionalLight.js.map

src/Lights/babylon.hemisphericLight.js

@@ -34,3 +34,4 @@ var BABYLON;
     })(BABYLON.Light);
     BABYLON.HemisphericLight = HemisphericLight;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.hemisphericLight.js.map

src/Lights/babylon.light.js

@@ -75,3 +75,4 @@ var BABYLON;
     })(BABYLON.Node);
     BABYLON.Light = Light;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.light.js.map

src/Lights/babylon.pointLight.js

@@ -39,3 +39,4 @@ var BABYLON;
     })(BABYLON.Light);
     BABYLON.PointLight = PointLight;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.pointLight.js.map

src/Lights/babylon.spotLight.js

@@ -69,3 +69,4 @@ var BABYLON;
     })(BABYLON.Light);
     BABYLON.SpotLight = SpotLight;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.spotLight.js.map

src/Loading/Plugins/babylon.babylonFileLoader.js

@@ -1439,3 +1439,4 @@ var BABYLON;
         });
     })(Internals = BABYLON.Internals || (BABYLON.Internals = {}));
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.babylonFileLoader.js.map

src/Loading/babylon.sceneLoader.js

@@ -174,3 +174,4 @@ var BABYLON;
     BABYLON.SceneLoader = SceneLoader;
     ;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.sceneLoader.js.map

src/Materials/Textures/Procedurals/babylon.customProceduralTexture.js

@@ -122,3 +122,4 @@ var BABYLON;
     })(BABYLON.ProceduralTexture);
     BABYLON.CustomProceduralTexture = CustomProceduralTexture;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.customProceduralTexture.js.map

src/Materials/Textures/Procedurals/babylon.proceduralTexture.js

@@ -247,3 +247,4 @@ var BABYLON;
     })(BABYLON.Texture);
     BABYLON.ProceduralTexture = ProceduralTexture;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.proceduralTexture.js.map

src/Materials/Textures/Procedurals/babylon.standardProceduralTexture.js

@@ -417,3 +417,4 @@ var BABYLON;
     })(BABYLON.ProceduralTexture);
     BABYLON.MarbleProceduralTexture = MarbleProceduralTexture;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.standardProceduralTexture.js.map

src/Materials/Textures/babylon.baseTexture.js

@@ -116,3 +116,4 @@ var BABYLON;
     })();
     BABYLON.BaseTexture = BaseTexture;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.baseTexture.js.map

src/Materials/Textures/babylon.cubeTexture.js

@@ -61,3 +61,4 @@ var BABYLON;
     })(BABYLON.BaseTexture);
     BABYLON.CubeTexture = CubeTexture;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.cubeTexture.js.map

src/Materials/Textures/babylon.dynamicTexture.js

@@ -91,3 +91,4 @@ var BABYLON;
     })(BABYLON.Texture);
     BABYLON.DynamicTexture = DynamicTexture;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.dynamicTexture.js.map

src/Materials/Textures/babylon.mirrorTexture.js

@@ -44,3 +44,4 @@ var BABYLON;
     })(BABYLON.RenderTargetTexture);
     BABYLON.MirrorTexture = MirrorTexture;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.mirrorTexture.js.map

src/Materials/Textures/babylon.rawTexture.js

@@ -55,3 +55,4 @@ var BABYLON;
     })(BABYLON.Texture);
     BABYLON.RawTexture = RawTexture;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.rawTexture.js.map

src/Materials/Textures/babylon.renderTargetTexture.js

@@ -233,3 +233,4 @@ var BABYLON;
     })(BABYLON.Texture);
     BABYLON.RenderTargetTexture = RenderTargetTexture;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.renderTargetTexture.js.map

src/Materials/Textures/babylon.texture.js

@@ -212,3 +212,4 @@ var BABYLON;
     })(BABYLON.BaseTexture);
     BABYLON.Texture = Texture;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.texture.js.map

src/Materials/Textures/babylon.videoTexture.js

@@ -56,3 +56,4 @@ var BABYLON;
     })(BABYLON.Texture);
     BABYLON.VideoTexture = VideoTexture;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.videoTexture.js.map

src/Materials/babylon.effect.js

@@ -371,3 +371,4 @@ var BABYLON;
     })();
     BABYLON.Effect = Effect;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.effect.js.map

src/Materials/babylon.material.js

@@ -192,3 +192,4 @@ var BABYLON;
     })();
     BABYLON.Material = Material;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.material.js.map

src/Materials/babylon.multiMaterial.js

@@ -43,3 +43,4 @@ var BABYLON;
     })(BABYLON.Material);
     BABYLON.MultiMaterial = MultiMaterial;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.multiMaterial.js.map

src/Materials/babylon.pbrMaterial.js

@@ -259,3 +259,4 @@ var BABYLON;
     })(BABYLON.Material);
     BABYLON.PBRMaterial = PBRMaterial;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.pbrMaterial.js.map

src/Materials/babylon.shaderMaterial.js

@@ -231,3 +231,4 @@ var BABYLON;
     })(BABYLON.Material);
     BABYLON.ShaderMaterial = ShaderMaterial;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.shaderMaterial.js.map

src/Materials/babylon.standardMaterial.js

@@ -850,3 +850,4 @@ var BABYLON;
     })(BABYLON.Material);
     BABYLON.StandardMaterial = StandardMaterial;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.standardMaterial.js.map

src/Math/babylon.math.js

@@ -3139,3 +3139,4 @@ var BABYLON;
     })();
     BABYLON.SIMDHelper = SIMDHelper;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.math.js.map

src/Mesh/babylon.abstractMesh.js

@@ -888,3 +888,4 @@ var BABYLON;
     })(BABYLON.Node);
     BABYLON.AbstractMesh = AbstractMesh;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.abstractMesh.js.map

src/Mesh/babylon.csg.js

@@ -508,3 +508,4 @@ var BABYLON;
     })();
     BABYLON.CSG = CSG;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.csg.js.map

src/Mesh/babylon.geometry.js

@@ -634,3 +634,4 @@ var BABYLON;
         })(Primitives = Geometry.Primitives || (Geometry.Primitives = {}));
     })(Geometry = BABYLON.Geometry || (BABYLON.Geometry = {}));
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.geometry.js.map

src/Mesh/babylon.groundMesh.js

@@ -39,3 +39,4 @@ var BABYLON;
     })(BABYLON.Mesh);
     BABYLON.GroundMesh = GroundMesh;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.groundMesh.js.map

src/Mesh/babylon.instancedMesh.js

@@ -150,3 +150,4 @@ var BABYLON;
     })(BABYLON.AbstractMesh);
     BABYLON.InstancedMesh = InstancedMesh;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.instancedMesh.js.map

src/Mesh/babylon.linesMesh.js

@@ -69,3 +69,4 @@ var BABYLON;
     })(BABYLON.Mesh);
     BABYLON.LinesMesh = LinesMesh;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.linesMesh.js.map

src/Mesh/babylon.mesh.js

@@ -2167,3 +2167,4 @@ var BABYLON;
     })(BABYLON.AbstractMesh);
     BABYLON.Mesh = Mesh;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.mesh.js.map

src/Mesh/babylon.mesh.vertexData.js

@@ -1370,3 +1370,4 @@ var BABYLON;
     })();
     BABYLON.VertexData = VertexData;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.mesh.vertexData.js.map

src/Mesh/babylon.meshLODLevel.js

@@ -12,3 +12,4 @@ var BABYLON;
         Internals.MeshLODLevel = MeshLODLevel;
     })(Internals = BABYLON.Internals || (BABYLON.Internals = {}));
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.meshLODLevel.js.map

src/Mesh/babylon.meshSimplification.js

@@ -655,3 +655,4 @@ var BABYLON;
     })();
     BABYLON.QuadraticErrorSimplification = QuadraticErrorSimplification;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.meshSimplification.js.map

src/Mesh/babylon.polygonMesh.js

@@ -243,3 +243,4 @@ var BABYLON;
     })();
     BABYLON.PolygonMeshBuilder = PolygonMeshBuilder;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.polygonMesh.js.map

src/Mesh/babylon.subMesh.js

@@ -143,3 +143,4 @@ var BABYLON;
     })();
     BABYLON.SubMesh = SubMesh;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.subMesh.js.map

src/Mesh/babylon.vertexBuffer.js

@@ -190,3 +190,4 @@ var BABYLON;
     })();
     BABYLON.VertexBuffer = VertexBuffer;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.vertexBuffer.js.map

src/Particles/babylon.particle.js

@@ -27,3 +27,4 @@ var BABYLON;
     })();
     BABYLON.Particle = Particle;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.particle.js.map

src/Particles/babylon.particleSystem.js

@@ -335,3 +335,4 @@ var BABYLON;
     })();
     BABYLON.ParticleSystem = ParticleSystem;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.particleSystem.js.map

src/Particles/babylon.solidParticle.js

@@ -19,3 +19,4 @@ var BABYLON;
     })();
     BABYLON.SolidParticle = SolidParticle;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.solidParticle.js.map

src/Particles/babylon.solidParticle.ts

@@ -1,18 +1,18 @@
 module BABYLON {
 
     export class SolidParticle {
-        public idx: number; 
+        public idx: number;
         public color = new Color4(1, 1, 1, 1);
         public position = Vector3.Zero();
         public rotation = Vector3.Zero();
         public quaternion: Vector4;
-        public scale = new Vector3(1 ,1, 1);
-        public uvs = new Vector4(0,0, 1,1);
+        public scale = new Vector3(1, 1, 1);
+        public uvs = new Vector4(0, 0, 1, 1);
         public velocity = Vector3.Zero();
         public alive = true;
         public _pos: number;
-        public _shape: Vector3[]; 
-        public _shapeUV : number[];   
+        public _shape: Vector3[];
+        public _shapeUV: number[];
         public previous: SolidParticle;
         public next: SolidParticle;
 
@@ -23,4 +23,4 @@ module BABYLON {
             this._shapeUV = shapeUV;
         }
     }
-}
+}

src/Particles/babylon.solidParticleSystem.js

@@ -0,0 +1,370 @@
+var BABYLON;
+(function (BABYLON) {
+    var SolidParticleSystem = (function () {
+        function SolidParticleSystem(name, scene) {
+            // public members  
+            this.particles = new Array();
+            this.nbParticles = 0;
+            this.billboard = false;
+            this.counter = 0;
+            this._positions = new Array();
+            this._indices = new Array();
+            this._normals = new Array();
+            this._colors = new Array();
+            this._uvs = new Array();
+            this._index = 0; // indices index
+            this._shapeCounter = 0;
+            this._useParticleColor = true;
+            this._useParticleTexture = true;
+            this._useParticleRotation = true;
+            this._useParticleVertex = false;
+            this._cam_axisZ = BABYLON.Vector3.Zero();
+            this._cam_axisY = BABYLON.Vector3.Zero();
+            this._cam_axisX = BABYLON.Vector3.Zero();
+            this._axisX = BABYLON.Axis.X;
+            this._axisY = BABYLON.Axis.Y;
+            this._axisZ = BABYLON.Axis.Z;
+            this._fakeCamPos = BABYLON.Vector3.Zero();
+            this._rotMatrix = new BABYLON.Matrix();
+            this._invertedMatrix = new BABYLON.Matrix();
+            this._rotated = BABYLON.Vector3.Zero();
+            this._quaternion = new BABYLON.Quaternion();
+            this._vertex = BABYLON.Vector3.Zero();
+            this._yaw = 0.0;
+            this._pitch = 0.0;
+            this._roll = 0.0;
+            this._halfroll = 0.0;
+            this._halfpitch = 0.0;
+            this._halfyaw = 0.0;
+            this._sinRoll = 0.0;
+            this._cosRoll = 0.0;
+            this._sinPitch = 0.0;
+            this._cosPitch = 0.0;
+            this._sinYaw = 0.0;
+            this._cosYaw = 0.0;
+            this.name = name;
+            this._scene = scene;
+            this._camera = scene.activeCamera;
+        }
+        // build the SPS mesh : returns the mesh
+        SolidParticleSystem.prototype.buildMesh = function () {
+            if (this.nbParticles === 0) {
+                var triangle = BABYLON.Mesh.CreateDisc("", { radius: 1, tessellation: 3 }, this._scene);
+                this.addShape(triangle, 1);
+                triangle.dispose();
+            }
+            BABYLON.VertexData.ComputeNormals(this._positions, this._indices, this._normals);
+            var vertexData = new BABYLON.VertexData();
+            vertexData.positions = this._positions;
+            vertexData.indices = this._indices;
+            vertexData.normals = this._normals;
+            if (this._uvs) {
+                vertexData.uvs = this._uvs;
+            }
+            if (this._colors) {
+                vertexData.colors = this._colors;
+            }
+            var mesh = new BABYLON.Mesh(name, this._scene);
+            vertexData.applyToMesh(mesh, true);
+            this.mesh = mesh;
+            return mesh;
+        };
+        // _meshBuilder : inserts the shape model in the global SPS mesh
+        SolidParticleSystem.prototype._meshBuilder = function (p, shape, positions, meshInd, indices, meshUV, uvs, meshCol, colors) {
+            var i;
+            var u = 0;
+            var c = 0;
+            for (i = 0; i < shape.length; i++) {
+                positions.push(shape[i].x, shape[i].y, shape[i].z);
+                if (meshUV) {
+                    uvs.push(meshUV[u], meshUV[u + 1]);
+                    u += 2;
+                }
+                if (meshCol) {
+                    colors.push(meshCol[c], meshCol[c + 1], meshCol[c + 2], meshCol[c + 3]);
+                    c += 4;
+                }
+                else {
+                    colors.push(1, 1, 1, 1);
+                }
+            }
+            for (i = 0; i < meshInd.length; i++) {
+                indices.push(p + meshInd[i]);
+            }
+        };
+        // returns a shape array from positions array
+        SolidParticleSystem.prototype._posToShape = function (positions) {
+            var shape = [];
+            for (var i = 0; i < positions.length; i += 3) {
+                shape.push(new BABYLON.Vector3(positions[i], positions[i + 1], positions[i + 2]));
+            }
+            return shape;
+        };
+        // returns a shapeUV array from a Vector4 uvs
+        SolidParticleSystem.prototype._uvsToShapeUV = function (uvs) {
+            var shapeUV = [];
+            if (uvs) {
+                for (var i = 0; i < uvs.length; i++)
+                    shapeUV.push(uvs[i]);
+            }
+            return shapeUV;
+        };
+        // adds a new particle object in the particles array and double links the particle (next/previous)
+        SolidParticleSystem.prototype._addParticle = function (p, idxpos, shape, shapeUV, shapeId) {
+            this._particle = new BABYLON.SolidParticle(p, idxpos, shape, shapeUV, shapeId);
+            this.particles.push(this._particle);
+            this._particle.previous = this._previousParticle;
+            if (this._previousParticle) {
+                this._previousParticle.next = this._particle;
+            }
+            this._previousParticle = this._particle;
+        };
+        // add solid particles from a shape model in the particles array
+        SolidParticleSystem.prototype.addShape = function (mesh, nb) {
+            var meshPos = mesh.getVerticesData(BABYLON.VertexBuffer.PositionKind);
+            var meshInd = mesh.getIndices();
+            var meshUV = mesh.getVerticesData(BABYLON.VertexBuffer.UVKind);
+            var meshCol = mesh.getVerticesData(BABYLON.VertexBuffer.ColorKind);
+            var shape = this._posToShape(meshPos);
+            var shapeUV = this._uvsToShapeUV(meshUV);
+            // particles
+            for (var i = 0; i < nb; i++) {
+                this._meshBuilder(this._index, shape, this._positions, meshInd, this._indices, meshUV, this._uvs, meshCol, this._colors);
+                this._addParticle(this.nbParticles + i, this._positions.length, shape, shapeUV, this._shapeCounter);
+                this._index += shape.length;
+            }
+            this.nbParticles += nb;
+            this._shapeCounter++;
+            return this._shapeCounter;
+        };
+        // resets a particle back to its just built status
+        SolidParticleSystem.prototype.resetParticle = function (particle) {
+            for (var pt = 0; pt < particle._shape.length; pt++) {
+                this._positions[particle._pos + pt * 3] = particle._shape[pt].x;
+                this._positions[particle._pos + pt * 3 + 1] = particle._shape[pt].y;
+                this._positions[particle._pos + pt * 3 + 2] = particle._shape[pt].z;
+            }
+        };
+        // sets all the particles
+        SolidParticleSystem.prototype.setParticles = function (start, end, update) {
+            if (start === void 0) { start = 0; }
+            if (end === void 0) { end = this.nbParticles - 1; }
+            if (update === void 0) { update = true; }
+            // custom beforeUpdate
+            this.beforeUpdateParticles(start, end, update);
+            this._cam_axisX.x = 1;
+            this._cam_axisX.y = 0;
+            this._cam_axisX.z = 0;
+            this._cam_axisY.x = 0;
+            this._cam_axisY.y = 1;
+            this._cam_axisY.z = 0;
+            this._cam_axisZ.x = 0;
+            this._cam_axisZ.y = 0;
+            this._cam_axisZ.z = 1;
+            // if the particles will always face the camera
+            if (this.billboard) {
+                // compute a fake camera position : un-rotate the camera position by the current mesh rotation
+                this._yaw = this.mesh.rotation.y;
+                this._pitch = this.mesh.rotation.x;
+                this._roll = this.mesh.rotation.z;
+                this._quaternionRotationYPR();
+                this._quaternionToRotationMatrix();
+                this._rotMatrix.invertToRef(this._invertedMatrix);
+                BABYLON.Vector3.TransformCoordinatesToRef(this._camera.globalPosition, this._invertedMatrix, this._fakeCamPos);
+                // set two orthogonal vectors (_cam_axisX and and _cam_axisY) to the cam-mesh axis (_cam_axisZ)
+                (this._fakeCamPos).subtractToRef(this.mesh.position, this._cam_axisZ);
+                BABYLON.Vector3.CrossToRef(this._cam_axisZ, this._axisX, this._cam_axisY);
+                BABYLON.Vector3.CrossToRef(this._cam_axisZ, this._cam_axisY, this._cam_axisX);
+                this._cam_axisY.normalize();
+                this._cam_axisX.normalize();
+                this._cam_axisZ.normalize();
+            }
+            BABYLON.Matrix.IdentityToRef(this._rotMatrix);
+            var idx = 0;
+            var index = 0;
+            var colidx = 0;
+            var colorIndex = 0;
+            var uvidx = 0;
+            var uvIndex = 0;
+            // particle loop
+            for (var p = start; p <= end; p++) {
+                this._particle = this.particles[p];
+                // call to custom user function to update the particle properties
+                this.updateParticle(this._particle);
+                // particle rotation matrix
+                if (this.billboard) {
+                    this._particle.rotation.x = 0.0;
+                    this._particle.rotation.y = 0.0;
+                }
+                if (this._useParticleRotation) {
+                    if (this._particle.quaternion) {
+                        this._quaternion.x = this._particle.quaternion.x;
+                        this._quaternion.y = this._particle.quaternion.y;
+                        this._quaternion.z = this._particle.quaternion.z;
+                        this._quaternion.w = this._particle.quaternion.w;
+                    }
+                    else {
+                        this._yaw = this._particle.rotation.y;
+                        this._pitch = this._particle.rotation.x;
+                        this._roll = this._particle.rotation.z;
+                        this._quaternionRotationYPR();
+                    }
+                    this._quaternionToRotationMatrix();
+                }
+                for (var pt = 0; pt < this._particle._shape.length; pt++) {
+                    idx = index + pt * 3;
+                    colidx = colorIndex + pt * 4;
+                    uvidx = uvIndex + pt * 2;
+                    this._vertex.x = this._particle._shape[pt].x;
+                    this._vertex.y = this._particle._shape[pt].y;
+                    this._vertex.z = this._particle._shape[pt].z;
+                    if (this._useParticleVertex) {
+                        this.updateParticleVertex(this._particle, this._vertex, pt);
+                    }
+                    BABYLON.Vector3.TransformCoordinatesToRef(this._vertex, this._rotMatrix, this._rotated);
+                    this._positions[idx] = this._particle.position.x + this._cam_axisX.x * this._rotated.x * this._particle.scale.x + this._cam_axisY.x * this._rotated.y * this._particle.scale.y + this._cam_axisZ.x * this._rotated.z * this._particle.scale.z;
+                    this._positions[idx + 1] = this._particle.position.y + this._cam_axisX.y * this._rotated.x * this._particle.scale.x + this._cam_axisY.y * this._rotated.y * this._particle.scale.y + this._cam_axisZ.y * this._rotated.z * this._particle.scale.z;
+                    this._positions[idx + 2] = this._particle.position.z + this._cam_axisX.z * this._rotated.x * this._particle.scale.x + this._cam_axisY.z * this._rotated.y * this._particle.scale.y + this._cam_axisZ.z * this._rotated.z * this._particle.scale.z;
+                    if (this._useParticleColor) {
+                        this._colors[colidx] = this._particle.color.r;
+                        this._colors[colidx + 1] = this._particle.color.g;
+                        this._colors[colidx + 2] = this._particle.color.b;
+                        this._colors[colidx + 3] = this._particle.color.a;
+                    }
+                    if (this._useParticleTexture) {
+                        this._uvs[uvidx] = this._particle._shapeUV[pt * 2] * (this._particle.uvs.z - this._particle.uvs.x) + this._particle.uvs.x;
+                        this._uvs[uvidx + 1] = this._particle._shapeUV[pt * 2 + 1] * (this._particle.uvs.w - this._particle.uvs.y) + this._particle.uvs.y;
+                    }
+                }
+                index = idx + 3;
+                colorIndex = colidx + 4;
+                uvIndex = uvidx + 2;
+            }
+            if (update) {
+                if (this._useParticleColor) {
+                    this.mesh.updateVerticesData(BABYLON.VertexBuffer.ColorKind, this._colors, false, false);
+                }
+                if (this._useParticleTexture) {
+                    this.mesh.updateVerticesData(BABYLON.VertexBuffer.UVKind, this._uvs, false, false);
+                }
+                this.mesh.updateVerticesData(BABYLON.VertexBuffer.PositionKind, this._positions, false, false);
+                if (!this.mesh.areNormalsFrozen) {
+                    BABYLON.VertexData.ComputeNormals(this._positions, this._indices, this._normals);
+                    this.mesh.updateVerticesData(BABYLON.VertexBuffer.NormalKind, this._normals, false, false);
+                }
+            }
+            this.afterUpdateParticles(start, end, update);
+        };
+        SolidParticleSystem.prototype._quaternionRotationYPR = function () {
+            this._halfroll = this._roll * 0.5;
+            this._halfpitch = this._pitch * 0.5;
+            this._halfyaw = this._yaw * 0.5;
+            this._sinRoll = Math.sin(this._halfroll);
+            this._cosRoll = Math.cos(this._halfroll);
+            this._sinPitch = Math.sin(this._halfpitch);
+            this._cosPitch = Math.cos(this._halfpitch);
+            this._sinYaw = Math.sin(this._halfyaw);
+            this._cosYaw = Math.cos(this._halfyaw);
+            this._quaternion.x = (this._cosYaw * this._sinPitch * this._cosRoll) + (this._sinYaw * this._cosPitch * this._sinRoll);
+            this._quaternion.y = (this._sinYaw * this._cosPitch * this._cosRoll) - (this._cosYaw * this._sinPitch * this._sinRoll);
+            this._quaternion.z = (this._cosYaw * this._cosPitch * this._sinRoll) - (this._sinYaw * this._sinPitch * this._cosRoll);
+            this._quaternion.w = (this._cosYaw * this._cosPitch * this._cosRoll) + (this._sinYaw * this._sinPitch * this._sinRoll);
+        };
+        SolidParticleSystem.prototype._quaternionToRotationMatrix = function () {
+            this._rotMatrix.m[0] = 1.0 - (2.0 * (this._quaternion.y * this._quaternion.y + this._quaternion.z * this._quaternion.z));
+            this._rotMatrix.m[1] = 2.0 * (this._quaternion.x * this._quaternion.y + this._quaternion.z * this._quaternion.w);
+            this._rotMatrix.m[2] = 2.0 * (this._quaternion.z * this._quaternion.x - this._quaternion.y * this._quaternion.w);
+            this._rotMatrix.m[3] = 0;
+            this._rotMatrix.m[4] = 2.0 * (this._quaternion.x * this._quaternion.y - this._quaternion.z * this._quaternion.w);
+            this._rotMatrix.m[5] = 1.0 - (2.0 * (this._quaternion.z * this._quaternion.z + this._quaternion.x * this._quaternion.x));
+            this._rotMatrix.m[6] = 2.0 * (this._quaternion.y * this._quaternion.z + this._quaternion.x * this._quaternion.w);
+            this._rotMatrix.m[7] = 0;
+            this._rotMatrix.m[8] = 2.0 * (this._quaternion.z * this._quaternion.x + this._quaternion.y * this._quaternion.w);
+            this._rotMatrix.m[9] = 2.0 * (this._quaternion.y * this._quaternion.z - this._quaternion.x * this._quaternion.w);
+            this._rotMatrix.m[10] = 1.0 - (2.0 * (this._quaternion.y * this._quaternion.y + this._quaternion.x * this._quaternion.x));
+            this._rotMatrix.m[11] = 0;
+            this._rotMatrix.m[12] = 0;
+            this._rotMatrix.m[13] = 0;
+            this._rotMatrix.m[14] = 0;
+            this._rotMatrix.m[15] = 1.0;
+        };
+        // dispose the SPS
+        SolidParticleSystem.prototype.dispose = function () {
+            this.mesh.dispose();
+        };
+        Object.defineProperty(SolidParticleSystem.prototype, "useParticleRotation", {
+            // getters
+            get: function () {
+                return this._useParticleRotation;
+            },
+            // Optimizer setters
+            set: function (val) {
+                this._useParticleRotation = val;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(SolidParticleSystem.prototype, "useParticleColor", {
+            get: function () {
+                return this._useParticleColor;
+            },
+            set: function (val) {
+                this._useParticleColor = val;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(SolidParticleSystem.prototype, "useParticleTexture", {
+            get: function () {
+                return this._useParticleTexture;
+            },
+            set: function (val) {
+                this._useParticleTexture = val;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(SolidParticleSystem.prototype, "useParticleVertex", {
+            get: function () {
+                return this._useParticleVertex;
+            },
+            set: function (val) {
+                this._useParticleVertex = val;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        // =======================================================================
+        // Particle behavior logic
+        // these following methods may be overwritten by the user to fit his needs
+        // init : sets all particles first values and calls updateParticle to set them in space
+        // can be overwritten by the user
+        SolidParticleSystem.prototype.initParticles = function () {
+        };
+        // recycles a particle : can by overwritten by the user
+        SolidParticleSystem.prototype.recycleParticle = function (particle) {
+            return particle;
+        };
+        // updates a particle : can be overwritten by the user
+        // will be called on each particle by setParticles() :
+        // ex : just set a particle position or velocity and recycle conditions
+        SolidParticleSystem.prototype.updateParticle = function (particle) {
+            return particle;
+        };
+        // updates a vertex of a particle : can be overwritten by the user
+        // will be called on each vertex particle by setParticles() :
+        // ex : just set a vertex particle position
+        SolidParticleSystem.prototype.updateParticleVertex = function (particle, vertex, i) {
+            return vertex;
+        };
+        // will be called before any other treatment by setParticles()
+        SolidParticleSystem.prototype.beforeUpdateParticles = function (start, stop, update) {
+        };
+        // will be called after all setParticles() treatments
+        SolidParticleSystem.prototype.afterUpdateParticles = function (start, stop, update) {
+        };
+        return SolidParticleSystem;
+    })();
+    BABYLON.SolidParticleSystem = SolidParticleSystem;
+})(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.solidParticleSystem.js.map

src/Particles/babylon.solidParticleSystem.ts

@@ -31,24 +31,24 @@ module BABYLON {
         private _camera: Camera;
         private _particle: SolidParticle;
         private _previousParticle: SolidParticle;
-        private _fakeCamPos: Vector3 = Vector3.Zero();
-        private _rotMatrix: Matrix = new Matrix();
-        private _invertedMatrix: Matrix = new Matrix();
-        private _rotated: Vector3 = Vector3.Zero();
-        private _quaternion: Quaternion = new Quaternion();
-        private _vertex: Vector3 = Vector3.Zero();
-        private _yaw: number = 0.0;
-        private _pitch: number = 0.0;
-        private _roll: number = 0.0;
-        private _halfroll: number = 0.0;
-        private _halfpitch: number = 0.0;
-        private _halfyaw: number = 0.0;
-        private _sinRoll: number = 0.0;
-        private _cosRoll: number = 0.0;
-        private _sinPitch: number = 0.0;
-        private _cosPitch: number = 0.0;
-        private _sinYaw: number = 0.0;
-        private _cosYaw: number = 0.0;
+        private _fakeCamPos = Vector3.Zero();
+        private _rotMatrix = new Matrix();
+        private _invertedMatrix = new Matrix();
+        private _rotated = Vector3.Zero();
+        private _quaternion = new Quaternion();
+        private _vertex = Vector3.Zero();
+        private _yaw = 0.0;
+        private _pitch = 0.0;
+        private _roll = 0.0;
+        private _halfroll = 0.0;
+        private _halfpitch = 0.0;
+        private _halfyaw = 0.0;
+        private _sinRoll = 0.0;
+        private _cosRoll = 0.0;
+        private _sinPitch = 0.0;
+        private _cosPitch = 0.0;
+        private _sinYaw = 0.0;
+        private _cosYaw = 0.0;
 
 
         constructor(name: string, scene: Scene) {
@@ -60,7 +60,7 @@ module BABYLON {
         // build the SPS mesh : returns the mesh
         public buildMesh(): Mesh {
             if (this.nbParticles === 0) {
-                var triangle = Mesh.CreateDisc("", {radius: 1, tessellation: 3}, this._scene);
+                var triangle = Mesh.CreateDisc("", { radius: 1, tessellation: 3 }, this._scene);
                 this.addShape(triangle, 1);
                 triangle.dispose();
             }
@@ -210,7 +210,7 @@ module BABYLON {
             var uvIndex = 0;
 
             // particle loop
-            for (var p = start; p <= end; p++) { 
+            for (var p = start; p <= end; p++) {
                 this._particle = this.particles[p];
 
                 // call to custom user function to update the particle properties
@@ -287,7 +287,7 @@ module BABYLON {
             }
             this.afterUpdateParticles(start, end, update);
         }
-        
+
         private _quaternionRotationYPR(): void {
             this._halfroll = this._roll * 0.5;
             this._halfpitch = this._pitch * 0.5;
@@ -303,7 +303,7 @@ module BABYLON {
             this._quaternion.z = (this._cosYaw * this._cosPitch * this._sinRoll) - (this._sinYaw * this._sinPitch * this._cosRoll);
             this._quaternion.w = (this._cosYaw * this._cosPitch * this._cosRoll) + (this._sinYaw * this._sinPitch * this._sinRoll);
         }
-        
+
         private _quaternionToRotationMatrix(): void {
             this._rotMatrix.m[0] = 1.0 - (2.0 * (this._quaternion.y * this._quaternion.y + this._quaternion.z * this._quaternion.z));
             this._rotMatrix.m[1] = 2.0 * (this._quaternion.x * this._quaternion.y + this._quaternion.z * this._quaternion.w);
@@ -400,4 +400,4 @@ module BABYLON {
         public afterUpdateParticles(start?: number, stop?: number, update?: boolean): void {
         }
     }
-}
+}

src/Physics/Plugins/babylon.cannonJSPlugin.js

@@ -133,7 +133,7 @@ var BABYLON;
             });
             body.quaternion = new CANNON.Quaternion(mesh.rotationQuaternion.x, mesh.rotationQuaternion.y, mesh.rotationQuaternion.z, mesh.rotationQuaternion.w);
             //is shape is a plane, it must be rotated 90 degs in the X axis.
-            if (shape.type == CANNON.Shape.types.PLANE) {
+            if (shape.type === CANNON.Shape.types.PLANE) {
                 var tmpQ = new CANNON.Quaternion();
                 tmpQ.setFromAxisAngle(new CANNON.Vec3(1, 0, 0), -Math.PI / 2);
                 body.quaternion = body.quaternion.mult(tmpQ);
@@ -223,3 +223,4 @@ var BABYLON;
     })();
     BABYLON.CannonJSPlugin = CannonJSPlugin;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.cannonJSPlugin.js.map

src/Physics/Plugins/babylon.cannonJSPlugin.ts

@@ -37,7 +37,7 @@
                 registeredMesh.mesh.position.x = bodyX + deltaPos.x;
                 registeredMesh.mesh.position.y = bodyY + deltaPos.y;
                 registeredMesh.mesh.position.z = bodyZ + deltaPos.z;
-                
+
                 registeredMesh.mesh.rotationQuaternion.x = registeredMesh.body.quaternion.x;
                 registeredMesh.mesh.rotationQuaternion.y = registeredMesh.body.quaternion.y;
                 registeredMesh.mesh.rotationQuaternion.z = registeredMesh.body.quaternion.z;
@@ -108,7 +108,7 @@
 
             var shape = new CANNON.ConvexPolyhedron(verts, faces);
 
-            return shape;            
+            return shape;
         }
 
         private _addMaterial(friction: number, restitution: number) {
@@ -157,7 +157,7 @@
 
             body.quaternion = new CANNON.Quaternion(mesh.rotationQuaternion.x, mesh.rotationQuaternion.y, mesh.rotationQuaternion.z, mesh.rotationQuaternion.w);
             //is shape is a plane, it must be rotated 90 degs in the X axis.
-            if (shape.type == CANNON.Shape.types.PLANE) {
+            if (shape.type === CANNON.Shape.types.PLANE) {
                 var tmpQ = new CANNON.Quaternion();
                 tmpQ.setFromAxisAngle(new CANNON.Vec3(1, 0, 0), -Math.PI / 2);
                 body.quaternion = body.quaternion.mult(tmpQ);
@@ -189,10 +189,10 @@
                 mesh.computeWorldMatrix(true);
                 var shape = this._createShape(mesh, parts[index].impostor);
                 var localPosition = mesh.position;
-                
+
                 body.addShape(shape, new CANNON.Vec3(localPosition.x, localPosition.y, localPosition.z));
             }
-            
+
             return body;
         }
 
@@ -289,3 +289,4 @@
         }
     }
 }
+

src/Physics/Plugins/babylon.oimoJSPlugin.js

@@ -314,3 +314,4 @@ var BABYLON;
     })();
     BABYLON.OimoJSPlugin = OimoJSPlugin;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.oimoJSPlugin.js.map

src/Physics/babylon.physicsEngine.js

@@ -60,3 +60,4 @@ var BABYLON;
     })();
     BABYLON.PhysicsEngine = PhysicsEngine;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.physicsEngine.js.map

src/PostProcess/RenderPipeline/babylon.postProcessRenderEffect.js

@@ -138,3 +138,4 @@ var BABYLON;
     })();
     BABYLON.PostProcessRenderEffect = PostProcessRenderEffect;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.postProcessRenderEffect.js.map

src/PostProcess/RenderPipeline/babylon.postProcessRenderPass.js

@@ -40,3 +40,4 @@ var BABYLON;
     })();
     BABYLON.PostProcessRenderPass = PostProcessRenderPass;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.postProcessRenderPass.js.map

src/PostProcess/RenderPipeline/babylon.postProcessRenderPipeline.js

@@ -110,3 +110,4 @@ var BABYLON;
     })();
     BABYLON.PostProcessRenderPipeline = PostProcessRenderPipeline;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.postProcessRenderPipeline.js.map

src/PostProcess/RenderPipeline/babylon.postProcessRenderPipelineManager.js

@@ -58,3 +58,4 @@ var BABYLON;
     })();
     BABYLON.PostProcessRenderPipelineManager = PostProcessRenderPipelineManager;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.postProcessRenderPipelineManager.js.map