Use JSON files

assets/particles/systems/fire.json

@@ -0,0 +1,24 @@
+{
+  "type": "fire",
+  "capacity": 2000,
+  "textureFile": "flare.png",
+  "minEmitBox": { "x": -0.5, "y": 1, "z": -0.5 },
+  "maxEmitBox": { "x": 0.5, "y": 1, "z": 0.5 },
+  "color1": { "r": 1, "g": 0.5, "b": 0, "a": 1.0 },
+  "color2": { "r": 1, "g": 0.5, "b": 0, "a": 1.0 },
+  "colorDead": { "r": 0, "g": 0, "b": 0, "a": 0.0 },
+  "minSize": 0.3,
+  "maxSize": 1,
+  "minLifeTime": 0.2,
+  "maxLifeTime": 0.4,
+  "emitRate": 600,
+  "blendMode": 0,
+  "gravity": { "x": 0, "y": 0, "z": 0 },
+  "direction1": { "x": 0, "y": 4, "z": 0 },
+  "direction2": { "x": 0, "y": 4, "z": 0 },
+  "minAngularSpeed": 0,
+  "maxAngularSpeed": 3.141592653589793,
+  "minEmitPower": 1,
+  "maxEmitPower": 3,
+  "updateSpeed": 0.007
+}

assets/particles/systems/smoke.json

@@ -0,0 +1,24 @@
+{
+  "type": "smoke",
+  "capacity": 1000,
+  "textureFile": "flare.png",
+  "minEmitBox": { "x": -0.5, "y": 1, "z": -0.5 },
+  "maxEmitBox": { "x": 0.5, "y": 1, "z": 0.5 },
+  "color1": { "r": 0.1, "g": 0.1, "b": 0.1, "a": 1.0 },
+  "color2": { "r": 0.1, "g": 0.1, "b": 0.1, "a": 1.0 },
+  "colorDead": { "r": 0, "g": 0, "b": 0, "a": 0.0 },
+  "minSize": 0.3,
+  "maxSize": 1,
+  "minLifeTime": 0.3,
+  "maxLifeTime": 1.5,
+  "emitRate": 350,
+  "blendMode": 0,
+  "gravity": { "x": 0, "y": 0, "z": 0 },
+  "direction1": { "x": -1.5, "y": 8, "z": -1.5 },
+  "direction2": { "x": 1.5, "y": 8, "z": 1.5 },
+  "minAngularSpeed": 0,
+  "maxAngularSpeed": 3.141592653589793,
+  "minEmitPower": 0.5,
+  "maxEmitPower": 1.5,
+  "updateSpeed": 0.005
+}

src/Helpers/babylon.particleHelper.ts

