Merge pull request #716 from jbousquie/fix.CreateXXX.optionable

Fix.create xxx.optionable

src/Mesh/babylon.geometry.ts

@@ -580,7 +580,7 @@
             }
 
             public _regenerateVertexData(): VertexData {
-                return VertexData.CreateBox(this.size, this.side);
+                return VertexData.CreateBox({size: this.size, sideOrientation: this.side});
             }
 
             public copy(id: string): Geometry {
@@ -603,7 +603,7 @@
             }
 
             public _regenerateVertexData(): VertexData {
-                return VertexData.CreateSphere(this.segments, this.diameter, this.side);
+                return VertexData.CreateSphere({segments: this.segments, diameter: this.diameter, sideOrientation: this.side});
             }
 
             public copy(id: string): Geometry {
@@ -657,7 +657,7 @@
             }
 
             public _regenerateVertexData(): VertexData {
-                return VertexData.CreateTorus(this.diameter, this.thickness, this.tessellation, this.side);
+                return VertexData.CreateTorus({diameter: this.diameter, thickness: this.thickness, tessellation: this.tessellation, sideOrientation: this.side});
             }
 
             public copy(id: string): Geometry {
@@ -680,7 +680,7 @@
             }
 
             public _regenerateVertexData(): VertexData {
-                return VertexData.CreateGround(this.width, this.height, this.subdivisions);
+                return VertexData.CreateGround({width: this.width, height: this.height, subdivisions: this.subdivisions});
             }
 
             public copy(id: string): Geometry {
@@ -730,7 +730,7 @@
             }
 
             public _regenerateVertexData(): VertexData {
-                return VertexData.CreatePlane(this.size, this.side);
+                return VertexData.CreatePlane({size: this.size, sideOrientation: this.side});
             }
 
             public copy(id: string): Geometry {
@@ -761,7 +761,7 @@
             }
 
             public _regenerateVertexData(): VertexData {
-                return VertexData.CreateTorusKnot(this.radius, this.tube, this.radialSegments, this.tubularSegments, this.p, this.q, this.side);
+                return VertexData.CreateTorusKnot({radius: this.radius, tube: this.tube, radialSegments: this.radialSegments, tubularSegments: this.tubularSegments, p: this.p, q: this.q, sideOrientation: this.side});
             }
 
             public copy(id: string): Geometry {

src/Mesh/babylon.mesh.ts

@@ -1363,9 +1363,16 @@
         public static CreateBox(name: string, options: any, scene: Scene, updatable?: boolean, sideOrientation: number = Mesh.DEFAULTSIDE): Mesh {
             // Check parameters
             updatable = updatable || options.updatable;
-
+            if (typeof options === 'number') {
+                var size = options;
+                options = {
+                    size: size,
+                    sideOrientation: sideOrientation
+                };
+            }
+            
             var box = new Mesh(name, scene);
-            var vertexData = VertexData.CreateBox(options, sideOrientation);
+            var vertexData = VertexData.CreateBox(options);
 
             vertexData.applyToMesh(box, updatable);
 
@@ -1373,7 +1380,7 @@
         }
 
         public static CreateSphere(name: string, segments: number, diameter: number, scene?: Scene, updatable?: boolean, sideOrientation?: number): Mesh;
-        public static CreateSphere(name: string, options: { segments?: number, diameterX?: number, diameterY?: number, diameterZ?: number, sideOrientation?: number, updatable?: boolean }, scene: any): Mesh;
+        public static CreateSphere(name: string, options: { segments?: number, diameter?: number, diameterX?: number, diameterY?: number, diameterZ?: number, sideOrientation?: number, updatable?: boolean }, scene: any): Mesh;
         public static CreateSphere(name: string, options: any, diameterOrScene: any, scene?: Scene, updatable?: boolean, sideOrientation: number = Mesh.DEFAULTSIDE): Mesh {
             if (diameterOrScene instanceof Scene) {
                 scene = diameterOrScene;
@@ -1435,18 +1442,49 @@
         }
 
         // Torus  (Code from SharpDX.org)
-        public static CreateTorus(name: string, diameter: number, thickness: number, tessellation: number, scene: Scene, updatable?: boolean, sideOrientation: number = Mesh.DEFAULTSIDE): Mesh {
+        public static CreateTorus(name: string, diameter: number, thickness: number, tessellation: number, scene: Scene, updatable?: boolean, sideOrientation?: number): Mesh;
+        public static CreateTorus(name: string, options: { diameter?: number, thickness?: number, tessellation?: number, updatable?: boolean, sideOrientation?: number}, scene: any): Mesh;
+        public static CreateTorus(name: string, options: any, thicknessOrScene: any, tessellation?: number, scene?: Scene, updatable?: boolean, sideOrientation?: number): Mesh {
+            if (thicknessOrScene instanceof Scene) {
+                scene = thicknessOrScene;
+                updatable = options.updatable;
+            } else {
+                var diameter = options;
+                options = {
+                    diameter: diameter,
+                    thickness: thicknessOrScene,
+                    tessellation: tessellation,
+                    sideOrientation: sideOrientation
+                }
+            }
             var torus = new Mesh(name, scene);
-            var vertexData = VertexData.CreateTorus(diameter, thickness, tessellation, sideOrientation);
+            var vertexData = VertexData.CreateTorus(options);
 
             vertexData.applyToMesh(torus, updatable);
 
             return torus;
         }
 
-        public static CreateTorusKnot(name: string, radius: number, tube: number, radialSegments: number, tubularSegments: number, p: number, q: number, scene: Scene, updatable?: boolean, sideOrientation: number = Mesh.DEFAULTSIDE): Mesh {
+        public static CreateTorusKnot(name: string, radius: number, tube: number, radialSegments: number, tubularSegments: number, p: number, q: number, scene: Scene, updatable?: boolean, sideOrientation?: number): Mesh;
+        public static CreateTorusKnot(name: string, options: { radius?: number, tube?: number, radialSegments?: number, tubularSegments?: number, p?: number, q?: number, updatable?: boolean, sideOrientation?: number }, scene: any): Mesh;
+        public static CreateTorusKnot(name: string, options: any, tubeOrScene: any, radialSegments?: number, tubularSegments?: number, p?: number, q?: number, scene?: Scene, updatable?: boolean, sideOrientation?: number): Mesh {
+            if (tubeOrScene instanceof Scene) {
+                scene = tubeOrScene;
+                updatable = options.updatable;
+            } else {
+                var radius = options;
+                options = {
+                    radius: radius,
+                    tube: tubeOrScene,
+                    radialSegments: radialSegments,
+                    tubularSegments: tubularSegments,
+                    p: p,
+                    q: q,
+                    sideOrientation: sideOrientation
+                }
+            }
             var torusKnot = new Mesh(name, scene);
-            var vertexData = VertexData.CreateTorusKnot(radius, tube, radialSegments, tubularSegments, p, q, sideOrientation);
+            var vertexData = VertexData.CreateTorusKnot(options);
 
             vertexData.applyToMesh(torusKnot, updatable);
 
@@ -1665,11 +1703,20 @@
 
         // Plane & ground
         public static CreatePlane(name: string, size: number, scene: Scene, updatable?: boolean, sideOrientation?: number): Mesh;
-        public static CreatePlane(name: string, options: { width?: number, height?: number, sideOrientation?: number, updatable?: boolean }, scene: Scene): Mesh;
+        public static CreatePlane(name: string, options: { size?: number, width?: number, height?: number, sideOrientation?: number, updatable?: boolean }, scene: Scene): Mesh;
         public static CreatePlane(name: string, options: any, scene: Scene, updatable?: boolean, sideOrientation: number = Mesh.DEFAULTSIDE): Mesh {
+            if (typeof options === 'number') {
+                var size = options;
+                options = {
+                    size: size,
+                    width: size,
+                    height: size,
+                    sideOrientation: sideOrientation
+                }
+            }
             var plane = new Mesh(name, scene);
 
-            var vertexData = VertexData.CreatePlane(options, sideOrientation);
+            var vertexData = VertexData.CreatePlane(options);
 
             vertexData.applyToMesh(plane, updatable || options.updatable);
 
@@ -1677,7 +1724,7 @@
         }
 
         public static CreateGround(name: string, width: number, height: number, subdivisions: number, scene: Scene, updatable?: boolean): Mesh;
-        public static CreateGround(name: string, options: { width?: number, height?: number, subdivisions?: number, sideOrientation?: number, updatable?: boolean }, scene: any): Mesh;
+        public static CreateGround(name: string, options: { width?: number, height?: number, subdivisions?: number, updatable?: boolean }, scene: any): Mesh;
         public static CreateGround(name: string, options: any, heightOrScene: any, subdivisions?: number, scene?: Scene, updatable?: boolean): Mesh {
             if (heightOrScene instanceof Scene) {
                 scene = heightOrScene;

src/Mesh/babylon.mesh.vertexData.ts

@@ -576,9 +576,7 @@
             return vertexData;
         }
 
-        public static CreateBox(options: { width?: number, height?: number, depth?: number, faceUV?: Vector4[], faceColors?: Color4[], sideOrientation?: number }): VertexData;
-        public static CreateBox(size: number, sideOrientation?: number): VertexData;
-        public static CreateBox(options: any, sideOrientation: number = Mesh.DEFAULTSIDE): VertexData {
+        public static CreateBox(options: { size?: number, width?: number, height?: number, depth?: number, faceUV?: Vector4[], faceColors?: Color4[], sideOrientation?: number }): VertexData {
             var normalsSource = [
                 new Vector3(0, 0, 1),
                 new Vector3(0, 0, -1),
@@ -593,29 +591,18 @@
             var normals = [];
             var uvs = [];
 
-            var width = 1;
-            var height = 1;
-            var depth = 1;
+            var width = options.width || options.size || 1;
+            var height = options.height || options.size || 1;
+            var depth = options.depth || options.size || 1;
+            var sideOrientation = (options.sideOrientation === 0) ? 0 : options.sideOrientation || Mesh.DEFAULTSIDE;
             var faceUV: Vector4[] = options.faceUV || new Array<Vector4>(6);
             var faceColors: Color4[];
             var colors = [];
-
             if (options.faceColors) {
                 faceColors = options.faceColors;
             }
 
-            if (options.width !== undefined) {
-                width = options.width || 1;
-                height = options.height || 1;
-                depth = options.depth || 1;
-            } else { // back-compat with size parameter
-                width = options || 1;
-                height = options || 1;
-                depth = options || 1;
-            }
-
-            sideOrientation = sideOrientation || options.sideOrientation || Mesh.DEFAULTSIDE;
-
+            // default face colors and UV if undefined
             for (var f = 0; f < 6; f++) {
                 if (faceUV[f] === undefined) {
                     faceUV[f] = new Vector4(0, 0, 1, 1);
@@ -697,27 +684,13 @@
 
             return vertexData;
         }
-        public static CreateSphere(options: { segments?: number, diameterX?: number, diameterY?: number, diameterZ?: number, sideOrientation?: number }): VertexData;
-        public static CreateSphere(segments: number, diameter?: number, sideOrientation?: number): VertexData;
-        public static CreateSphere(options: any, diameter?: number, sideOrientation: number = Mesh.DEFAULTSIDE): VertexData {
-            var segments: number;
-            var diameterX: number;
-            var diameterY: number;
-            var diameterZ: number;
-
-            if (options.segments) {
-                segments = options.segments || 32;
-                diameterX = options.diameterX || 1;
-                diameterY = options.diameterY || 1;
-                diameterZ = options.diameterZ || 1;
-            } else { // Back-compat
-                segments = options || 32;
-                diameterX = diameter || 1;
-                diameterY = diameterX;
-                diameterZ = diameterX;
-            }
-
-            sideOrientation = sideOrientation || options.sideOrientation || Mesh.DEFAULTSIDE;
+
+        public static CreateSphere(options: { segments?: number, diameter?: number, diameterX?: number, diameterY?: number, diameterZ?: number, sideOrientation?: number }): VertexData {
+            var segments: number = options.segments || 32;
+            var diameterX: number = options.diameterX || options.diameter || 1;
+            var diameterY: number = options.diameterY || options.diameter || 1;
+            var diameterZ: number = options.diameterZ || options.diameter || 1;
+            var sideOrientation = (options.sideOrientation === 0) ? 0 : options.sideOrientation || Mesh.DEFAULTSIDE;
 
             var radius = new Vector3(diameterX / 2, diameterY / 2, diameterZ / 2);
 
@@ -781,7 +754,7 @@
 
         // Cylinder and cone 
         public static CreateCylinder(options: { height?: number, diameterTop?: number, diameterBottom?: number, tessellation?: number, subdivisions?: number, sideOrientation?: number }): VertexData {
-            var height: number = options.height || 3;
+            var height: number = options.height || 2;
             var diameterTop: number = (options.diameterTop === 0) ? 0 : options.diameterTop || 1;
             var diameterBottom: number = options.diameterBottom || 1;
             var tessellation:number =  options.tessellation || 24;
@@ -896,15 +869,16 @@
             return vertexData;
         }
 
-        public static CreateTorus(diameter, thickness, tessellation, sideOrientation: number = Mesh.DEFAULTSIDE) {
+        public static CreateTorus(options: { diameter?: number, thickness?: number, tessellation?: number, sideOrientation?: number }) {
             var indices = [];
             var positions = [];
             var normals = [];
             var uvs = [];
 
-            diameter = diameter || 1;
-            thickness = thickness || 0.5;
-            tessellation = tessellation || 16;
+            var diameter = options.diameter || 1;
+            var thickness = options.thickness || 0.5;
+            var tessellation = options.tessellation || 16;
+            var sideOrientation = (options.sideOrientation === 0) ? 0 : options.sideOrientation || Mesh.DEFAULTSIDE;
 
             var stride = tessellation + 1;
 
@@ -1028,26 +1002,16 @@
             return vertexData;
         }
 
-        public static CreateGround(options: { width?: number, height?: number, subdivisions?: number, sideOrientation?: number }): VertexData;
-        public static CreateGround(width: number, height: number, subdivisions?: number): VertexData;
-        public static CreateGround(options: any, height?: number, subdivisions?: number): VertexData {
+        public static CreateGround(options: { width?: number, height?: number, subdivisions?: number }): VertexData {
             var indices = [];
             var positions = [];
             var normals = [];
             var uvs = [];
             var row: number, col: number;
 
-            var width: number;
-
-            if (options.width) {
-                width = options.width || 1;
-                height = options.height || 1;
-                subdivisions = options.subdivisions || 1;
-            } else {
-                width = options || 1;
-                height = height || 1;
-                subdivisions = subdivisions || 1;
-            }
+            var width: number = options.width || 1;
+            var height: number = options.height || 1;
+            var subdivisions: number = options.subdivisions || 1;
 
             for (row = 0; row <= subdivisions; row++) {
                 for (col = 0; col <= subdivisions; col++) {
@@ -1218,25 +1182,16 @@
 
             return vertexData;
         }
-        public static CreatePlane(options: { width?: number, height?: number, sideOrientation?: number }): VertexData;
-        public static CreatePlane(size: number, sideOrientation?: number): VertexData;
-        public static CreatePlane(options: any, sideOrientation: number = Mesh.DEFAULTSIDE): VertexData {
+
+        public static CreatePlane(options: { size?: number, width?: number, height?: number, sideOrientation?: number }): VertexData {
             var indices = [];
             var positions = [];
             var normals = [];
             var uvs = [];
 
-            var width: number;
-            var height: number;
-
-            if (options.width) {
-                width = options.width || 1;
-                height = options.height || 1;
-                sideOrientation = options.sideOrientation || Mesh.DEFAULTSIDE;
-            } else {
-                width = options || 1;
-                height = options || 1;
-            }
+            var width: number = options.width || options.size || 1;
+            var height: number = options.height || options.size || 1;
+            var sideOrientation = (options.sideOrientation === 0) ? 0 : options.sideOrientation || Mesh.DEFAULTSIDE;
 
             // Vertices
             var halfWidth = width / 2.0;
@@ -1324,18 +1279,19 @@
         }
 
         // based on http://code.google.com/p/away3d/source/browse/trunk/fp10/Away3D/src/away3d/primitives/TorusKnot.as?spec=svn2473&r=2473
-        public static CreateTorusKnot(radius: number, tube: number, radialSegments: number, tubularSegments: number, p: number, q: number, sideOrientation: number = Mesh.DEFAULTSIDE): VertexData {
+        public static CreateTorusKnot(options: { radius?: number, tube?: number, radialSegments?: number, tubularSegments?: number, p?: number, q?: number, sideOrientation?: number }): VertexData {
             var indices = [];
             var positions = [];
             var normals = [];
             var uvs = [];
 
-            radius = radius || 2;
-            tube = tube || 0.5;
-            radialSegments = radialSegments || 32;
-            tubularSegments = tubularSegments || 32;
-            p = p || 2;
-            q = q || 3;
+            var radius = options.radius || 2;
+            var tube = options.tube || 0.5;
+            var radialSegments = options.radialSegments || 32;
+            var tubularSegments = options.tubularSegments || 32;
+            var p = options.p || 2;
+            var q = options.q || 3;
+            var sideOrientation = (options.sideOrientation === 0) ? 0 : options.sideOrientation || Mesh.DEFAULTSIDE;
 
             // Helper
             var getPos = (angle) => {