Adding new "options" parameter to CreateSphere

dist/preview release - beta/babylon.2.2.d.ts

@@ -2153,62 +2153,6 @@ declare module BABYLON {
 }
 
 declare module BABYLON {
-    class DebugLayer {
-        private _scene;
-        private _camera;
-        private _transformationMatrix;
-        private _enabled;
-        private _labelsEnabled;
-        private _displayStatistics;
-        private _displayTree;
-        private _displayLogs;
-        private _globalDiv;
-        private _statsDiv;
-        private _statsSubsetDiv;
-        private _optionsDiv;
-        private _optionsSubsetDiv;
-        private _logDiv;
-        private _logSubsetDiv;
-        private _treeDiv;
-        private _treeSubsetDiv;
-        private _drawingCanvas;
-        private _drawingContext;
-        private _syncPositions;
-        private _syncData;
-        private _syncUI;
-        private _onCanvasClick;
-        private _clickPosition;
-        private _ratio;
-        private _identityMatrix;
-        private _showUI;
-        private _needToRefreshMeshesTree;
-        shouldDisplayLabel: (node: Node) => boolean;
-        shouldDisplayAxis: (mesh: Mesh) => boolean;
-        axisRatio: number;
-        accentColor: string;
-        customStatsFunction: () => string;
-        constructor(scene: Scene);
-        private _refreshMeshesTreeContent();
-        private _renderSingleAxis(zero, unit, unitText, label, color);
-        private _renderAxis(projectedPosition, mesh, globalViewport);
-        private _renderLabel(text, projectedPosition, labelOffset, onClick, getFillStyle);
-        private _isClickInsideRect(x, y, width, height);
-        isVisible(): boolean;
-        hide(): void;
-        show(showUI?: boolean, camera?: Camera): void;
-        private _clearLabels();
-        private _generateheader(root, text);
-        private _generateTexBox(root, title, color);
-        private _generateAdvancedCheckBox(root, leftTitle, rightTitle, initialState, task, tag?);
-        private _generateCheckBox(root, title, initialState, task, tag?);
-        private _generateButton(root, title, task, tag?);
-        private _generateRadio(root, title, name, initialState, task, tag?);
-        private _generateDOMelements();
-        private _displayStats();
-    }
-}
-
-declare module BABYLON {
     class BoundingBox {
         minimum: Vector3;
         maximum: Vector3;
@@ -2269,6 +2213,62 @@ declare module BABYLON {
 }
 
 declare module BABYLON {
+    class DebugLayer {
+        private _scene;
+        private _camera;
+        private _transformationMatrix;
+        private _enabled;
+        private _labelsEnabled;
+        private _displayStatistics;
+        private _displayTree;
+        private _displayLogs;
+        private _globalDiv;
+        private _statsDiv;
+        private _statsSubsetDiv;
+        private _optionsDiv;
+        private _optionsSubsetDiv;
+        private _logDiv;
+        private _logSubsetDiv;
+        private _treeDiv;
+        private _treeSubsetDiv;
+        private _drawingCanvas;
+        private _drawingContext;
+        private _syncPositions;
+        private _syncData;
+        private _syncUI;
+        private _onCanvasClick;
+        private _clickPosition;
+        private _ratio;
+        private _identityMatrix;
+        private _showUI;
+        private _needToRefreshMeshesTree;
+        shouldDisplayLabel: (node: Node) => boolean;
+        shouldDisplayAxis: (mesh: Mesh) => boolean;
+        axisRatio: number;
+        accentColor: string;
+        customStatsFunction: () => string;
+        constructor(scene: Scene);
+        private _refreshMeshesTreeContent();
+        private _renderSingleAxis(zero, unit, unitText, label, color);
+        private _renderAxis(projectedPosition, mesh, globalViewport);
+        private _renderLabel(text, projectedPosition, labelOffset, onClick, getFillStyle);
+        private _isClickInsideRect(x, y, width, height);
+        isVisible(): boolean;
+        hide(): void;
+        show(showUI?: boolean, camera?: Camera): void;
+        private _clearLabels();
+        private _generateheader(root, text);
+        private _generateTexBox(root, title, color);
+        private _generateAdvancedCheckBox(root, leftTitle, rightTitle, initialState, task, tag?);
+        private _generateCheckBox(root, title, initialState, task, tag?);
+        private _generateButton(root, title, task, tag?);
+        private _generateRadio(root, title, name, initialState, task, tag?);
+        private _generateDOMelements();
+        private _displayStats();
+    }
+}
+
+declare module BABYLON {
     class Layer {
         name: string;
         texture: Texture;
@@ -2433,38 +2433,6 @@ declare module BABYLON {
 }
 
 declare module BABYLON {
-    interface ISceneLoaderPlugin {
-        extensions: string;
-        importMesh: (meshesNames: any, scene: Scene, data: any, rootUrl: string, meshes: AbstractMesh[], particleSystems: ParticleSystem[], skeletons: Skeleton[]) => boolean;
-        load: (scene: Scene, data: string, rootUrl: string) => boolean;
-    }
-    class SceneLoader {
-        private static _ForceFullSceneLoadingForIncremental;
-        private static _ShowLoadingScreen;
-        static ForceFullSceneLoadingForIncremental: boolean;
-        static ShowLoadingScreen: boolean;
-        private static _registeredPlugins;
-        private static _getPluginForFilename(sceneFilename);
-        static RegisterPlugin(plugin: ISceneLoaderPlugin): void;
-        static ImportMesh(meshesNames: any, rootUrl: string, sceneFilename: string, scene: Scene, onsuccess?: (meshes: AbstractMesh[], particleSystems: ParticleSystem[], skeletons: Skeleton[]) => void, progressCallBack?: () => void, onerror?: (scene: Scene, e: any) => void): void;
-        /**
-        * Load a scene
-        * @param rootUrl a string that defines the root url for scene and resources
-        * @param sceneFilename a string that defines the name of the scene file. can start with "data:" following by the stringified version of the scene
-        * @param engine is the instance of BABYLON.Engine to use to create the scene
-        */
-        static Load(rootUrl: string, sceneFilename: any, engine: Engine, onsuccess?: (scene: Scene) => void, progressCallBack?: any, onerror?: (scene: Scene) => void): void;
-        /**
-        * Append a scene
-        * @param rootUrl a string that defines the root url for scene and resources
-        * @param sceneFilename a string that defines the name of the scene file. can start with "data:" following by the stringified version of the scene
-        * @param scene is the instance of BABYLON.Scene to append to
-        */
-        static Append(rootUrl: string, sceneFilename: any, scene: Scene, onsuccess?: (scene: Scene) => void, progressCallBack?: any, onerror?: (scene: Scene) => void): void;
-    }
-}
-
-declare module BABYLON {
     class EffectFallbacks {
         private _defines;
         private _currentRank;
@@ -2692,6 +2660,38 @@ declare module BABYLON {
 }
 
 declare module BABYLON {
+    interface ISceneLoaderPlugin {
+        extensions: string;
+        importMesh: (meshesNames: any, scene: Scene, data: any, rootUrl: string, meshes: AbstractMesh[], particleSystems: ParticleSystem[], skeletons: Skeleton[]) => boolean;
+        load: (scene: Scene, data: string, rootUrl: string) => boolean;
+    }
+    class SceneLoader {
+        private static _ForceFullSceneLoadingForIncremental;
+        private static _ShowLoadingScreen;
+        static ForceFullSceneLoadingForIncremental: boolean;
+        static ShowLoadingScreen: boolean;
+        private static _registeredPlugins;
+        private static _getPluginForFilename(sceneFilename);
+        static RegisterPlugin(plugin: ISceneLoaderPlugin): void;
+        static ImportMesh(meshesNames: any, rootUrl: string, sceneFilename: string, scene: Scene, onsuccess?: (meshes: AbstractMesh[], particleSystems: ParticleSystem[], skeletons: Skeleton[]) => void, progressCallBack?: () => void, onerror?: (scene: Scene, e: any) => void): void;
+        /**
+        * Load a scene
+        * @param rootUrl a string that defines the root url for scene and resources
+        * @param sceneFilename a string that defines the name of the scene file. can start with "data:" following by the stringified version of the scene
+        * @param engine is the instance of BABYLON.Engine to use to create the scene
+        */
+        static Load(rootUrl: string, sceneFilename: any, engine: Engine, onsuccess?: (scene: Scene) => void, progressCallBack?: any, onerror?: (scene: Scene) => void): void;
+        /**
+        * Append a scene
+        * @param rootUrl a string that defines the root url for scene and resources
+        * @param sceneFilename a string that defines the name of the scene file. can start with "data:" following by the stringified version of the scene
+        * @param scene is the instance of BABYLON.Scene to append to
+        */
+        static Append(rootUrl: string, sceneFilename: any, scene: Scene, onsuccess?: (scene: Scene) => void, progressCallBack?: any, onerror?: (scene: Scene) => void): void;
+    }
+}
+
+declare module BABYLON {
     class Color3 {
         r: number;
         g: number;
@@ -3883,7 +3883,7 @@ declare module BABYLON {
         static CreateRibbon(name: string, pathArray: Vector3[][], closeArray: boolean, closePath: boolean, offset: number, scene: Scene, updatable?: boolean, sideOrientation?: number, ribbonInstance?: Mesh): Mesh;
         static CreateDisc(name: string, radius: number, tessellation: number, scene: Scene, updatable?: boolean, sideOrientation?: number): Mesh;
         static CreateBox(name: string, options: any, scene: Scene, updatable?: boolean, sideOrientation?: number): Mesh;
-        static CreateSphere(name: string, segments: number, diameter: number, scene: Scene, updatable?: boolean, sideOrientation?: number): Mesh;
+        static CreateSphere(name: string, options: any, diameterOrScene: any, scene?: Scene, updatable?: boolean, sideOrientation?: number): Mesh;
         static CreateCylinder(name: string, height: number, diameterTop: number, diameterBottom: number, tessellation: number, subdivisions: any, scene: Scene, updatable?: any, sideOrientation?: number): Mesh;
         static CreateTorus(name: string, diameter: number, thickness: number, tessellation: number, scene: Scene, updatable?: boolean, sideOrientation?: number): Mesh;
         static CreateTorusKnot(name: string, radius: number, tube: number, radialSegments: number, tubularSegments: number, p: number, q: number, scene: Scene, updatable?: boolean, sideOrientation?: number): Mesh;
@@ -3964,7 +3964,7 @@ declare module BABYLON {
         private static _ExtractFrom(meshOrGeometry, copyWhenShared?);
         static CreateRibbon(pathArray: Vector3[][], closeArray: boolean, closePath: boolean, offset: number, sideOrientation?: number): VertexData;
         static CreateBox(options: any, sideOrientation?: number): VertexData;
-        static CreateSphere(segments: number, diameter: number, sideOrientation?: number): VertexData;
+        static CreateSphere(options: any, diameter?: number, sideOrientation?: number): VertexData;
         static CreateCylinder(height: number, diameterTop: number, diameterBottom: number, tessellation: number, subdivisions?: number, sideOrientation?: number): VertexData;
         static CreateTorus(diameter: any, thickness: any, tessellation: any, sideOrientation?: number): VertexData;
         static CreateLines(points: Vector3[]): VertexData;
@@ -4277,6 +4277,165 @@ declare module BABYLON {
 }
 
 declare module BABYLON {
+    class BoundingBoxRenderer {
+        frontColor: Color3;
+        backColor: Color3;
+        showBackLines: boolean;
+        renderList: SmartArray<BoundingBox>;
+        private _scene;
+        private _colorShader;
+        private _vb;
+        private _ib;
+        constructor(scene: Scene);
+        private _prepareRessources();
+        reset(): void;
+        render(): void;
+        dispose(): void;
+    }
+}
+
+declare module BABYLON {
+    class DepthRenderer {
+        private _scene;
+        private _depthMap;
+        private _effect;
+        private _viewMatrix;
+        private _projectionMatrix;
+        private _transformMatrix;
+        private _worldViewProjection;
+        private _cachedDefines;
+        constructor(scene: Scene, type?: number);
+        isReady(subMesh: SubMesh, useInstances: boolean): boolean;
+        getDepthMap(): RenderTargetTexture;
+        dispose(): void;
+    }
+}
+
+declare module BABYLON {
+    class EdgesRenderer {
+        private _source;
+        private _linesPositions;
+        private _linesNormals;
+        private _linesIndices;
+        private _epsilon;
+        private _indicesCount;
+        private _lineShader;
+        private _vb0;
+        private _vb1;
+        private _ib;
+        private _buffers;
+        private _checkVerticesInsteadOfIndices;
+        constructor(source: AbstractMesh, epsilon?: number, checkVerticesInsteadOfIndices?: boolean);
+        private _prepareRessources();
+        dispose(): void;
+        private _processEdgeForAdjacencies(pa, pb, p0, p1, p2);
+        private _processEdgeForAdjacenciesWithVertices(pa, pb, p0, p1, p2);
+        private _checkEdge(faceIndex, edge, faceNormals, p0, p1);
+        _generateEdgesLines(): void;
+        render(): void;
+    }
+}
+
+declare module BABYLON {
+    class OutlineRenderer {
+        private _scene;
+        private _effect;
+        private _cachedDefines;
+        constructor(scene: Scene);
+        render(subMesh: SubMesh, batch: _InstancesBatch, useOverlay?: boolean): void;
+        isReady(subMesh: SubMesh, useInstances: boolean): boolean;
+    }
+}
+
+declare module BABYLON {
+    class RenderingGroup {
+        index: number;
+        private _scene;
+        private _opaqueSubMeshes;
+        private _transparentSubMeshes;
+        private _alphaTestSubMeshes;
+        private _activeVertices;
+        constructor(index: number, scene: Scene);
+        render(customRenderFunction: (opaqueSubMeshes: SmartArray<SubMesh>, transparentSubMeshes: SmartArray<SubMesh>, alphaTestSubMeshes: SmartArray<SubMesh>) => void): boolean;
+        prepare(): void;
+        dispatch(subMesh: SubMesh): void;
+    }
+}
+
+declare module BABYLON {
+    class RenderingManager {
+        static MAX_RENDERINGGROUPS: number;
+        private _scene;
+        private _renderingGroups;
+        private _depthBufferAlreadyCleaned;
+        constructor(scene: Scene);
+        private _renderParticles(index, activeMeshes);
+        private _renderSprites(index);
+        private _clearDepthBuffer();
+        render(customRenderFunction: (opaqueSubMeshes: SmartArray<SubMesh>, transparentSubMeshes: SmartArray<SubMesh>, alphaTestSubMeshes: SmartArray<SubMesh>) => void, activeMeshes: AbstractMesh[], renderParticles: boolean, renderSprites: boolean): void;
+        reset(): void;
+        dispatch(subMesh: SubMesh): void;
+    }
+}
+
+declare module BABYLON {
+    class Sprite {
+        name: string;
+        position: Vector3;
+        color: Color4;
+        width: number;
+        height: number;
+        angle: number;
+        cellIndex: number;
+        invertU: number;
+        invertV: number;
+        disposeWhenFinishedAnimating: boolean;
+        animations: Animation[];
+        private _animationStarted;
+        private _loopAnimation;
+        private _fromIndex;
+        private _toIndex;
+        private _delay;
+        private _direction;
+        private _frameCount;
+        private _manager;
+        private _time;
+        size: number;
+        constructor(name: string, manager: SpriteManager);
+        playAnimation(from: number, to: number, loop: boolean, delay: number): void;
+        stopAnimation(): void;
+        _animate(deltaTime: number): void;
+        dispose(): void;
+    }
+}
+
+declare module BABYLON {
+    class SpriteManager {
+        name: string;
+        cellSize: number;
+        sprites: Sprite[];
+        renderingGroupId: number;
+        onDispose: () => void;
+        fogEnabled: boolean;
+        private _capacity;
+        private _spriteTexture;
+        private _epsilon;
+        private _scene;
+        private _vertexDeclaration;
+        private _vertexStrideSize;
+        private _vertexBuffer;
+        private _indexBuffer;
+        private _vertices;
+        private _effectBase;
+        private _effectFog;
+        constructor(name: string, imgUrl: string, capacity: number, cellSize: number, scene: Scene, epsilon?: number, samplingMode?: number);
+        private _appendSpriteVertex(index, sprite, offsetX, offsetY, rowSize);
+        render(): void;
+        dispose(): void;
+    }
+}
+
+declare module BABYLON {
     class AnaglyphPostProcess extends PostProcess {
         constructor(name: string, ratio: number, camera: Camera, samplingMode?: number, engine?: Engine, reusable?: boolean);
     }
@@ -4815,165 +4974,6 @@ declare module BABYLON {
     }
 }
 
-declare module BABYLON {
-    class BoundingBoxRenderer {
-        frontColor: Color3;
-        backColor: Color3;
-        showBackLines: boolean;
-        renderList: SmartArray<BoundingBox>;
-        private _scene;
-        private _colorShader;
-        private _vb;
-        private _ib;
-        constructor(scene: Scene);
-        private _prepareRessources();
-        reset(): void;
-        render(): void;
-        dispose(): void;
-    }
-}
-
-declare module BABYLON {
-    class DepthRenderer {
-        private _scene;
-        private _depthMap;
-        private _effect;
-        private _viewMatrix;
-        private _projectionMatrix;
-        private _transformMatrix;
-        private _worldViewProjection;
-        private _cachedDefines;
-        constructor(scene: Scene, type?: number);
-        isReady(subMesh: SubMesh, useInstances: boolean): boolean;
-        getDepthMap(): RenderTargetTexture;
-        dispose(): void;
-    }
-}
-
-declare module BABYLON {
-    class EdgesRenderer {
-        private _source;
-        private _linesPositions;
-        private _linesNormals;
-        private _linesIndices;
-        private _epsilon;
-        private _indicesCount;
-        private _lineShader;
-        private _vb0;
-        private _vb1;
-        private _ib;
-        private _buffers;
-        private _checkVerticesInsteadOfIndices;
-        constructor(source: AbstractMesh, epsilon?: number, checkVerticesInsteadOfIndices?: boolean);
-        private _prepareRessources();
-        dispose(): void;
-        private _processEdgeForAdjacencies(pa, pb, p0, p1, p2);
-        private _processEdgeForAdjacenciesWithVertices(pa, pb, p0, p1, p2);
-        private _checkEdge(faceIndex, edge, faceNormals, p0, p1);
-        _generateEdgesLines(): void;
-        render(): void;
-    }
-}
-
-declare module BABYLON {
-    class OutlineRenderer {
-        private _scene;
-        private _effect;
-        private _cachedDefines;
-        constructor(scene: Scene);
-        render(subMesh: SubMesh, batch: _InstancesBatch, useOverlay?: boolean): void;
-        isReady(subMesh: SubMesh, useInstances: boolean): boolean;
-    }
-}
-
-declare module BABYLON {
-    class RenderingGroup {
-        index: number;
-        private _scene;
-        private _opaqueSubMeshes;
-        private _transparentSubMeshes;
-        private _alphaTestSubMeshes;
-        private _activeVertices;
-        constructor(index: number, scene: Scene);
-        render(customRenderFunction: (opaqueSubMeshes: SmartArray<SubMesh>, transparentSubMeshes: SmartArray<SubMesh>, alphaTestSubMeshes: SmartArray<SubMesh>) => void): boolean;
-        prepare(): void;
-        dispatch(subMesh: SubMesh): void;
-    }
-}
-
-declare module BABYLON {
-    class RenderingManager {
-        static MAX_RENDERINGGROUPS: number;
-        private _scene;
-        private _renderingGroups;
-        private _depthBufferAlreadyCleaned;
-        constructor(scene: Scene);
-        private _renderParticles(index, activeMeshes);
-        private _renderSprites(index);
-        private _clearDepthBuffer();
-        render(customRenderFunction: (opaqueSubMeshes: SmartArray<SubMesh>, transparentSubMeshes: SmartArray<SubMesh>, alphaTestSubMeshes: SmartArray<SubMesh>) => void, activeMeshes: AbstractMesh[], renderParticles: boolean, renderSprites: boolean): void;
-        reset(): void;
-        dispatch(subMesh: SubMesh): void;
-    }
-}
-
-declare module BABYLON {
-    class Sprite {
-        name: string;
-        position: Vector3;
-        color: Color4;
-        width: number;
-        height: number;
-        angle: number;
-        cellIndex: number;
-        invertU: number;
-        invertV: number;
-        disposeWhenFinishedAnimating: boolean;
-        animations: Animation[];
-        private _animationStarted;
-        private _loopAnimation;
-        private _fromIndex;
-        private _toIndex;
-        private _delay;
-        private _direction;
-        private _frameCount;
-        private _manager;
-        private _time;
-        size: number;
-        constructor(name: string, manager: SpriteManager);
-        playAnimation(from: number, to: number, loop: boolean, delay: number): void;
-        stopAnimation(): void;
-        _animate(deltaTime: number): void;
-        dispose(): void;
-    }
-}
-
-declare module BABYLON {
-    class SpriteManager {
-        name: string;
-        cellSize: number;
-        sprites: Sprite[];
-        renderingGroupId: number;
-        onDispose: () => void;
-        fogEnabled: boolean;
-        private _capacity;
-        private _spriteTexture;
-        private _epsilon;
-        private _scene;
-        private _vertexDeclaration;
-        private _vertexStrideSize;
-        private _vertexBuffer;
-        private _indexBuffer;
-        private _vertices;
-        private _effectBase;
-        private _effectFog;
-        constructor(name: string, imgUrl: string, capacity: number, cellSize: number, scene: Scene, epsilon?: number, samplingMode?: number);
-        private _appendSpriteVertex(index, sprite, offsetX, offsetY, rowSize);
-        render(): void;
-        dispose(): void;
-    }
-}
-
 declare module BABYLON.Internals {
     class AndOrNotEvaluator {
         static Eval(query: string, evaluateCallback: (val: any) => boolean): boolean;
@@ -5745,9 +5745,6 @@ declare module BABYLON {
     }
 }
 
-declare module BABYLON.Internals {
-}
-
 declare module BABYLON {
     class BaseTexture {
         name: string;
@@ -5935,6 +5932,9 @@ declare module BABYLON {
     }
 }
 
+declare module BABYLON.Internals {
+}
+
 declare module BABYLON {
     class CannonJSPlugin implements IPhysicsEnginePlugin {
         checkWithEpsilon: (value: number) => number;

dist/preview release - beta/babylon.2.2.max.js

@@ -15762,10 +15762,24 @@ var BABYLON;
             vertexData.applyToMesh(box, updatable);
             return box;
         };
-        Mesh.CreateSphere = function (name, segments, diameter, scene, updatable, sideOrientation) {
+        Mesh.CreateSphere = function (name, options, diameterOrScene, scene, updatable, sideOrientation) {
             if (sideOrientation === void 0) { sideOrientation = Mesh.DEFAULTSIDE; }
+            if (diameterOrScene instanceof BABYLON.Scene) {
+                scene = diameterOrScene;
+                updatable = options.updatable;
+            }
+            else {
+                var segments = options;
+                options = {
+                    segments: segments,
+                    diameterX: diameterOrScene,
+                    diameterY: diameterOrScene,
+                    diameterZ: diameterOrScene,
+                    sideOrientation: sideOrientation
+                };
+            }
             var sphere = new Mesh(name, scene);
-            var vertexData = BABYLON.VertexData.CreateSphere(segments, diameter, sideOrientation);
+            var vertexData = BABYLON.VertexData.CreateSphere(options);
             vertexData.applyToMesh(sphere, updatable);
             return sphere;
         };
@@ -26237,9 +26251,10 @@ var BABYLON;
         };
         VertexData.prototype.transform = function (matrix) {
             var transformed = BABYLON.Vector3.Zero();
+            var index;
             if (this.positions) {
                 var position = BABYLON.Vector3.Zero();
-                for (var index = 0; index < this.positions.length; index += 3) {
+                for (index = 0; index < this.positions.length; index += 3) {
                     BABYLON.Vector3.FromArrayToRef(this.positions, index, position);
                     BABYLON.Vector3.TransformCoordinatesToRef(position, matrix, transformed);
                     this.positions[index] = transformed.x;
@@ -26259,12 +26274,13 @@ var BABYLON;
             }
         };
         VertexData.prototype.merge = function (other) {
+            var index;
             if (other.indices) {
                 if (!this.indices) {
                     this.indices = [];
                 }
                 var offset = this.positions ? this.positions.length / 3 : 0;
-                for (var index = 0; index < other.indices.length; index++) {
+                for (index = 0; index < other.indices.length; index++) {
                     this.indices.push(other.indices[index] + offset);
                 }
             }
@@ -26439,6 +26455,8 @@ var BABYLON;
             var path;
             var l;
             minlg = pathArray[0].length;
+            var vectlg;
+            var dist;
             for (p = 0; p < pathArray.length; p++) {
                 uTotalDistance[p] = 0;
                 us[p] = [0];
@@ -26449,8 +26467,8 @@ var BABYLON;
                 while (j < l) {
                     positions.push(path[j].x, path[j].y, path[j].z);
                     if (j > 0) {
-                        var vectlg = path[j].subtract(path[j - 1]).length();
-                        var dist = vectlg + uTotalDistance[p];
+                        vectlg = path[j].subtract(path[j - 1]).length();
+                        dist = vectlg + uTotalDistance[p];
                         us[p].push(dist);
                         uTotalDistance[p] = dist;
                     }
@@ -26643,11 +26661,26 @@ var BABYLON;
             vertexData.uvs = uvs;
             return vertexData;
         };
-        VertexData.CreateSphere = function (segments, diameter, sideOrientation) {
+        VertexData.CreateSphere = function (options, diameter, sideOrientation) {
             if (sideOrientation === void 0) { sideOrientation = BABYLON.Mesh.DEFAULTSIDE; }
-            segments = segments || 32;
-            diameter = diameter || 1;
-            var radius = diameter / 2;
+            var segments;
+            var diameterX;
+            var diameterY;
+            var diameterZ;
+            if (options.segments) {
+                segments = options.segments || 32;
+                diameterX = options.diameterX || 1;
+                diameterY = options.diameterY || 1;
+                diameterZ = options.diameterZ || 1;
+            }
+            else {
+                segments = options || 32;
+                diameterX = diameter || 1;
+                diameterY = diameterX;
+                diameterZ = diameterX;
+            }
+            sideOrientation = sideOrientation || options.sideOrientation;
+            var radius = new BABYLON.Vector3(diameterX / 2, diameterY / 2, diameterZ / 2);
             var totalZRotationSteps = 2 + segments;
             var totalYRotationSteps = 2 * totalZRotationSteps;
             var indices = [];
@@ -26664,7 +26697,7 @@ var BABYLON;
                     var rotationY = BABYLON.Matrix.RotationY(angleY);
                     var afterRotZ = BABYLON.Vector3.TransformCoordinates(BABYLON.Vector3.Up(), rotationZ);
                     var complete = BABYLON.Vector3.TransformCoordinates(afterRotZ, rotationY);
-                    var vertex = complete.scale(radius);
+                    var vertex = complete.multiply(radius);
                     var normal = BABYLON.Vector3.Normalize(vertex);
                     positions.push(vertex.x, vertex.y, vertex.z);
                     normals.push(normal.x, normal.y, normal.z);
@@ -26702,17 +26735,18 @@ var BABYLON;
             var uvs = [];
             var angle_step = Math.PI * 2 / tessellation;
             var angle;
-            var subdivision_step = height / subdivisions;
             var h;
             var radius;
             var tan = (diameterBottom - diameterTop) / 2 / height;
             var ringVertex = BABYLON.Vector3.Zero();
             var ringNormal = BABYLON.Vector3.Zero();
             // positions, normals, uvs
-            for (var i = 0; i <= subdivisions; i++) {
+            var i;
+            var j;
+            for (i = 0; i <= subdivisions; i++) {
                 h = i / subdivisions;
                 radius = (h * (diameterTop - diameterBottom) + diameterBottom) / 2;
-                for (var j = 0; j <= tessellation; j++) {
+                for (j = 0; j <= tessellation; j++) {
                     angle = j * angle_step;
                     ringVertex.x = Math.cos(-angle) * radius;
                     ringVertex.y = -height / 2 + h * height;
@@ -26735,8 +26769,8 @@ var BABYLON;
                 }
             }
             // indices
-            for (var i = 0; i < subdivisions; i++) {
-                for (var j = 0; j < tessellation; j++) {
+            for (i = 0; i < subdivisions; i++) {
+                for (j = 0; j < tessellation; j++) {
                     var i0 = i * (tessellation + 1) + j;
                     var i1 = (i + 1) * (tessellation + 1) + j;
                     var i2 = i * (tessellation + 1) + (j + 1);
@@ -26757,7 +26791,8 @@ var BABYLON;
                 // Cap positions, normals & uvs
                 var angle;
                 var circleVector;
-                for (var i = 0; i < tessellation; i++) {
+                var i;
+                for (i = 0; i < tessellation; i++) {
                     angle = Math.PI * 2 * i / tessellation;
                     circleVector = new BABYLON.Vector3(Math.cos(-angle), 0, Math.sin(-angle));
                     var position = circleVector.scale(radius).add(offset);
@@ -27138,7 +27173,9 @@ var BABYLON;
                 return new BABYLON.Vector3(tx, ty, tz);
             };
             // Vertices
-            for (var i = 0; i <= radialSegments; i++) {
+            var i;
+            var j;
+            for (i = 0; i <= radialSegments; i++) {
                 var modI = i % radialSegments;
                 var u = modI / radialSegments * 2 * p * Math.PI;
                 var p1 = getPos(u);
@@ -27149,7 +27186,7 @@ var BABYLON;
                 n = BABYLON.Vector3.Cross(bitan, tang);
                 bitan.normalize();
                 n.normalize();
-                for (var j = 0; j < tubularSegments; j++) {
+                for (j = 0; j < tubularSegments; j++) {
                     var modJ = j % tubularSegments;
                     var v = modJ / tubularSegments * 2 * Math.PI;
                     var cx = -tube * Math.cos(v);

dist/preview release - beta/what's new.md

@@ -9,6 +9,7 @@
     - OBJ loader. See [demo here](http://www.babylonjs-playground.com/#28YUR5) [Temechon](https://github.com/Temechon)
     - EdgesRenderer. See [demo here](http://www.babylonjs-playground.com/#TYAHX#10) [deltakosh](https://github.com/deltakosh)
   - **Updates**
+    - New options parameters for Box and Sphere. See [demo here](http://www.html5gamedevs.com/topic/17044-evolution-for-out-of-the-box-meshes-creation/) [deltakosh](https://github.com/deltakosh)
     - Added darkness support for soft shadows [deltakosh](https://github.com/deltakosh)
     - Added scene.getLensFlareSystemByName() [deltakosh](https://github.com/deltakosh)
     - Added LensFlareSystem.setEmitter() [deltakosh](https://github.com/deltakosh)

src/Mesh/babylon.mesh.js

@@ -1148,10 +1148,24 @@ var BABYLON;
             vertexData.applyToMesh(box, updatable);
             return box;
         };
-        Mesh.CreateSphere = function (name, segments, diameter, scene, updatable, sideOrientation) {
+        Mesh.CreateSphere = function (name, options, diameterOrScene, scene, updatable, sideOrientation) {
             if (sideOrientation === void 0) { sideOrientation = Mesh.DEFAULTSIDE; }
+            if (diameterOrScene instanceof BABYLON.Scene) {
+                scene = diameterOrScene;
+                updatable = options.updatable;
+            }
+            else {
+                var segments = options;
+                options = {
+                    segments: segments,
+                    diameterX: diameterOrScene,
+                    diameterY: diameterOrScene,
+                    diameterZ: diameterOrScene,
+                    sideOrientation: sideOrientation
+                };
+            }
             var sphere = new Mesh(name, scene);
-            var vertexData = BABYLON.VertexData.CreateSphere(segments, diameter, sideOrientation);
+            var vertexData = BABYLON.VertexData.CreateSphere(options);
             vertexData.applyToMesh(sphere, updatable);
             return sphere;
         };

src/Mesh/babylon.mesh.ts

@@ -1343,9 +1343,24 @@
             return box;
         }
 
-        public static CreateSphere(name: string, segments: number, diameter: number, scene: Scene, updatable?: boolean, sideOrientation: number = Mesh.DEFAULTSIDE): 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;
+                updatable = options.updatable;
+            } else {
+                var segments = options;
+
+                options = {
+                    segments: segments,
+                    diameterX: diameterOrScene,
+                    diameterY: diameterOrScene,
+                    diameterZ: diameterOrScene,
+                    sideOrientation: sideOrientation
+                }
+            }
+
             var sphere = new Mesh(name, scene);
-            var vertexData = VertexData.CreateSphere(segments, diameter, sideOrientation);
+            var vertexData = VertexData.CreateSphere(options);
 
             vertexData.applyToMesh(sphere, updatable);
 

src/Mesh/babylon.mesh.vertexData.js

@@ -130,9 +130,10 @@ var BABYLON;
         };
         VertexData.prototype.transform = function (matrix) {
             var transformed = BABYLON.Vector3.Zero();
+            var index;
             if (this.positions) {
                 var position = BABYLON.Vector3.Zero();
-                for (var index = 0; index < this.positions.length; index += 3) {
+                for (index = 0; index < this.positions.length; index += 3) {
                     BABYLON.Vector3.FromArrayToRef(this.positions, index, position);
                     BABYLON.Vector3.TransformCoordinatesToRef(position, matrix, transformed);
                     this.positions[index] = transformed.x;
@@ -152,12 +153,13 @@ var BABYLON;
             }
         };
         VertexData.prototype.merge = function (other) {
+            var index;
             if (other.indices) {
                 if (!this.indices) {
                     this.indices = [];
                 }
                 var offset = this.positions ? this.positions.length / 3 : 0;
-                for (var index = 0; index < other.indices.length; index++) {
+                for (index = 0; index < other.indices.length; index++) {
                     this.indices.push(other.indices[index] + offset);
                 }
             }
@@ -332,6 +334,8 @@ var BABYLON;
             var path;
             var l;
             minlg = pathArray[0].length;
+            var vectlg;
+            var dist;
             for (p = 0; p < pathArray.length; p++) {
                 uTotalDistance[p] = 0;
                 us[p] = [0];
@@ -342,8 +346,8 @@ var BABYLON;
                 while (j < l) {
                     positions.push(path[j].x, path[j].y, path[j].z);
                     if (j > 0) {
-                        var vectlg = path[j].subtract(path[j - 1]).length();
-                        var dist = vectlg + uTotalDistance[p];
+                        vectlg = path[j].subtract(path[j - 1]).length();
+                        dist = vectlg + uTotalDistance[p];
                         us[p].push(dist);
                         uTotalDistance[p] = dist;
                     }
@@ -536,11 +540,26 @@ var BABYLON;
             vertexData.uvs = uvs;
             return vertexData;
         };
-        VertexData.CreateSphere = function (segments, diameter, sideOrientation) {
+        VertexData.CreateSphere = function (options, diameter, sideOrientation) {
             if (sideOrientation === void 0) { sideOrientation = BABYLON.Mesh.DEFAULTSIDE; }
-            segments = segments || 32;
-            diameter = diameter || 1;
-            var radius = diameter / 2;
+            var segments;
+            var diameterX;
+            var diameterY;
+            var diameterZ;
+            if (options.segments) {
+                segments = options.segments || 32;
+                diameterX = options.diameterX || 1;
+                diameterY = options.diameterY || 1;
+                diameterZ = options.diameterZ || 1;
+            }
+            else {
+                segments = options || 32;
+                diameterX = diameter || 1;
+                diameterY = diameterX;
+                diameterZ = diameterX;
+            }
+            sideOrientation = sideOrientation || options.sideOrientation;
+            var radius = new BABYLON.Vector3(diameterX / 2, diameterY / 2, diameterZ / 2);
             var totalZRotationSteps = 2 + segments;
             var totalYRotationSteps = 2 * totalZRotationSteps;
             var indices = [];
@@ -557,7 +576,7 @@ var BABYLON;
                     var rotationY = BABYLON.Matrix.RotationY(angleY);
                     var afterRotZ = BABYLON.Vector3.TransformCoordinates(BABYLON.Vector3.Up(), rotationZ);
                     var complete = BABYLON.Vector3.TransformCoordinates(afterRotZ, rotationY);
-                    var vertex = complete.scale(radius);
+                    var vertex = complete.multiply(radius);
                     var normal = BABYLON.Vector3.Normalize(vertex);
                     positions.push(vertex.x, vertex.y, vertex.z);
                     normals.push(normal.x, normal.y, normal.z);
@@ -595,17 +614,18 @@ var BABYLON;
             var uvs = [];
             var angle_step = Math.PI * 2 / tessellation;
             var angle;
-            var subdivision_step = height / subdivisions;
             var h;
             var radius;
             var tan = (diameterBottom - diameterTop) / 2 / height;
             var ringVertex = BABYLON.Vector3.Zero();
             var ringNormal = BABYLON.Vector3.Zero();
             // positions, normals, uvs
-            for (var i = 0; i <= subdivisions; i++) {
+            var i;
+            var j;
+            for (i = 0; i <= subdivisions; i++) {
                 h = i / subdivisions;
                 radius = (h * (diameterTop - diameterBottom) + diameterBottom) / 2;
-                for (var j = 0; j <= tessellation; j++) {
+                for (j = 0; j <= tessellation; j++) {
                     angle = j * angle_step;
                     ringVertex.x = Math.cos(-angle) * radius;
                     ringVertex.y = -height / 2 + h * height;
@@ -628,8 +648,8 @@ var BABYLON;
                 }
             }
             // indices
-            for (var i = 0; i < subdivisions; i++) {
-                for (var j = 0; j < tessellation; j++) {
+            for (i = 0; i < subdivisions; i++) {
+                for (j = 0; j < tessellation; j++) {
                     var i0 = i * (tessellation + 1) + j;
                     var i1 = (i + 1) * (tessellation + 1) + j;
                     var i2 = i * (tessellation + 1) + (j + 1);
@@ -650,7 +670,8 @@ var BABYLON;
                 // Cap positions, normals & uvs
                 var angle;
                 var circleVector;
-                for (var i = 0; i < tessellation; i++) {
+                var i;
+                for (i = 0; i < tessellation; i++) {
                     angle = Math.PI * 2 * i / tessellation;
                     circleVector = new BABYLON.Vector3(Math.cos(-angle), 0, Math.sin(-angle));
                     var position = circleVector.scale(radius).add(offset);
@@ -1031,7 +1052,9 @@ var BABYLON;
                 return new BABYLON.Vector3(tx, ty, tz);
             };
             // Vertices
-            for (var i = 0; i <= radialSegments; i++) {
+            var i;
+            var j;
+            for (i = 0; i <= radialSegments; i++) {
                 var modI = i % radialSegments;
                 var u = modI / radialSegments * 2 * p * Math.PI;
                 var p1 = getPos(u);
@@ -1042,7 +1065,7 @@ var BABYLON;
                 n = BABYLON.Vector3.Cross(bitan, tang);
                 bitan.normalize();
                 n.normalize();
-                for (var j = 0; j < tubularSegments; j++) {
+                for (j = 0; j < tubularSegments; j++) {
                     var modJ = j % tubularSegments;
                     var v = modJ / tubularSegments * 2 * Math.PI;
                     var cx = -tube * Math.cos(v);

src/Mesh/babylon.mesh.vertexData.ts

@@ -178,11 +178,11 @@
 
         public transform(matrix: Matrix): void {
             var transformed = Vector3.Zero();
-
+            var index: number;
             if (this.positions) {
                 var position = Vector3.Zero();
 
-                for (var index = 0; index < this.positions.length; index += 3) {
+                for (index = 0; index < this.positions.length; index += 3) {
                     Vector3.FromArrayToRef(this.positions, index, position);
 
                     Vector3.TransformCoordinatesToRef(position, matrix, transformed);
@@ -207,13 +207,14 @@
         }
 
         public merge(other: VertexData): void {
+            var index: number;
             if (other.indices) {
                 if (!this.indices) {
                     this.indices = [];
                 }
 
                 var offset = this.positions ? this.positions.length / 3 : 0;
-                for (var index = 0; index < other.indices.length; index++) {
+                for (index = 0; index < other.indices.length; index++) {
                     this.indices.push(other.indices[index] + offset);
                 }
             }
@@ -420,7 +421,8 @@
             var path: Vector3[];
             var l: number;
             minlg = pathArray[0].length;
-
+            var vectlg: number;
+            var dist: number;
             for (p = 0; p < pathArray.length; p++) {
                 uTotalDistance[p] = 0;
                 us[p] = [0];
@@ -432,8 +434,8 @@
                 while (j < l) {
                     positions.push(path[j].x, path[j].y, path[j].z);
                     if (j > 0) {
-                        var vectlg: number = path[j].subtract(path[j - 1]).length();
-                        var dist: number = vectlg + uTotalDistance[p];
+                        vectlg = path[j].subtract(path[j - 1]).length();
+                        dist = vectlg + uTotalDistance[p];
                         us[p].push(dist);
                         uTotalDistance[p] = dist;
                     }
@@ -657,12 +659,27 @@
             return vertexData;
         }
 
-        public static CreateSphere(segments: number, diameter: number, sideOrientation: number = Mesh.DEFAULTSIDE): 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;
 
-            segments = segments || 32;
-            diameter = diameter || 1;
+            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;
 
-            var radius = diameter / 2;
+            var radius = new Vector3(diameterX / 2, diameterY / 2, diameterZ / 2);
 
             var totalZRotationSteps = 2 + segments;
             var totalYRotationSteps = 2 * totalZRotationSteps;
@@ -686,7 +703,7 @@
                     var afterRotZ = Vector3.TransformCoordinates(Vector3.Up(), rotationZ);
                     var complete = Vector3.TransformCoordinates(afterRotZ, rotationY);
 
-                    var vertex = complete.scale(radius);
+                    var vertex = complete.multiply(radius);
                     var normal = Vector3.Normalize(vertex);
 
                     positions.push(vertex.x, vertex.y, vertex.z);
@@ -732,7 +749,6 @@
 
             var angle_step = Math.PI * 2 / tessellation;
             var angle: number;
-            var subdivision_step = height / subdivisions;
             var h: number;
             var radius: number;
             var tan = (diameterBottom - diameterTop) / 2 / height;
@@ -740,10 +756,12 @@
             var ringNormal: Vector3 = Vector3.Zero();
 
             // positions, normals, uvs
-            for (var i = 0; i <= subdivisions; i++) {
+            var i: number;
+            var j: number;
+            for (i = 0; i <= subdivisions; i++) {
                 h = i / subdivisions;
                 radius = (h * (diameterTop - diameterBottom) + diameterBottom) / 2;
-                for (var j = 0; j <= tessellation; j++) {
+                for (j = 0; j <= tessellation; j++) {
                     angle = j * angle_step;
                     ringVertex.x = Math.cos(-angle) * radius;
                     ringVertex.y = -height / 2 + h * height;
@@ -756,7 +774,7 @@
                     }
                     else {
                         ringNormal.x = ringVertex.x;
-                        ringNormal.z = ringVertex.z
+                        ringNormal.z = ringVertex.z;
                         ringNormal.y = Math.sqrt(ringNormal.x * ringNormal.x + ringNormal.z * ringNormal.z) * tan;
                         ringNormal.normalize();
                     }
@@ -767,8 +785,8 @@
             }
 
             // indices
-            for (var i = 0; i < subdivisions; i++) {
-                for (var j = 0; j < tessellation; j++) {
+            for (i = 0; i < subdivisions; i++) {
+                for (j = 0; j < tessellation; j++) {
                     var i0 = i * (tessellation + 1) + j;
                     var i1 = (i + 1) * (tessellation + 1) + j;
                     var i2 = i * (tessellation + 1) + (j + 1);
@@ -779,7 +797,7 @@
             }
 
             // Caps
-            var createCylinderCap = function (isTop) {
+            var createCylinderCap = isTop => {
                 var radius = isTop ? diameterTop / 2 : diameterBottom / 2;
                 if (radius === 0) {
                     return;
@@ -790,7 +808,8 @@
                 // Cap positions, normals & uvs
                 var angle;
                 var circleVector;
-                for (var i = 0; i < tessellation; i++) {
+                var i: number;
+                for (i = 0; i < tessellation; i++) {
                     angle = Math.PI * 2 * i / tessellation;
                     circleVector = new Vector3(Math.cos(-angle), 0, Math.sin(-angle));
                     var position = circleVector.scale(radius).add(offset);
@@ -1265,7 +1284,9 @@
             };
 
             // Vertices
-            for (var i = 0; i <= radialSegments; i++) {
+            var i: number;
+            var j: number;
+            for (i = 0; i <= radialSegments; i++) {
                 var modI = i % radialSegments;
                 var u = modI / radialSegments * 2 * p * Math.PI;
                 var p1 = getPos(u);
@@ -1279,7 +1300,7 @@
                 bitan.normalize();
                 n.normalize();
 
-                for (var j = 0; j < tubularSegments; j++) {
+                for (j = 0; j < tubularSegments; j++) {
                     var modJ = j % tubularSegments;
                     var v = modJ / tubularSegments * 2 * Math.PI;
                     var cx = -tube * Math.cos(v);