@@ -1,20 +1,47 @@
 module BABYLON {
     /**
+     * Represents all the data needed to create a ParticleSystem.
+     */
+    export interface IParticleSystemData {
+        type: ParticleSystemType;
+        capacity: number;
+        textureFile: string;
+        minEmitBox: { x: number, y: number, z: number };
+        maxEmitBox: { x: number, y: number, z: number };
+        color1: { r: number, g: number, b: number, a: number };
+        color2: { r: number, g: number, b: number, a: number };
+        colorDead: { r: number, g: number, b: number, a: number };
+        minSize: number;
+        maxSize: number;
+        minLifeTime: number;
+        maxLifeTime: number;
+        emitRate: number;
+        blendMode: number;
+        gravity: { x: number, y: number, z: number };
+        direction1: { x: number, y: number, z: number };
+        direction2: { x: number, y: number, z: number };
+        minAngularSpeed: number;
+        maxAngularSpeed: number;
+        minEmitPower: number;
+        maxEmitPower: number;
+        updateSpeed: number;
+    }
+    /**
      * ParticleSystemType
      */
     export enum ParticleSystemType {
         /**
          * None is to represents an error in parsing the type string in the create method.
          */
-        None,
+        None = "none",
         /**
          * Fire particle system.
          */
-        Fire,
+        Fire = "fire",
         /**
          * Smoke particle system.
          */
-        Smoke
+        Smoke = "smoke"
     }
     /**
      * This class is made for on one-liner static method to help creating particle systems.
@@ -37,33 +64,29 @@ module BABYLON {
          * @param gpu If the system will use gpu.
          * @returns the ParticleSystem created.
          */
-        public static Create(type: string, emitter: AbstractMesh, scene: Nullable<Scene> = Engine.LastCreatedScene, gpu: boolean = false): ParticleSystem {
+        public static Create(type: string, emitter: AbstractMesh,
+                                   scene: Nullable<Scene> = Engine.LastCreatedScene, gpu: boolean = false): Promise<ParticleSystem> {
             
-            Tools.LoadFile(`${this._baseAssetsUrl}/fire.json`, (data, response) => {
-                console.log(data, response);
-            });
-            
-            const typeParsed = this._parseType(type);
-            if (typeParsed === ParticleSystemType.None) {
-                throw new Error("This particle system type doesn't exist.");
-            }
+            return new Promise((resolve, reject) => {
+                const typeParsed = this._parseType(type);
+                if (typeParsed === ParticleSystemType.None) {
+                    throw new Error("This particle system type doesn't exist.");
+                }
 
-            if (scene) {
-                this._scene = scene;
-            } else {
-                throw new Error("A particle system need a scene.");
-            }
+                if (scene) {
+                    this._scene = scene;
+                } else {
+                    throw new Error("A particle system need a scene.");
+                }
 
-            this._emitter = emitter;
+                this._emitter = emitter;
 
-            switch (typeParsed) {
-                case ParticleSystemType.Fire:
-                    return this._createFire();
-                case ParticleSystemType.Smoke:
-                    return this._createSmoke();
-                default:
-                    throw new Error("Not yet implemented.");
-            }
+                Tools.LoadFile(`${this._baseAssetsUrl}/systems/${typeParsed}.json`, (data, response) => {
+                    const newData = JSON.parse(data.toString()) as IParticleSystemData;
+                    return resolve(this._createSystem(newData));
+                });
+
+            });
         }
 
         private static _parseType(type: string): ParticleSystemType {
@@ -81,89 +104,53 @@ module BABYLON {
             }
         }
 
-        private static _createFire(): ParticleSystem {
+        private static _createSystem(data: IParticleSystemData): ParticleSystem {
             // Create a particle system
-            const fireSystem = new ParticleSystem("particles", 2000, this._scene);
+            const fireSystem = new ParticleSystem(data.type, data.capacity, this._scene);
             // Texture of each particle
-            fireSystem.particleTexture = new Texture(`${this._baseAssetsUrl}/textures/flare.png`, this._scene);
+            fireSystem.particleTexture = new Texture(`${this._baseAssetsUrl}/textures/${data.textureFile}`, this._scene);
             // Where the particles come from
             fireSystem.emitter = this._emitter; // the starting object, the emitter
-            fireSystem.minEmitBox = new Vector3(-0.5, 1, -0.5); // Starting all from
-            fireSystem.maxEmitBox = new Vector3(0.5, 1, 0.5); // To...
+            fireSystem.minEmitBox = new Vector3(data.minEmitBox.x, data.minEmitBox.y, data.minEmitBox.z); // Starting all from
+            fireSystem.maxEmitBox = new Vector3(data.maxEmitBox.x, data.maxEmitBox.y, data.maxEmitBox.z); // To...
 
             // Colors of all particles
-            fireSystem.color1 = new Color4(1, 0.5, 0, 1.0);
-            fireSystem.color2 = new Color4(1, 0.5, 0, 1.0);
-            fireSystem.colorDead = new Color4(0, 0, 0, 0.0);
+            fireSystem.color1 = new Color4(data.color1.r, data.color1.g, data.color1.b, data.color1.a);
+            fireSystem.color2 = new Color4(data.color2.r, data.color2.g, data.color2.b, data.color2.a);
+            fireSystem.colorDead = new Color4(data.colorDead.r, data.colorDead.g, data.colorDead.b, data.colorDead.a);
 
             // Size of each particle (random between...
-            fireSystem.minSize = 0.3;
-            fireSystem.maxSize = 1;
+            fireSystem.minSize = data.minSize;
+            fireSystem.maxSize = data.maxSize;
 
             // Life time of each particle (random between...
-            fireSystem.minLifeTime = 0.2;
-            fireSystem.maxLifeTime = 0.4;
+            fireSystem.minLifeTime = data.minLifeTime;
+            fireSystem.maxLifeTime = data.maxLifeTime;
 
             // Emission rate
-            fireSystem.emitRate = 600;
+            fireSystem.emitRate = data.emitRate;
 
             // Blend mode : BLENDMODE_ONEONE, or BLENDMODE_STANDARD
-            fireSystem.blendMode = ParticleSystem.BLENDMODE_ONEONE;
+            fireSystem.blendMode = data.blendMode;
 
             // Set the gravity of all particles
-            fireSystem.gravity = new Vector3(0, 0, 0);
+            fireSystem.gravity = new Vector3(data.gravity.x, data.gravity.y, data.gravity.z);
 
             // Direction of each particle after it has been emitted
-            fireSystem.direction1 = new Vector3(0, 4, 0);
-            fireSystem.direction2 = new Vector3(0, 4, 0);
+            fireSystem.direction1 = new Vector3(data.direction1.x, data.direction1.y, data.direction1.z);
+            fireSystem.direction2 = new Vector3(data.direction2.x, data.direction2.y, data.direction2.z);
 
             // Angular speed, in radians
-            fireSystem.minAngularSpeed = 0;
-            fireSystem.maxAngularSpeed = Math.PI;
+            fireSystem.minAngularSpeed = data.minAngularSpeed;
+            fireSystem.maxAngularSpeed = data.maxAngularSpeed;
 
             // Speed
-            fireSystem.minEmitPower = 1;
-            fireSystem.maxEmitPower = 3;
-            fireSystem.updateSpeed = 0.007;
+            fireSystem.minEmitPower = data.minEmitPower;
+            fireSystem.maxEmitPower = data.maxEmitPower;
+            fireSystem.updateSpeed = data.updateSpeed;
 
             return fireSystem;
         }
-
-        private static _createSmoke(): ParticleSystem {
-            const smokeSystem = new ParticleSystem("smoke", 1000, this._scene);
-            smokeSystem.particleTexture = new Texture(`${this._baseAssetsUrl}/textures/flare.png`, this._scene);
-            smokeSystem.emitter = this._emitter;
-            smokeSystem.minEmitBox = new Vector3(-0.5, 1, -0.5);
-            smokeSystem.maxEmitBox = new Vector3(0.5, 1, 0.5);
-            
-            smokeSystem.color1 = new Color4(0.1, 0.1, 0.1, 1.0);
-            smokeSystem.color2 = new Color4(0.1, 0.1, 0.1, 1.0);
-            smokeSystem.colorDead = new Color4(0, 0, 0, 0.0);
-            
-            smokeSystem.minSize = 0.3;
-            smokeSystem.maxSize = 1;
-
-            smokeSystem.minLifeTime = 0.3;
-            smokeSystem.maxLifeTime = 1.5;
-
-            smokeSystem.emitRate = 350;
-
-            smokeSystem.blendMode = ParticleSystem.BLENDMODE_ONEONE;
-
-            smokeSystem.gravity = new Vector3(0, 0, 0);
-
-            smokeSystem.direction1 = new Vector3(-1.5, 8, -1.5);
-            smokeSystem.direction2 = new Vector3(1.5, 8, 1.5);
-
-            smokeSystem.minAngularSpeed = 0;
-            smokeSystem.maxAngularSpeed = Math.PI;
-
-            smokeSystem.minEmitPower = 0.5;
-            smokeSystem.maxEmitPower = 1.5;
-            smokeSystem.updateSpeed = 0.005;
-
-            return smokeSystem;
-        }
     }
 
 }