首頁 探索 說明
註冊 登入
zhangyupeng
/
Babylon.js
1
0
複刻 0
檔案 問題管理 0 合併請求 0 Wiki
瀏覽代碼

Clean all unwanted merges

David Catuhe 8 年之前
父節點
5a511dd666
當前提交
c3566eeedc
共有 27 個文件被更改，包括 5726 次插入 和 5510 次删除
統一視圖 顯示文件統計
  1. 二進制
      Exporters/3ds Max/Max2Babylon-0.9.0.zip
  2. 4 4
      Exporters/3ds Max/Max2Babylon/Tools/WebServer.cs
  3. 4 4
      Playground/zipContent/index.html
  4. 177 183
      dist/preview release/babylon.d.ts
  5. 24 24
      dist/preview release/babylon.js
  6. 0 19
      dist/preview release/babylon.max.js
  7. 177 183
      dist/preview release/babylon.module.d.ts
  8. 24 24
      dist/preview release/babylon.worker.js
  9. 2490 2475
      dist/preview release/customConfigurations/minimalViewer/babylon.d.ts
  10. 25 25
      dist/preview release/customConfigurations/minimalViewer/babylon.js
  11. 94 44
      dist/preview release/customConfigurations/minimalViewer/babylon.max.js
  12. 2490 2475
      dist/preview release/customConfigurations/minimalViewer/babylon.module.d.ts
  13. 4 0
      dist/preview release/gui/babylon.gui.d.ts
  14. 38 2
      dist/preview release/gui/babylon.gui.js
  15. 2 2
      dist/preview release/gui/babylon.gui.min.js
  16. 6 2
      gui/src/advancedDynamicTexture.ts
  17. 7 0
      gui/src/controls/container.ts
  18. 36 0
      gui/src/controls/control.ts
  19. 41 21
      src/Bones/babylon.bone.ts
  20. 1 1
      src/Collisions/babylon.collider.ts
  21. 35 11
      src/Materials/Textures/babylon.mirrorTexture.ts
  22. 20 5
      src/Materials/Textures/babylon.texture.ts
  23. 19 1
      src/Math/babylon.math.ts
  24. 3 3
      src/Mesh/babylon.abstractMesh.ts
  25. 1 1
      src/Mesh/babylon.meshBuilder.ts
  26. 1 1
      src/Particles/babylon.solidParticle.ts
  27. 3 0
      src/PostProcess/babylon.postProcess.ts

二進制
Exporters/3ds Max/Max2Babylon-0.9.0.zip
查看文件


+ 4 - 4
Exporters/3ds Max/Max2Babylon/Tools/WebServer.cs
查看文件 

@@ -18,10 +18,10 @@ namespace Max2Babylon
 
 

 

 <head>

 <head>

     <title>Babylon.js</title>

     <title>Babylon.js</title>

-    <script type='text/javascript' src='http://www.babylonjs.com/oimo.js'></script>

-    <script type='text/javascript' src='http://www.babylonjs.com/cannon.js'></script>

-    <script type='text/javascript' src='http://www.babylonjs.com/babylon.js'></script>

-    <script type='text/javascript' src='http://www.babylonjs.com/babylon.inspector.bundle.js'></script>

+    <script type='text/javascript' src='https://preview.babylonjs.com/oimo.js'></script>

+    <script type='text/javascript' src='https://preview.babylonjs.com/cannon.js'></script>

+    <script type='text/javascript' src='https://preview.babylonjs.com/babylon.js'></script>

+    <script type='text/javascript' src='https://preview.babylonjs.com/inspector/babylon.inspector.bundle.js'></script>

     <style type='text/css'>

     <style type='text/css'>

         html, body, div, canvas {

         html, body, div, canvas {

             width: 100%;

             width: 100%;

+ 4 - 4
Playground/zipContent/index.html
查看文件 

@@ -5,10 +5,10 @@
 
 

 

         <title>Babylon.js sample code</title>

         <title>Babylon.js sample code</title>

         <!-- Babylon.js -->

         <!-- Babylon.js -->

-        <script src="http://www.babylonjs.com/hand.minified-1.2.js"></script>

-        <script src="http://www.babylonjs.com/cannon.js"></script>

-        <script src="http://www.babylonjs.com/oimo.js"></script>

-        <script src="http://www.babylonjs.com/babylon.js"></script>

+        <script src="https://www.babylonjs.com/hand.minified-1.2.js"></script>

+        <script src="https://preview.babylonjs.com/cannon.js"></script>

+        <script src="https://preview.babylonjs.com/oimo.js"></script>

+        <script src="https://preview.babylonjs.com/babylon.js"></script>

         <style>

         <style>

             html, body {

             html, body {

                 overflow: hidden;

                 overflow: hidden;

+ 177 - 183
dist/preview release/babylon.d.ts
查看文件 

@@ -3779,120 +3779,6 @@ declare module BABYLON {
 
 }
 
 }
 
 
 
 declare module BABYLON {
 
 declare module BABYLON {
 
-    class BoundingBox implements ICullable {
 
-        minimum: Vector3;
 
-        maximum: Vector3;
 
-        vectors: Vector3[];
 
-        center: Vector3;
 
-        centerWorld: Vector3;
 
-        extendSize: Vector3;
 
-        extendSizeWorld: Vector3;
 
-        directions: Vector3[];
 
-        vectorsWorld: Vector3[];
 
-        minimumWorld: Vector3;
 
-        maximumWorld: Vector3;
 
-        private _worldMatrix;
 
-        constructor(minimum: Vector3, maximum: Vector3);
 
-        getWorldMatrix(): Matrix;
 
-        setWorldMatrix(matrix: Matrix): BoundingBox;
 
-        _update(world: Matrix): void;
 
-        isInFrustum(frustumPlanes: Plane[]): boolean;
 
-        isCompletelyInFrustum(frustumPlanes: Plane[]): boolean;
 
-        intersectsPoint(point: Vector3): boolean;
 
-        intersectsSphere(sphere: BoundingSphere): boolean;
 
-        intersectsMinMax(min: Vector3, max: Vector3): boolean;
 
-        static Intersects(box0: BoundingBox, box1: BoundingBox): boolean;
 
-        static IntersectsSphere(minPoint: Vector3, maxPoint: Vector3, sphereCenter: Vector3, sphereRadius: number): boolean;
 
-        static IsCompletelyInFrustum(boundingVectors: Vector3[], frustumPlanes: Plane[]): boolean;
 
-        static IsInFrustum(boundingVectors: Vector3[], frustumPlanes: Plane[]): boolean;
 
-    }
 
-}
 
-
 
-declare module BABYLON {
 
-    interface ICullable {
 
-        isInFrustum(frustumPlanes: Plane[]): boolean;
 
-        isCompletelyInFrustum(frustumPlanes: Plane[]): boolean;
 
-    }
 
-    class BoundingInfo implements ICullable {
 
-        minimum: Vector3;
 
-        maximum: Vector3;
 
-        boundingBox: BoundingBox;
 
-        boundingSphere: BoundingSphere;
 
-        private _isLocked;
 
-        constructor(minimum: Vector3, maximum: Vector3);
 
-        isLocked: boolean;
 
-        update(world: Matrix): void;
 
-        isInFrustum(frustumPlanes: Plane[]): boolean;
 
-        isCompletelyInFrustum(frustumPlanes: Plane[]): boolean;
 
-        _checkCollision(collider: Collider): boolean;
 
-        intersectsPoint(point: Vector3): boolean;
 
-        intersects(boundingInfo: BoundingInfo, precise: boolean): boolean;
 
-    }
 
-}
 
-
 
-declare module BABYLON {
 
-    class BoundingSphere {
 
-        minimum: Vector3;
 
-        maximum: Vector3;
 
-        center: Vector3;
 
-        radius: number;
 
-        centerWorld: Vector3;
 
-        radiusWorld: number;
 
-        private _tempRadiusVector;
 
-        constructor(minimum: Vector3, maximum: Vector3);
 
-        _update(world: Matrix): void;
 
-        isInFrustum(frustumPlanes: Plane[]): boolean;
 
-        intersectsPoint(point: Vector3): boolean;
 
-        static Intersects(sphere0: BoundingSphere, sphere1: BoundingSphere): boolean;
 
-    }
 
-}
 
-
 
-declare module BABYLON {
 
-    class Ray {
 
-        origin: Vector3;
 
-        direction: Vector3;
 
-        length: number;
 
-        private _edge1;
 
-        private _edge2;
 
-        private _pvec;
 
-        private _tvec;
 
-        private _qvec;
 
-        private _tmpRay;
 
-        private _rayHelper;
 
-        constructor(origin: Vector3, direction: Vector3, length?: number);
 
-        intersectsBoxMinMax(minimum: Vector3, maximum: Vector3): boolean;
 
-        intersectsBox(box: BoundingBox): boolean;
 
-        intersectsSphere(sphere: BoundingSphere): boolean;
 
-        intersectsTriangle(vertex0: Vector3, vertex1: Vector3, vertex2: Vector3): IntersectionInfo;
 
-        intersectsPlane(plane: Plane): number;
 
-        intersectsMesh(mesh: AbstractMesh, fastCheck?: boolean): PickingInfo;
 
-        intersectsMeshes(meshes: Array<AbstractMesh>, fastCheck?: boolean, results?: Array<PickingInfo>): Array<PickingInfo>;
 
-        private _comparePickingInfo(pickingInfoA, pickingInfoB);
 
-        private static smallnum;
 
-        private static rayl;
 
-        /**
 
-         * Intersection test between the ray and a given segment whithin a given tolerance (threshold)
 
-         * @param sega the first point of the segment to test the intersection against
 
-         * @param segb the second point of the segment to test the intersection against
 
-         * @param threshold the tolerance margin, if the ray doesn't intersect the segment but is close to the given threshold, the intersection is successful
 
-         * @return the distance from the ray origin to the intersection point if there's intersection, or -1 if there's no intersection
 
-         */
 
-        intersectionSegment(sega: Vector3, segb: Vector3, threshold: number): number;
 
-        static CreateNew(x: number, y: number, viewportWidth: number, viewportHeight: number, world: Matrix, view: Matrix, projection: Matrix): Ray;
 
-        /**
 
-        * Function will create a new transformed ray starting from origin and ending at the end point. Ray's length will be set, and ray will be
 
-        * transformed to the given world matrix.
 
-        * @param origin The origin point
 
-        * @param end The end point
 
-        * @param world a matrix to transform the ray to. Default is the identity matrix.
 
-        */
 
-        static CreateNewFromTo(origin: Vector3, end: Vector3, world?: Matrix): Ray;
 
-        static Transform(ray: Ray, matrix: Matrix): Ray;
 
-        static TransformToRef(ray: Ray, matrix: Matrix, result: Ray): void;
 
-    }
 
-}
 
-
 
-declare module BABYLON {
 
     class Collider {
 
     class Collider {
 
         radius: Vector3;
 
         radius: Vector3;
 
         retry: number;
 
         retry: number;
 
@@ -4135,6 +4021,120 @@ declare module BABYLON {
 
     }
 
     }
 
 }
 
 }
 
 
 
+declare module BABYLON {
 
+    class BoundingBox implements ICullable {
 
+        minimum: Vector3;
 
+        maximum: Vector3;
 
+        vectors: Vector3[];
 
+        center: Vector3;
 
+        centerWorld: Vector3;
 
+        extendSize: Vector3;
 
+        extendSizeWorld: Vector3;
 
+        directions: Vector3[];
 
+        vectorsWorld: Vector3[];
 
+        minimumWorld: Vector3;
 
+        maximumWorld: Vector3;
 
+        private _worldMatrix;
 
+        constructor(minimum: Vector3, maximum: Vector3);
 
+        getWorldMatrix(): Matrix;
 
+        setWorldMatrix(matrix: Matrix): BoundingBox;
 
+        _update(world: Matrix): void;
 
+        isInFrustum(frustumPlanes: Plane[]): boolean;
 
+        isCompletelyInFrustum(frustumPlanes: Plane[]): boolean;
 
+        intersectsPoint(point: Vector3): boolean;
 
+        intersectsSphere(sphere: BoundingSphere): boolean;
 
+        intersectsMinMax(min: Vector3, max: Vector3): boolean;
 
+        static Intersects(box0: BoundingBox, box1: BoundingBox): boolean;
 
+        static IntersectsSphere(minPoint: Vector3, maxPoint: Vector3, sphereCenter: Vector3, sphereRadius: number): boolean;
 
+        static IsCompletelyInFrustum(boundingVectors: Vector3[], frustumPlanes: Plane[]): boolean;
 
+        static IsInFrustum(boundingVectors: Vector3[], frustumPlanes: Plane[]): boolean;
 
+    }
 
+}
 
+
 
+declare module BABYLON {
 
+    interface ICullable {
 
+        isInFrustum(frustumPlanes: Plane[]): boolean;
 
+        isCompletelyInFrustum(frustumPlanes: Plane[]): boolean;
 
+    }
 
+    class BoundingInfo implements ICullable {
 
+        minimum: Vector3;
 
+        maximum: Vector3;
 
+        boundingBox: BoundingBox;
 
+        boundingSphere: BoundingSphere;
 
+        private _isLocked;
 
+        constructor(minimum: Vector3, maximum: Vector3);
 
+        isLocked: boolean;
 
+        update(world: Matrix): void;
 
+        isInFrustum(frustumPlanes: Plane[]): boolean;
 
+        isCompletelyInFrustum(frustumPlanes: Plane[]): boolean;
 
+        _checkCollision(collider: Collider): boolean;
 
+        intersectsPoint(point: Vector3): boolean;
 
+        intersects(boundingInfo: BoundingInfo, precise: boolean): boolean;
 
+    }
 
+}
 
+
 
+declare module BABYLON {
 
+    class BoundingSphere {
 
+        minimum: Vector3;
 
+        maximum: Vector3;
 
+        center: Vector3;
 
+        radius: number;
 
+        centerWorld: Vector3;
 
+        radiusWorld: number;
 
+        private _tempRadiusVector;
 
+        constructor(minimum: Vector3, maximum: Vector3);
 
+        _update(world: Matrix): void;
 
+        isInFrustum(frustumPlanes: Plane[]): boolean;
 
+        intersectsPoint(point: Vector3): boolean;
 
+        static Intersects(sphere0: BoundingSphere, sphere1: BoundingSphere): boolean;
 
+    }
 
+}
 
+
 
+declare module BABYLON {
 
+    class Ray {
 
+        origin: Vector3;
 
+        direction: Vector3;
 
+        length: number;
 
+        private _edge1;
 
+        private _edge2;
 
+        private _pvec;
 
+        private _tvec;
 
+        private _qvec;
 
+        private _tmpRay;
 
+        private _rayHelper;
 
+        constructor(origin: Vector3, direction: Vector3, length?: number);
 
+        intersectsBoxMinMax(minimum: Vector3, maximum: Vector3): boolean;
 
+        intersectsBox(box: BoundingBox): boolean;
 
+        intersectsSphere(sphere: BoundingSphere): boolean;
 
+        intersectsTriangle(vertex0: Vector3, vertex1: Vector3, vertex2: Vector3): IntersectionInfo;
 
+        intersectsPlane(plane: Plane): number;
 
+        intersectsMesh(mesh: AbstractMesh, fastCheck?: boolean): PickingInfo;
 
+        intersectsMeshes(meshes: Array<AbstractMesh>, fastCheck?: boolean, results?: Array<PickingInfo>): Array<PickingInfo>;
 
+        private _comparePickingInfo(pickingInfoA, pickingInfoB);
 
+        private static smallnum;
 
+        private static rayl;
 
+        /**
 
+         * Intersection test between the ray and a given segment whithin a given tolerance (threshold)
 
+         * @param sega the first point of the segment to test the intersection against
 
+         * @param segb the second point of the segment to test the intersection against
 
+         * @param threshold the tolerance margin, if the ray doesn't intersect the segment but is close to the given threshold, the intersection is successful
 
+         * @return the distance from the ray origin to the intersection point if there's intersection, or -1 if there's no intersection
 
+         */
 
+        intersectionSegment(sega: Vector3, segb: Vector3, threshold: number): number;
 
+        static CreateNew(x: number, y: number, viewportWidth: number, viewportHeight: number, world: Matrix, view: Matrix, projection: Matrix): Ray;
 
+        /**
 
+        * Function will create a new transformed ray starting from origin and ending at the end point. Ray's length will be set, and ray will be
 
+        * transformed to the given world matrix.
 
+        * @param origin The origin point
 
+        * @param end The end point
 
+        * @param world a matrix to transform the ray to. Default is the identity matrix.
 
+        */
 
+        static CreateNewFromTo(origin: Vector3, end: Vector3, world?: Matrix): Ray;
 
+        static Transform(ray: Ray, matrix: Matrix): Ray;
 
+        static TransformToRef(ray: Ray, matrix: Matrix, result: Ray): void;
 
+    }
 
+}
 
+
 
 declare module BABYLON.Debug {
 
 declare module BABYLON.Debug {
 
     class AxesViewer {
 
     class AxesViewer {
 
         private _xline;
 
         private _xline;
 
@@ -8209,69 +8209,6 @@ declare module BABYLON {
 
 }
 
 }
 
 
 
 declare module BABYLON {
 
 declare module BABYLON {
 
-    class MorphTarget {
 
-        name: string;
 
-        animations: Animation[];
 
-        private _positions;
 
-        private _normals;
 
-        private _tangents;
 
-        private _influence;
 
-        onInfluenceChanged: Observable<boolean>;
 
-        influence: number;
 
-        constructor(name: string, influence?: number);
 
-        readonly hasNormals: boolean;
 
-        readonly hasTangents: boolean;
 
-        setPositions(data: Float32Array | number[]): void;
 
-        getPositions(): Float32Array;
 
-        setNormals(data: Float32Array | number[]): void;
 
-        getNormals(): Float32Array;
 
-        setTangents(data: Float32Array | number[]): void;
 
-        getTangents(): Float32Array;
 
-        /**
 
-         * Serializes the current target into a Serialization object.
 
-         * Returns the serialized object.
 
-         */
 
-        serialize(): any;
 
-        static Parse(serializationObject: any): MorphTarget;
 
-        static FromMesh(mesh: AbstractMesh, name?: string, influence?: number): MorphTarget;
 
-    }
 
-}
 
-
 
-declare module BABYLON {
 
-    class MorphTargetManager {
 
-        private _targets;
 
-        private _targetObservable;
 
-        private _activeTargets;
 
-        private _scene;
 
-        private _influences;
 
-        private _supportsNormals;
 
-        private _supportsTangents;
 
-        private _vertexCount;
 
-        private _uniqueId;
 
-        constructor(scene?: Scene);
 
-        readonly uniqueId: number;
 
-        readonly vertexCount: number;
 
-        readonly supportsNormals: boolean;
 
-        readonly supportsTangents: boolean;
 
-        readonly numTargets: number;
 
-        readonly numInfluencers: number;
 
-        readonly influences: Float32Array;
 
-        getActiveTarget(index: number): MorphTarget;
 
-        getTarget(index: number): MorphTarget;
 
-        addTarget(target: MorphTarget): void;
 
-        removeTarget(target: MorphTarget): void;
 
-        /**
 
-         * Serializes the current manager into a Serialization object.
 
-         * Returns the serialized object.
 
-         */
 
-        serialize(): any;
 
-        private _onInfluenceChanged(needUpdate);
 
-        private _syncActiveTargets(needUpdate);
 
-        static Parse(serializationObject: any, scene: Scene): MorphTargetManager;
 
-    }
 
-}
 
-
 
-declare module BABYLON {
 
     class AbstractMesh extends Node implements IDisposable, ICullable, IGetSetVerticesData {
 
     class AbstractMesh extends Node implements IDisposable, ICullable, IGetSetVerticesData {
 
         private static _BILLBOARDMODE_NONE;
 
         private static _BILLBOARDMODE_NONE;
 
         private static _BILLBOARDMODE_X;
 
         private static _BILLBOARDMODE_X;
 
@@ -9782,12 +9719,6 @@ declare module BABYLON {
 
          */
 
          */
 
         updateMeshPositions(positionFunction: any, computeNormals?: boolean): Mesh;
 
         updateMeshPositions(positionFunction: any, computeNormals?: boolean): Mesh;
 
         /**
 
         /**
 
-         * This method will force the computation of normals for the mesh.
 
-         * Please note that the mesh must have normals vertex data already.
 
-         * Returns the Mesh.
 
-         */
 
-        recomputeNormals(markDataAsUpdatable?: boolean): Mesh;
 
-        /**
 
          * Creates a un-shared specific occurence of the geometry for the mesh.
 
          * Creates a un-shared specific occurence of the geometry for the mesh.
 
          * Returns the Mesh.
 
          * Returns the Mesh.
 
          */
 
          */
 
@@ -11621,6 +11552,69 @@ declare module BABYLON {
 
 }
 
 }
 
 
 
 declare module BABYLON {
 
 declare module BABYLON {
 
+    class MorphTarget {
 
+        name: string;
 
+        animations: Animation[];
 
+        private _positions;
 
+        private _normals;
 
+        private _tangents;
 
+        private _influence;
 
+        onInfluenceChanged: Observable<boolean>;
 
+        influence: number;
 
+        constructor(name: string, influence?: number);
 
+        readonly hasNormals: boolean;
 
+        readonly hasTangents: boolean;
 
+        setPositions(data: Float32Array | number[]): void;
 
+        getPositions(): Float32Array;
 
+        setNormals(data: Float32Array | number[]): void;
 
+        getNormals(): Float32Array;
 
+        setTangents(data: Float32Array | number[]): void;
 
+        getTangents(): Float32Array;
 
+        /**
 
+         * Serializes the current target into a Serialization object.
 
+         * Returns the serialized object.
 
+         */
 
+        serialize(): any;
 
+        static Parse(serializationObject: any): MorphTarget;
 
+        static FromMesh(mesh: AbstractMesh, name?: string, influence?: number): MorphTarget;
 
+    }
 
+}
 
+
 
+declare module BABYLON {
 
+    class MorphTargetManager {
 
+        private _targets;
 
+        private _targetObservable;
 
+        private _activeTargets;
 
+        private _scene;
 
+        private _influences;
 
+        private _supportsNormals;
 
+        private _supportsTangents;
 
+        private _vertexCount;
 
+        private _uniqueId;
 
+        constructor(scene?: Scene);
 
+        readonly uniqueId: number;
 
+        readonly vertexCount: number;
 
+        readonly supportsNormals: boolean;
 
+        readonly supportsTangents: boolean;
 
+        readonly numTargets: number;
 
+        readonly numInfluencers: number;
 
+        readonly influences: Float32Array;
 
+        getActiveTarget(index: number): MorphTarget;
 
+        getTarget(index: number): MorphTarget;
 
+        addTarget(target: MorphTarget): void;
 
+        removeTarget(target: MorphTarget): void;
 
+        /**
 
+         * Serializes the current manager into a Serialization object.
 
+         * Returns the serialized object.
 
+         */
 
+        serialize(): any;
 
+        private _onInfluenceChanged(needUpdate);
 
+        private _syncActiveTargets(needUpdate);
 
+        static Parse(serializationObject: any, scene: Scene): MorphTargetManager;
 
+    }
 
+}
 
+
 
+declare module BABYLON {
 
     class Particle {
 
     class Particle {
 
         position: Vector3;
 
         position: Vector3;
 
         direction: Vector3;
 
         direction: Vector3;

文件差異過大導致無法顯示
+ 24 - 24
dist/preview release/babylon.js


+ 0 - 19
dist/preview release/babylon.max.js
查看文件 

@@ -20195,25 +20195,6 @@ var BABYLON;
 
             return this;
 
             return this;
 
         };
 
         };
 
         /**
 
         /**
 
-         * This method will force the computation of normals for the mesh.
 
-         * Please note that the mesh must have normals vertex data already.
 
-         * Returns the Mesh.
 
-         */
 
-        Mesh.prototype.recomputeNormals = function (markDataAsUpdatable) {
 
-            var positions = this.getVerticesData(BABYLON.VertexBuffer.PositionKind);
 
-            var indices = this.getIndices();
 
-            var normals;
 
-            if (this.isVerticesDataPresent(BABYLON.VertexBuffer.NormalKind)) {
 
-                normals = this.getVerticesData(BABYLON.VertexBuffer.NormalKind);
 
-            }
 
-            else {
 
-                normals = [];
 
-            }
 
-            BABYLON.VertexData.ComputeNormals(positions, indices, normals);
 
-            this.setVerticesData(BABYLON.VertexBuffer.NormalKind, normals, markDataAsUpdatable);
 
-            return this;
 
-        };
 
-        /**
 
          * Creates a un-shared specific occurence of the geometry for the mesh.
 
          * Creates a un-shared specific occurence of the geometry for the mesh.
 
          * Returns the Mesh.
 
          * Returns the Mesh.
 
          */
 
          */

+ 177 - 183
dist/preview release/babylon.module.d.ts
查看文件 

@@ -3779,120 +3779,6 @@ declare module BABYLON {
 
 }
 
 }
 
 
 
 declare module BABYLON {
 
 declare module BABYLON {
 
-    class BoundingBox implements ICullable {
 
-        minimum: Vector3;
 
-        maximum: Vector3;
 
-        vectors: Vector3[];
 
-        center: Vector3;
 
-        centerWorld: Vector3;
 
-        extendSize: Vector3;
 
-        extendSizeWorld: Vector3;
 
-        directions: Vector3[];
 
-        vectorsWorld: Vector3[];
 
-        minimumWorld: Vector3;
 
-        maximumWorld: Vector3;
 
-        private _worldMatrix;
 
-        constructor(minimum: Vector3, maximum: Vector3);
 
-        getWorldMatrix(): Matrix;
 
-        setWorldMatrix(matrix: Matrix): BoundingBox;
 
-        _update(world: Matrix): void;
 
-        isInFrustum(frustumPlanes: Plane[]): boolean;
 
-        isCompletelyInFrustum(frustumPlanes: Plane[]): boolean;
 
-        intersectsPoint(point: Vector3): boolean;
 
-        intersectsSphere(sphere: BoundingSphere): boolean;
 
-        intersectsMinMax(min: Vector3, max: Vector3): boolean;
 
-        static Intersects(box0: BoundingBox, box1: BoundingBox): boolean;
 
-        static IntersectsSphere(minPoint: Vector3, maxPoint: Vector3, sphereCenter: Vector3, sphereRadius: number): boolean;
 
-        static IsCompletelyInFrustum(boundingVectors: Vector3[], frustumPlanes: Plane[]): boolean;
 
-        static IsInFrustum(boundingVectors: Vector3[], frustumPlanes: Plane[]): boolean;
 
-    }
 
-}
 
-
 
-declare module BABYLON {
 
-    interface ICullable {
 
-        isInFrustum(frustumPlanes: Plane[]): boolean;
 
-        isCompletelyInFrustum(frustumPlanes: Plane[]): boolean;
 
-    }
 
-    class BoundingInfo implements ICullable {
 
-        minimum: Vector3;
 
-        maximum: Vector3;
 
-        boundingBox: BoundingBox;
 
-        boundingSphere: BoundingSphere;
 
-        private _isLocked;
 
-        constructor(minimum: Vector3, maximum: Vector3);
 
-        isLocked: boolean;
 
-        update(world: Matrix): void;
 
-        isInFrustum(frustumPlanes: Plane[]): boolean;
 
-        isCompletelyInFrustum(frustumPlanes: Plane[]): boolean;
 
-        _checkCollision(collider: Collider): boolean;
 
-        intersectsPoint(point: Vector3): boolean;
 
-        intersects(boundingInfo: BoundingInfo, precise: boolean): boolean;
 
-    }
 
-}
 
-
 
-declare module BABYLON {
 
-    class BoundingSphere {
 
-        minimum: Vector3;
 
-        maximum: Vector3;
 
-        center: Vector3;
 
-        radius: number;
 
-        centerWorld: Vector3;
 
-        radiusWorld: number;
 
-        private _tempRadiusVector;
 
-        constructor(minimum: Vector3, maximum: Vector3);
 
-        _update(world: Matrix): void;
 
-        isInFrustum(frustumPlanes: Plane[]): boolean;
 
-        intersectsPoint(point: Vector3): boolean;
 
-        static Intersects(sphere0: BoundingSphere, sphere1: BoundingSphere): boolean;
 
-    }
 
-}
 
-
 
-declare module BABYLON {
 
-    class Ray {
 
-        origin: Vector3;
 
-        direction: Vector3;
 
-        length: number;
 
-        private _edge1;
 
-        private _edge2;
 
-        private _pvec;
 
-        private _tvec;
 
-        private _qvec;
 
-        private _tmpRay;
 
-        private _rayHelper;
 
-        constructor(origin: Vector3, direction: Vector3, length?: number);
 
-        intersectsBoxMinMax(minimum: Vector3, maximum: Vector3): boolean;
 
-        intersectsBox(box: BoundingBox): boolean;
 
-        intersectsSphere(sphere: BoundingSphere): boolean;
 
-        intersectsTriangle(vertex0: Vector3, vertex1: Vector3, vertex2: Vector3): IntersectionInfo;
 
-        intersectsPlane(plane: Plane): number;
 
-        intersectsMesh(mesh: AbstractMesh, fastCheck?: boolean): PickingInfo;
 
-        intersectsMeshes(meshes: Array<AbstractMesh>, fastCheck?: boolean, results?: Array<PickingInfo>): Array<PickingInfo>;
 
-        private _comparePickingInfo(pickingInfoA, pickingInfoB);
 
-        private static smallnum;
 
-        private static rayl;
 
-        /**
 
-         * Intersection test between the ray and a given segment whithin a given tolerance (threshold)
 
-         * @param sega the first point of the segment to test the intersection against
 
-         * @param segb the second point of the segment to test the intersection against
 
-         * @param threshold the tolerance margin, if the ray doesn't intersect the segment but is close to the given threshold, the intersection is successful
 
-         * @return the distance from the ray origin to the intersection point if there's intersection, or -1 if there's no intersection
 
-         */
 
-        intersectionSegment(sega: Vector3, segb: Vector3, threshold: number): number;
 
-        static CreateNew(x: number, y: number, viewportWidth: number, viewportHeight: number, world: Matrix, view: Matrix, projection: Matrix): Ray;
 
-        /**
 
-        * Function will create a new transformed ray starting from origin and ending at the end point. Ray's length will be set, and ray will be
 
-        * transformed to the given world matrix.
 
-        * @param origin The origin point
 
-        * @param end The end point
 
-        * @param world a matrix to transform the ray to. Default is the identity matrix.
 
-        */
 
-        static CreateNewFromTo(origin: Vector3, end: Vector3, world?: Matrix): Ray;
 
-        static Transform(ray: Ray, matrix: Matrix): Ray;
 
-        static TransformToRef(ray: Ray, matrix: Matrix, result: Ray): void;
 
-    }
 
-}
 
-
 
-declare module BABYLON {
 
     class Collider {
 
     class Collider {
 
         radius: Vector3;
 
         radius: Vector3;
 
         retry: number;
 
         retry: number;
 
@@ -4135,6 +4021,120 @@ declare module BABYLON {
 
     }
 
     }
 
 }
 
 }
 
 
 
+declare module BABYLON {
 
+    class BoundingBox implements ICullable {
 
+        minimum: Vector3;
 
+        maximum: Vector3;
 
+        vectors: Vector3[];
 
+        center: Vector3;
 
+        centerWorld: Vector3;
 
+        extendSize: Vector3;
 
+        extendSizeWorld: Vector3;
 
+        directions: Vector3[];
 
+        vectorsWorld: Vector3[];
 
+        minimumWorld: Vector3;
 
+        maximumWorld: Vector3;
 
+        private _worldMatrix;
 
+        constructor(minimum: Vector3, maximum: Vector3);
 
+        getWorldMatrix(): Matrix;
 
+        setWorldMatrix(matrix: Matrix): BoundingBox;
 
+        _update(world: Matrix): void;
 
+        isInFrustum(frustumPlanes: Plane[]): boolean;
 
+        isCompletelyInFrustum(frustumPlanes: Plane[]): boolean;
 
+        intersectsPoint(point: Vector3): boolean;
 
+        intersectsSphere(sphere: BoundingSphere): boolean;
 
+        intersectsMinMax(min: Vector3, max: Vector3): boolean;
 
+        static Intersects(box0: BoundingBox, box1: BoundingBox): boolean;
 
+        static IntersectsSphere(minPoint: Vector3, maxPoint: Vector3, sphereCenter: Vector3, sphereRadius: number): boolean;
 
+        static IsCompletelyInFrustum(boundingVectors: Vector3[], frustumPlanes: Plane[]): boolean;
 
+        static IsInFrustum(boundingVectors: Vector3[], frustumPlanes: Plane[]): boolean;
 
+    }
 
+}
 
+
 
+declare module BABYLON {
 
+    interface ICullable {
 
+        isInFrustum(frustumPlanes: Plane[]): boolean;
 
+        isCompletelyInFrustum(frustumPlanes: Plane[]): boolean;
 
+    }
 
+    class BoundingInfo implements ICullable {
 
+        minimum: Vector3;
 
+        maximum: Vector3;
 
+        boundingBox: BoundingBox;
 
+        boundingSphere: BoundingSphere;
 
+        private _isLocked;
 
+        constructor(minimum: Vector3, maximum: Vector3);
 
+        isLocked: boolean;
 
+        update(world: Matrix): void;
 
+        isInFrustum(frustumPlanes: Plane[]): boolean;
 
+        isCompletelyInFrustum(frustumPlanes: Plane[]): boolean;
 
+        _checkCollision(collider: Collider): boolean;
 
+        intersectsPoint(point: Vector3): boolean;
 
+        intersects(boundingInfo: BoundingInfo, precise: boolean): boolean;
 
+    }
 
+}
 
+
 
+declare module BABYLON {
 
+    class BoundingSphere {
 
+        minimum: Vector3;
 
+        maximum: Vector3;
 
+        center: Vector3;
 
+        radius: number;
 
+        centerWorld: Vector3;
 
+        radiusWorld: number;
 
+        private _tempRadiusVector;
 
+        constructor(minimum: Vector3, maximum: Vector3);
 
+        _update(world: Matrix): void;
 
+        isInFrustum(frustumPlanes: Plane[]): boolean;
 
+        intersectsPoint(point: Vector3): boolean;
 
+        static Intersects(sphere0: BoundingSphere, sphere1: BoundingSphere): boolean;
 
+    }
 
+}
 
+
 
+declare module BABYLON {
 
+    class Ray {
 
+        origin: Vector3;
 
+        direction: Vector3;
 
+        length: number;
 
+        private _edge1;
 
+        private _edge2;
 
+        private _pvec;
 
+        private _tvec;
 
+        private _qvec;
 
+        private _tmpRay;
 
+        private _rayHelper;
 
+        constructor(origin: Vector3, direction: Vector3, length?: number);
 
+        intersectsBoxMinMax(minimum: Vector3, maximum: Vector3): boolean;
 
+        intersectsBox(box: BoundingBox): boolean;
 
+        intersectsSphere(sphere: BoundingSphere): boolean;
 
+        intersectsTriangle(vertex0: Vector3, vertex1: Vector3, vertex2: Vector3): IntersectionInfo;
 
+        intersectsPlane(plane: Plane): number;
 
+        intersectsMesh(mesh: AbstractMesh, fastCheck?: boolean): PickingInfo;
 
+        intersectsMeshes(meshes: Array<AbstractMesh>, fastCheck?: boolean, results?: Array<PickingInfo>): Array<PickingInfo>;
 
+        private _comparePickingInfo(pickingInfoA, pickingInfoB);
 
+        private static smallnum;
 
+        private static rayl;
 
+        /**
 
+         * Intersection test between the ray and a given segment whithin a given tolerance (threshold)
 
+         * @param sega the first point of the segment to test the intersection against
 
+         * @param segb the second point of the segment to test the intersection against
 
+         * @param threshold the tolerance margin, if the ray doesn't intersect the segment but is close to the given threshold, the intersection is successful
 
+         * @return the distance from the ray origin to the intersection point if there's intersection, or -1 if there's no intersection
 
+         */
 
+        intersectionSegment(sega: Vector3, segb: Vector3, threshold: number): number;
 
+        static CreateNew(x: number, y: number, viewportWidth: number, viewportHeight: number, world: Matrix, view: Matrix, projection: Matrix): Ray;
 
+        /**
 
+        * Function will create a new transformed ray starting from origin and ending at the end point. Ray's length will be set, and ray will be
 
+        * transformed to the given world matrix.
 
+        * @param origin The origin point
 
+        * @param end The end point
 
+        * @param world a matrix to transform the ray to. Default is the identity matrix.
 
+        */
 
+        static CreateNewFromTo(origin: Vector3, end: Vector3, world?: Matrix): Ray;
 
+        static Transform(ray: Ray, matrix: Matrix): Ray;
 
+        static TransformToRef(ray: Ray, matrix: Matrix, result: Ray): void;
 
+    }
 
+}
 
+
 
 declare module BABYLON.Debug {
 
 declare module BABYLON.Debug {
 
     class AxesViewer {
 
     class AxesViewer {
 
         private _xline;
 
         private _xline;
 
@@ -8209,69 +8209,6 @@ declare module BABYLON {
 
 }
 
 }
 
 
 
 declare module BABYLON {
 
 declare module BABYLON {
 
-    class MorphTarget {
 
-        name: string;
 
-        animations: Animation[];
 
-        private _positions;
 
-        private _normals;
 
-        private _tangents;
 
-        private _influence;
 
-        onInfluenceChanged: Observable<boolean>;
 
-        influence: number;
 
-        constructor(name: string, influence?: number);
 
-        readonly hasNormals: boolean;
 
-        readonly hasTangents: boolean;
 
-        setPositions(data: Float32Array | number[]): void;
 
-        getPositions(): Float32Array;
 
-        setNormals(data: Float32Array | number[]): void;
 
-        getNormals(): Float32Array;
 
-        setTangents(data: Float32Array | number[]): void;
 
-        getTangents(): Float32Array;
 
-        /**
 
-         * Serializes the current target into a Serialization object.
 
-         * Returns the serialized object.
 
-         */
 
-        serialize(): any;
 
-        static Parse(serializationObject: any): MorphTarget;
 
-        static FromMesh(mesh: AbstractMesh, name?: string, influence?: number): MorphTarget;
 
-    }
 
-}
 
-
 
-declare module BABYLON {
 
-    class MorphTargetManager {
 
-        private _targets;
 
-        private _targetObservable;
 
-        private _activeTargets;
 
-        private _scene;
 
-        private _influences;
 
-        private _supportsNormals;
 
-        private _supportsTangents;
 
-        private _vertexCount;
 
-        private _uniqueId;
 
-        constructor(scene?: Scene);
 
-        readonly uniqueId: number;
 
-        readonly vertexCount: number;
 
-        readonly supportsNormals: boolean;
 
-        readonly supportsTangents: boolean;
 
-        readonly numTargets: number;
 
-        readonly numInfluencers: number;
 
-        readonly influences: Float32Array;
 
-        getActiveTarget(index: number): MorphTarget;
 
-        getTarget(index: number): MorphTarget;
 
-        addTarget(target: MorphTarget): void;
 
-        removeTarget(target: MorphTarget): void;
 
-        /**
 
-         * Serializes the current manager into a Serialization object.
 
-         * Returns the serialized object.
 
-         */
 
-        serialize(): any;
 
-        private _onInfluenceChanged(needUpdate);
 
-        private _syncActiveTargets(needUpdate);
 
-        static Parse(serializationObject: any, scene: Scene): MorphTargetManager;
 
-    }
 
-}
 
-
 
-declare module BABYLON {
 
     class AbstractMesh extends Node implements IDisposable, ICullable, IGetSetVerticesData {
 
     class AbstractMesh extends Node implements IDisposable, ICullable, IGetSetVerticesData {
 
         private static _BILLBOARDMODE_NONE;
 
         private static _BILLBOARDMODE_NONE;
 
         private static _BILLBOARDMODE_X;
 
         private static _BILLBOARDMODE_X;
 
@@ -9782,12 +9719,6 @@ declare module BABYLON {
 
          */
 
          */
 
         updateMeshPositions(positionFunction: any, computeNormals?: boolean): Mesh;
 
         updateMeshPositions(positionFunction: any, computeNormals?: boolean): Mesh;
 
         /**
 
         /**
 
-         * This method will force the computation of normals for the mesh.
 
-         * Please note that the mesh must have normals vertex data already.
 
-         * Returns the Mesh.
 
-         */
 
-        recomputeNormals(markDataAsUpdatable?: boolean): Mesh;
 
-        /**
 
          * Creates a un-shared specific occurence of the geometry for the mesh.
 
          * Creates a un-shared specific occurence of the geometry for the mesh.
 
          * Returns the Mesh.
 
          * Returns the Mesh.
 
          */
 
          */
 
@@ -11621,6 +11552,69 @@ declare module BABYLON {
 
 }
 
 }
 
 
 
 declare module BABYLON {
 
 declare module BABYLON {
 
+    class MorphTarget {
 
+        name: string;
 
+        animations: Animation[];
 
+        private _positions;
 
+        private _normals;
 
+        private _tangents;
 
+        private _influence;
 
+        onInfluenceChanged: Observable<boolean>;
 
+        influence: number;
 
+        constructor(name: string, influence?: number);
 
+        readonly hasNormals: boolean;
 
+        readonly hasTangents: boolean;
 
+        setPositions(data: Float32Array | number[]): void;
 
+        getPositions(): Float32Array;
 
+        setNormals(data: Float32Array | number[]): void;
 
+        getNormals(): Float32Array;
 
+        setTangents(data: Float32Array | number[]): void;
 
+        getTangents(): Float32Array;
 
+        /**
 
+         * Serializes the current target into a Serialization object.
 
+         * Returns the serialized object.
 
+         */
 
+        serialize(): any;
 
+        static Parse(serializationObject: any): MorphTarget;
 
+        static FromMesh(mesh: AbstractMesh, name?: string, influence?: number): MorphTarget;
 
+    }
 
+}
 
+
 
+declare module BABYLON {
 
+    class MorphTargetManager {
 
+        private _targets;
 
+        private _targetObservable;
 
+        private _activeTargets;
 
+        private _scene;
 
+        private _influences;
 
+        private _supportsNormals;
 
+        private _supportsTangents;
 
+        private _vertexCount;
 
+        private _uniqueId;
 
+        constructor(scene?: Scene);
 
+        readonly uniqueId: number;
 
+        readonly vertexCount: number;
 
+        readonly supportsNormals: boolean;
 
+        readonly supportsTangents: boolean;
 
+        readonly numTargets: number;
 
+        readonly numInfluencers: number;
 
+        readonly influences: Float32Array;
 
+        getActiveTarget(index: number): MorphTarget;
 
+        getTarget(index: number): MorphTarget;
 
+        addTarget(target: MorphTarget): void;
 
+        removeTarget(target: MorphTarget): void;
 
+        /**
 
+         * Serializes the current manager into a Serialization object.
 
+         * Returns the serialized object.
 
+         */
 
+        serialize(): any;
 
+        private _onInfluenceChanged(needUpdate);
 
+        private _syncActiveTargets(needUpdate);
 
+        static Parse(serializationObject: any, scene: Scene): MorphTargetManager;
 
+    }
 
+}
 
+
 
+declare module BABYLON {
 
     class Particle {
 
     class Particle {
 
         position: Vector3;
 
         position: Vector3;
 
         direction: Vector3;
 
         direction: Vector3;

文件差異過大導致無法顯示
+ 24 - 24
dist/preview release/babylon.worker.js


文件差異過大導致無法顯示
+ 2490 - 2475
dist/preview release/customConfigurations/minimalViewer/babylon.d.ts


文件差異過大導致無法顯示
+ 25 - 25
dist/preview release/customConfigurations/minimalViewer/babylon.js


+ 94 - 44
dist/preview release/customConfigurations/minimalViewer/babylon.max.js
查看文件 

@@ -841,6 +841,12 @@ var __extends = (this && this.__extends) || (function () {
 
             return new Vector2(0, 0);
 
             return new Vector2(0, 0);
 
         };
 
         };
 
         /**
 
         /**
 
+         * Returns a new Vector2(1, 1)
 
+         */
 
+        Vector2.One = function () {
 
+            return new Vector2(1, 1);
 
+        };
 
+        /**
 
          * Returns a new Vector2 set from the passed index element of the passed array.
 
          * Returns a new Vector2 set from the passed index element of the passed array.
 
          */
 
          */
 
         Vector2.FromArray = function (array, offset) {
 
         Vector2.FromArray = function (array, offset) {
 
@@ -1378,6 +1384,12 @@ var __extends = (this && this.__extends) || (function () {
 
             return new Vector3(0.0, 0.0, 0.0);
 
             return new Vector3(0.0, 0.0, 0.0);
 
         };
 
         };
 
         /**
 
         /**
 
+         * Returns a new Vector3 set to (1.0, 1.0, 1.0).
 
+         */
 
+        Vector3.One = function () {
 
+            return new Vector3(1.0, 1.0, 1.0);
 
+        };
 
+        /**
 
          * Returns a new Vector3 set to (0.0, 1.0, 0.0)
 
          * Returns a new Vector3 set to (0.0, 1.0, 0.0)
 
          */
 
          */
 
         Vector3.Up = function () {
 
         Vector3.Up = function () {
 
@@ -2041,6 +2053,12 @@ var __extends = (this && this.__extends) || (function () {
 
             return new Vector4(0.0, 0.0, 0.0, 0.0);
 
             return new Vector4(0.0, 0.0, 0.0, 0.0);
 
         };
 
         };
 
         /**
 
         /**
 
+         * Returns a new Vector4 set to (1.0, 1.0, 1.0, 1.0)
 
+         */
 
+        Vector4.One = function () {
 
+            return new Vector4(1.0, 1.0, 1.0, 1.0);
 
+        };
 
+        /**
 
          * Returns a new normalized Vector4 from the passed one.
 
          * Returns a new normalized Vector4 from the passed one.
 
          */
 
          */
 
         Vector4.Normalize = function (vector) {
 
         Vector4.Normalize = function (vector) {
 
@@ -8909,7 +8927,13 @@ var BABYLON;
 
                 }
 
                 }
 
             }
 
             }
 
             // Z offset
 
             // Z offset
 
-            this._depthCullingState.zOffset = zOffset;
 
+            this.setZOffset(zOffset);
 
+        };
 
+        Engine.prototype.setZOffset = function (value) {
 
+            this._depthCullingState.zOffset = value;
 
+        };
 
+        Engine.prototype.getZOffset = function () {
 
+            return this._depthCullingState.zOffset;
 
         };
 
         };
 
         Engine.prototype.setDepthBuffer = function (enable) {
 
         Engine.prototype.setDepthBuffer = function (enable) {
 
             this._depthCullingState.depthTest = enable;
 
             this._depthCullingState.depthTest = enable;
 
@@ -11181,9 +11205,9 @@ var BABYLON;
 
             _this.onAfterWorldMatrixUpdateObservable = new BABYLON.Observable();
 
             _this.onAfterWorldMatrixUpdateObservable = new BABYLON.Observable();
 
             // Properties
 
             // Properties
 
             _this.definedFacingForward = true; // orientation for POV movement & rotation
 
             _this.definedFacingForward = true; // orientation for POV movement & rotation
 
-            _this.position = new BABYLON.Vector3(0.0, 0.0, 0.0);
 
-            _this._rotation = new BABYLON.Vector3(0.0, 0.0, 0.0);
 
-            _this._scaling = new BABYLON.Vector3(1.0, 1.0, 1.0);
 
+            _this.position = BABYLON.Vector3.Zero();
 
+            _this._rotation = BABYLON.Vector3.Zero();
 
+            _this._scaling = BABYLON.Vector3.One();
 
             _this.billboardMode = AbstractMesh.BILLBOARDMODE_NONE;
 
             _this.billboardMode = AbstractMesh.BILLBOARDMODE_NONE;
 
             _this.visibility = 1.0;
 
             _this.visibility = 1.0;
 
             _this.alphaIndex = Number.MAX_VALUE;
 
             _this.alphaIndex = Number.MAX_VALUE;
 
@@ -19082,10 +19106,6 @@ var BABYLON;
 
             _this._deleteBuffer = deleteBuffer;
 
             _this._deleteBuffer = deleteBuffer;
 
             _this._format = format;
 
             _this._format = format;
 
             scene = _this.getScene();
 
             scene = _this.getScene();
 
-            if (!url) {
 
-                return _this;
 
-            }
 
-            _this._texture = _this._getFromCache(url, noMipmap, samplingMode);
 
             var load = function () {
 
             var load = function () {
 
                 if (_this._onLoadObservarble && _this._onLoadObservarble.hasObservers()) {
 
                 if (_this._onLoadObservarble && _this._onLoadObservarble.hasObservers()) {
 
                     _this.onLoadObservable.notifyObservers(true);
 
                     _this.onLoadObservable.notifyObservers(true);
 
@@ -19097,6 +19117,12 @@ var BABYLON;
 
                     scene.resetCachedMaterial();
 
                     scene.resetCachedMaterial();
 
                 }
 
                 }
 
             };
 
             };
 
+            if (!url) {
 
+                _this._delayedOnLoad = load;
 
+                _this._delayedOnError = onError;
 
+                return _this;
 
+            }
 
+            _this._texture = _this._getFromCache(url, noMipmap, samplingMode);
 
             if (!_this._texture) {
 
             if (!_this._texture) {
 
                 if (!scene.useDelayedTextureLoading) {
 
                 if (!scene.useDelayedTextureLoading) {
 
                     _this._texture = scene.getEngine().createTexture(url, noMipmap, invertY, scene, _this._samplingMode, load, onError, _this._buffer, null, _this._format);
 
                     _this._texture = scene.getEngine().createTexture(url, noMipmap, invertY, scene, _this._samplingMode, load, onError, _this._buffer, null, _this._format);
 
@@ -19137,7 +19163,13 @@ var BABYLON;
 
             enumerable: true,
 
             enumerable: true,
 
             configurable: true
 
             configurable: true
 
         });
 
         });
 
+        Texture.prototype.updateURL = function (url) {
 
+            this.url = url;
 
+            this.delayLoadState = BABYLON.Engine.DELAYLOADSTATE_NOTLOADED;
 
+            this.delayLoad();
 
+        };
 
         Texture.prototype.delayLoad = function () {
 
         Texture.prototype.delayLoad = function () {
 
+            var _this = this;
 
             if (this.delayLoadState !== BABYLON.Engine.DELAYLOADSTATE_NOTLOADED) {
 
             if (this.delayLoadState !== BABYLON.Engine.DELAYLOADSTATE_NOTLOADED) {
 
                 return;
 
                 return;
 
             }
 
             }
 
@@ -19149,6 +19181,14 @@ var BABYLON;
 
                     delete this._buffer;
 
                     delete this._buffer;
 
                 }
 
                 }
 
             }
 
             }
 
+            else {
 
+                if (this._texture.isReady) {
 
+                    BABYLON.Tools.SetImmediate(function () { return _this._delayedOnLoad(); });
 
+                }
 
+                else {
 
+                    this._texture.onLoadedCallbacks.push(this._delayedOnLoad);
 
+                }
 
+            }
 
         };
 
         };
 
         Texture.prototype.updateSamplingMode = function (samplingMode) {
 
         Texture.prototype.updateSamplingMode = function (samplingMode) {
 
             if (!this._texture) {
 
             if (!this._texture) {
 
@@ -20155,25 +20195,6 @@ var BABYLON;
 
             return this;
 
             return this;
 
         };
 
         };
 
         /**
 
         /**
 
-         * This method will force the computation of normals for the mesh.
 
-         * Please note that the mesh must have normals vertex data already.
 
-         * Returns the Mesh.
 
-         */
 
-        Mesh.prototype.recomputeNormals = function () {
 
-            var positions = this.getVerticesData(BABYLON.VertexBuffer.PositionKind);
 
-            var indices = this.getIndices();
 
-            var normals;
 
-            if (this.isVerticesDataPresent(BABYLON.VertexBuffer.NormalKind)) {
 
-                normals = this.getVerticesData(BABYLON.VertexBuffer.NormalKind);
 
-            }
 
-            else {
 
-                normals = [];
 
-            }
 
-            BABYLON.VertexData.ComputeNormals(positions, indices, normals);
 
-            this.updateVerticesData(BABYLON.VertexBuffer.NormalKind, normals, false, false);
 
-            return this;
 
-        };
 
-        /**
 
          * Creates a un-shared specific occurence of the geometry for the mesh.
 
          * Creates a un-shared specific occurence of the geometry for the mesh.
 
          * Returns the Mesh.
 
          * Returns the Mesh.
 
          */
 
          */
 
@@ -24715,6 +24736,7 @@ var BABYLON;
 
             if (flag & BABYLON.Material.MiscDirtyFlag) {
 
             if (flag & BABYLON.Material.MiscDirtyFlag) {
 
                 this._markAllSubMeshesAsMiscDirty();
 
                 this._markAllSubMeshesAsMiscDirty();
 
             }
 
             }
 
+            this.getScene().resetCachedMaterial();
 
         };
 
         };
 
         PushMaterial.prototype._markAllSubMeshesAsDirty = function (func) {
 
         PushMaterial.prototype._markAllSubMeshesAsDirty = function (func) {
 
             for (var _i = 0, _a = this.getScene().meshes; _i < _a.length; _i++) {
 
             for (var _i = 0, _a = this.getScene().meshes; _i < _a.length; _i++) {
 
@@ -29629,7 +29651,7 @@ var BABYLON;
 
             var normals = sourceMesh.getVerticesData(BABYLON.VertexBuffer.NormalKind);
 
             var normals = sourceMesh.getVerticesData(BABYLON.VertexBuffer.NormalKind);
 
             var position = options.position || BABYLON.Vector3.Zero();
 
             var position = options.position || BABYLON.Vector3.Zero();
 
             var normal = options.normal || BABYLON.Vector3.Up();
 
             var normal = options.normal || BABYLON.Vector3.Up();
 
-            var size = options.size || new BABYLON.Vector3(1, 1, 1);
 
+            var size = options.size || BABYLON.Vector3.One();
 
             var angle = options.angle || 0;
 
             var angle = options.angle || 0;
 
             // Getting correct rotation
 
             // Getting correct rotation
 
             if (!normal) {
 
             if (!normal) {
 
@@ -33225,8 +33247,9 @@ var BABYLON;
 
             _this.mirrorPlane = new BABYLON.Plane(0, 1, 0, 1);
 
             _this.mirrorPlane = new BABYLON.Plane(0, 1, 0, 1);
 
             _this._transformMatrix = BABYLON.Matrix.Zero();
 
             _this._transformMatrix = BABYLON.Matrix.Zero();
 
             _this._mirrorMatrix = BABYLON.Matrix.Zero();
 
             _this._mirrorMatrix = BABYLON.Matrix.Zero();
 
-            _this._blurKernel = 0;
 
-            _this._blurRatio = 0.6;
 
+            _this._blurKernelX = 0;
 
+            _this._blurKernelY = 0;
 
+            _this._blurRatio = 1.0;
 
             _this.onBeforeRenderObservable.add(function () {
 
             _this.onBeforeRenderObservable.add(function () {
 
                 BABYLON.Matrix.ReflectionToRef(_this.mirrorPlane, _this._mirrorMatrix);
 
                 BABYLON.Matrix.ReflectionToRef(_this.mirrorPlane, _this._mirrorMatrix);
 
                 _this._savedViewMatrix = scene.getViewMatrix();
 
                 _this._savedViewMatrix = scene.getViewMatrix();
 
@@ -33259,14 +33282,36 @@ var BABYLON;
 
             configurable: true
 
             configurable: true
 
         });
 
         });
 
         Object.defineProperty(MirrorTexture.prototype, "blurKernel", {
 
         Object.defineProperty(MirrorTexture.prototype, "blurKernel", {
 
+            set: function (value) {
 
+                this.blurKernelX = value;
 
+                this.blurKernelY = value;
 
+            },
 
+            enumerable: true,
 
+            configurable: true
 
+        });
 
+        Object.defineProperty(MirrorTexture.prototype, "blurKernelX", {
 
+            get: function () {
 
+                return this._blurKernelX;
 
+            },
 
+            set: function (value) {
 
+                if (this._blurKernelX === value) {
 
+                    return;
 
+                }
 
+                this._blurKernelX = value;
 
+                this._preparePostProcesses();
 
+            },
 
+            enumerable: true,
 
+            configurable: true
 
+        });
 
+        Object.defineProperty(MirrorTexture.prototype, "blurKernelY", {
 
             get: function () {
 
             get: function () {
 
-                return this._blurKernel;
 
+                return this._blurKernelY;
 
             },
 
             },
 
             set: function (value) {
 
             set: function (value) {
 
-                if (this._blurKernel === value) {
 
+                if (this._blurKernelY === value) {
 
                     return;
 
                     return;
 
                 }
 
                 }
 
-                this._blurKernel = value;
 
+                this._blurKernelY = value;
 
                 this._preparePostProcesses();
 
                 this._preparePostProcesses();
 
             },
 
             },
 
             enumerable: true,
 
             enumerable: true,
 
@@ -33274,15 +33319,20 @@ var BABYLON;
 
         });
 
         });
 
         MirrorTexture.prototype._preparePostProcesses = function () {
 
         MirrorTexture.prototype._preparePostProcesses = function () {
 
             this.clearPostProcesses(true);
 
             this.clearPostProcesses(true);
 
-            if (this._blurKernel) {
 
+            if (this._blurKernelX && this._blurKernelY) {
 
                 var engine = this.getScene().getEngine();
 
                 var engine = this.getScene().getEngine();
 
                 var textureType = engine.getCaps().textureFloatRender ? BABYLON.Engine.TEXTURETYPE_FLOAT : BABYLON.Engine.TEXTURETYPE_HALF_FLOAT;
 
                 var textureType = engine.getCaps().textureFloatRender ? BABYLON.Engine.TEXTURETYPE_FLOAT : BABYLON.Engine.TEXTURETYPE_HALF_FLOAT;
 
-                this._blurX = new BABYLON.BlurPostProcess("horizontal blur", new BABYLON.Vector2(1.0, 0), this._blurKernel, this._blurRatio, null, BABYLON.Texture.BILINEAR_SAMPLINGMODE, engine, false, textureType);
 
+                this._blurX = new BABYLON.BlurPostProcess("horizontal blur", new BABYLON.Vector2(1.0, 0), this._blurKernelX, this._blurRatio, null, BABYLON.Texture.BILINEAR_SAMPLINGMODE, engine, false, textureType);
 
                 this._blurX.autoClear = false;
 
                 this._blurX.autoClear = false;
 
-                this._blurX.alwaysForcePOT = false;
 
-                this._blurY = new BABYLON.BlurPostProcess("vertical blur", new BABYLON.Vector2(0, 1.0), this._blurKernel, this._blurRatio, null, BABYLON.Texture.BILINEAR_SAMPLINGMODE, engine, false, textureType);
 
+                if (this._blurRatio === 1) {
 
+                    this._blurX.outputTexture = this._texture;
 
+                }
 
+                else {
 
+                    this._blurX.alwaysForcePOT = true;
 
+                }
 
+                this._blurY = new BABYLON.BlurPostProcess("vertical blur", new BABYLON.Vector2(0, 1.0), this._blurKernelY, this._blurRatio, null, BABYLON.Texture.BILINEAR_SAMPLINGMODE, engine, false, textureType);
 
                 this._blurY.autoClear = false;
 
                 this._blurY.autoClear = false;
 
-                this._blurY.alwaysForcePOT = true;
 
+                this._blurY.alwaysForcePOT = this._blurRatio !== 1;
 
                 this.addPostProcess(this._blurX);
 
                 this.addPostProcess(this._blurX);
 
                 this.addPostProcess(this._blurY);
 
                 this.addPostProcess(this._blurY);
 
             }
 
             }
 
@@ -35261,11 +35311,9 @@ var BABYLON;
 
             if (defines._areFresnelDirty) {
 
             if (defines._areFresnelDirty) {
 
                 if (StandardMaterial.FresnelEnabled) {
 
                 if (StandardMaterial.FresnelEnabled) {
 
                     // Fresnel
 
                     // Fresnel
 
-                    if (this._diffuseFresnelParameters && this._diffuseFresnelParameters.isEnabled ||
 
-                        this._opacityFresnelParameters && this._opacityFresnelParameters.isEnabled ||
 
-                        this._emissiveFresnelParameters && this._emissiveFresnelParameters.isEnabled ||
 
-                        this._refractionFresnelParameters && this._refractionFresnelParameters.isEnabled ||
 
-                        this._reflectionFresnelParameters && this._reflectionFresnelParameters.isEnabled) {
 
+                    if (this._diffuseFresnelParameters || this._opacityFresnelParameters ||
 
+                        this._emissiveFresnelParameters || this._refractionFresnelParameters ||
 
+                        this._reflectionFresnelParameters) {
 
                         defines.DIFFUSEFRESNEL = (this._diffuseFresnelParameters && this._diffuseFresnelParameters.isEnabled);
 
                         defines.DIFFUSEFRESNEL = (this._diffuseFresnelParameters && this._diffuseFresnelParameters.isEnabled);
 
                         defines.OPACITYFRESNEL = (this._opacityFresnelParameters && this._opacityFresnelParameters.isEnabled);
 
                         defines.OPACITYFRESNEL = (this._opacityFresnelParameters && this._opacityFresnelParameters.isEnabled);
 
                         defines.REFLECTIONFRESNEL = (this._reflectionFresnelParameters && this._reflectionFresnelParameters.isEnabled);
 
                         defines.REFLECTIONFRESNEL = (this._reflectionFresnelParameters && this._reflectionFresnelParameters.isEnabled);
 
@@ -38294,7 +38342,7 @@ var BABYLON;
 
         return DebugLayer;
 
         return DebugLayer;
 
     }());
 
     }());
 
     // Get protocol used - http or https
 
     // Get protocol used - http or https
 
-    DebugLayer.InspectorURL = window.location.href.split('/')[0] + '//www.babylonjs.com/babylon.inspector.bundle.js';
 
+    DebugLayer.InspectorURL = window.location.href.split('/')[0] + '//preview.babylonjs.com/inspector/babylon.inspector.bundle.js';
 
     BABYLON.DebugLayer = DebugLayer;
 
     BABYLON.DebugLayer = DebugLayer;
 
 })(BABYLON || (BABYLON = {}));
 
 })(BABYLON || (BABYLON = {}));
 
 
 
@@ -41280,6 +41328,8 @@ var BABYLON;
 
             }
 
             }
 
             else if (this._forcedOutputTexture) {
 
             else if (this._forcedOutputTexture) {
 
                 target = this._forcedOutputTexture;
 
                 target = this._forcedOutputTexture;
 
+                this.width = this._forcedOutputTexture._width;
 
+                this.height = this._forcedOutputTexture._height;
 
             }
 
             }
 
             else {
 
             else {
 
                 target = this.outputTexture;
 
                 target = this.outputTexture;

文件差異過大導致無法顯示
+ 2490 - 2475
dist/preview release/customConfigurations/minimalViewer/babylon.module.d.ts


+ 4 - 0
dist/preview release/gui/babylon.gui.d.ts
查看文件 

@@ -30,6 +30,7 @@ declare module BABYLON.GUI {
 
         removeControl(control: Control): AdvancedDynamicTexture;
 
         removeControl(control: Control): AdvancedDynamicTexture;
 
         dispose(): void;
 
         dispose(): void;
 
         private _onResize();
 
         private _onResize();
 
+        _getGlobalViewport(scene: Scene): Viewport;
 
         private _checkUpdate(camera);
 
         private _checkUpdate(camera);
 
         private _render();
 
         private _render();
 
         private _doPicking(x, y, type);
 
         private _doPicking(x, y, type);
 
@@ -214,6 +215,9 @@ declare module BABYLON.GUI {
 
         readonly centerY: number;
 
         readonly centerY: number;
 
         constructor(name?: string);
 
         constructor(name?: string);
 
         protected _getTypeName(): string;
 
         protected _getTypeName(): string;
 
+        getLocalCoordinates(globalCoordinates: Vector2): Vector2;
 
+        getLocalCoordinatesToRef(globalCoordinates: Vector2, result: Vector2): Control;
 
+        moveToVector3(position: Vector3, scene: Scene): void;
 
         linkWithMesh(mesh: AbstractMesh): void;
 
         linkWithMesh(mesh: AbstractMesh): void;
 
         _moveToProjectedPosition(projectedPosition: Vector3): void;
 
         _moveToProjectedPosition(projectedPosition: Vector3): void;
 
         _markMatrixAsDirty(): void;
 
         _markMatrixAsDirty(): void;

+ 38 - 2
dist/preview release/gui/babylon.gui.js
查看文件 

@@ -148,6 +148,10 @@ var BABYLON;
 
                     }
 
                     }
 
                 }
 
                 }
 
             };
 
             };
 
+            AdvancedDynamicTexture.prototype._getGlobalViewport = function (scene) {
 
+                var engine = scene.getEngine();
 
+                return this._fullscreenViewport.toGlobal(engine.getRenderWidth(), engine.getRenderHeight());
 
+            };
 
             AdvancedDynamicTexture.prototype._checkUpdate = function (camera) {
 
             AdvancedDynamicTexture.prototype._checkUpdate = function (camera) {
 
                 if (this._layerToDispose) {
 
                 if (this._layerToDispose) {
 
                     if ((camera.layerMask & this._layerToDispose.layerMask) === 0) {
 
                     if ((camera.layerMask & this._layerToDispose.layerMask) === 0) {
 
@@ -156,8 +160,7 @@ var BABYLON;
 
                 }
 
                 }
 
                 if (this._isFullscreen && this._linkedControls.length) {
 
                 if (this._isFullscreen && this._linkedControls.length) {
 
                     var scene = this.getScene();
 
                     var scene = this.getScene();
 
-                    var engine = scene.getEngine();
 
-                    var globalViewport = this._fullscreenViewport.toGlobal(engine.getRenderWidth(), engine.getRenderHeight());
 
+                    var globalViewport = this._getGlobalViewport(scene);
 
                     for (var _i = 0, _a = this._linkedControls; _i < _a.length; _i++) {
 
                     for (var _i = 0, _a = this._linkedControls; _i < _a.length; _i++) {
 
                         var control = _a[_i];
 
                         var control = _a[_i];
 
                         var mesh = control._linkedMesh;
 
                         var mesh = control._linkedMesh;
 
@@ -999,6 +1002,33 @@ var BABYLON;
 
             Control.prototype._getTypeName = function () {
 
             Control.prototype._getTypeName = function () {
 
                 return "Control";
 
                 return "Control";
 
             };
 
             };
 
+            Control.prototype.getLocalCoordinates = function (globalCoordinates) {
 
+                var result = BABYLON.Vector2.Zero();
 
+                this.getLocalCoordinatesToRef(globalCoordinates, result);
 
+                return result;
 
+            };
 
+            Control.prototype.getLocalCoordinatesToRef = function (globalCoordinates, result) {
 
+                result.x = globalCoordinates.x - this._currentMeasure.left;
 
+                result.y = globalCoordinates.y - this._currentMeasure.top;
 
+                return this;
 
+            };
 
+            Control.prototype.moveToVector3 = function (position, scene) {
 
+                if (!this._host || this._root !== this._host._rootContainer) {
 
+                    BABYLON.Tools.Error("Cannot move a control to a vector3 if the control is not at root level");
 
+                    return;
 
+                }
 
+                this.horizontalAlignment = BABYLON.GUI.Control.HORIZONTAL_ALIGNMENT_LEFT;
 
+                this.verticalAlignment = BABYLON.GUI.Control.VERTICAL_ALIGNMENT_TOP;
 
+                var engine = scene.getEngine();
 
+                var globalViewport = this._host._getGlobalViewport(scene);
 
+                var projectedPosition = BABYLON.Vector3.Project(position, BABYLON.Matrix.Identity(), scene.getTransformMatrix(), globalViewport);
 
+                this._moveToProjectedPosition(projectedPosition);
 
+                if (projectedPosition.z < 0 || projectedPosition.z > 1) {
 
+                    this.isVisible = false;
 
+                    return;
 
+                }
 
+                this.isVisible = true;
 
+            };
 
             Control.prototype.linkWithMesh = function (mesh) {
 
             Control.prototype.linkWithMesh = function (mesh) {
 
                 if (!this._host || this._root !== this._host._rootContainer) {
 
                 if (!this._host || this._root !== this._host._rootContainer) {
 
                     BABYLON.Tools.Error("Cannot link a control to a mesh if the control is not at root level");
 
                     BABYLON.Tools.Error("Cannot link a control to a mesh if the control is not at root level");
 
@@ -1573,6 +1603,9 @@ var BABYLON;
 
                 }
 
                 }
 
             };
 
             };
 
             Container.prototype._draw = function (parentMeasure, context) {
 
             Container.prototype._draw = function (parentMeasure, context) {
 
+                if (!this.isVisible) {
 
+                    return;
 
+                }
 
                 context.save();
 
                 context.save();
 
                 this._applyStates(context);
 
                 this._applyStates(context);
 
                 if (this._processMeasures(parentMeasure, context)) {
 
                 if (this._processMeasures(parentMeasure, context)) {
 
@@ -1588,6 +1621,9 @@ var BABYLON;
 
                 context.restore();
 
                 context.restore();
 
             };
 
             };
 
             Container.prototype._processPicking = function (x, y, type) {
 
             Container.prototype._processPicking = function (x, y, type) {
 
+                if (!this.isHitTestVisible || !this.isVisible) {
 
+                    return false;
 
+                }
 
                 if (!_super.prototype.contains.call(this, x, y)) {
 
                 if (!_super.prototype.contains.call(this, x, y)) {
 
                     return false;
 
                     return false;
 
                 }
 
                 }

文件差異過大導致無法顯示
+ 2 - 2
dist/preview release/gui/babylon.gui.min.js


+ 6 - 2
gui/src/advancedDynamicTexture.ts
查看文件 

@@ -158,6 +158,11 @@ module BABYLON.GUI {
 
             }

             }

         }

         }

 

 

+        public _getGlobalViewport(scene: Scene): Viewport {

+            var engine = scene.getEngine();

+            return this._fullscreenViewport.toGlobal(engine.getRenderWidth(), engine.getRenderHeight());

+        }

+

         private _checkUpdate(camera: Camera): void {

         private _checkUpdate(camera: Camera): void {

             if (this._layerToDispose) {

             if (this._layerToDispose) {

                 if ((camera.layerMask & this._layerToDispose.layerMask) === 0) {

                 if ((camera.layerMask & this._layerToDispose.layerMask) === 0) {

@@ -167,8 +172,7 @@ module BABYLON.GUI {
 
 

 

             if (this._isFullscreen && this._linkedControls.length) {

             if (this._isFullscreen && this._linkedControls.length) {

                 var scene = this.getScene();

                 var scene = this.getScene();

-                var engine = scene.getEngine();

-                var globalViewport = this._fullscreenViewport.toGlobal(engine.getRenderWidth(), engine.getRenderHeight());

+                var globalViewport = this._getGlobalViewport(scene);

 

 

                 for (var control of this._linkedControls) {

                 for (var control of this._linkedControls) {

                     var mesh = control._linkedMesh;

                     var mesh = control._linkedMesh;

+ 7 - 0
gui/src/controls/container.ts
查看文件 

@@ -127,6 +127,9 @@ module BABYLON.GUI {
 
         }

         }

 

 

         public _draw(parentMeasure: Measure, context: CanvasRenderingContext2D): void {      

         public _draw(parentMeasure: Measure, context: CanvasRenderingContext2D): void {      

+            if (!this.isVisible) {

+                return;

+            }

             context.save();

             context.save();

            

            

             this._applyStates(context);

             this._applyStates(context);

@@ -145,6 +148,10 @@ module BABYLON.GUI {
 
         }

         }

 

 

         public _processPicking(x: number, y: number, type: number): boolean {

         public _processPicking(x: number, y: number, type: number): boolean {

+            if (!this.isHitTestVisible || !this.isVisible) {

+                return false;

+            }

+

             if (!super.contains(x, y)) {

             if (!super.contains(x, y)) {

                 return false;

                 return false;

             }

             }

+ 36 - 0
gui/src/controls/control.ts
查看文件 

@@ -399,6 +399,42 @@ module BABYLON.GUI {
 
             return "Control";

             return "Control";

         }

         }

 

 

+        public getLocalCoordinates(globalCoordinates: Vector2): Vector2 {

+            var result = Vector2.Zero();

+

+            this.getLocalCoordinatesToRef(globalCoordinates, result);

+

+            return result;

+        }

+

+        public getLocalCoordinatesToRef(globalCoordinates: Vector2, result: Vector2): Control {

+            result.x = globalCoordinates.x - this._currentMeasure.left;

+            result.y = globalCoordinates.y - this._currentMeasure.top;

+            return this;

+        }

+

+        public moveToVector3(position: Vector3, scene: Scene): void {

+            if (!this._host || this._root !== this._host._rootContainer) {

+                Tools.Error("Cannot move a control to a vector3 if the control is not at root level");

+                return;

+            }

+            

+            this.horizontalAlignment = BABYLON.GUI.Control.HORIZONTAL_ALIGNMENT_LEFT;

+            this.verticalAlignment = BABYLON.GUI.Control.VERTICAL_ALIGNMENT_TOP;

+

+            var engine = scene.getEngine();

+            var globalViewport = this._host._getGlobalViewport(scene);

+            var projectedPosition = Vector3.Project(position, Matrix.Identity(), scene.getTransformMatrix(), globalViewport);

+

+            this._moveToProjectedPosition(projectedPosition);

+

+            if (projectedPosition.z < 0 || projectedPosition.z > 1) {

+                this.isVisible = false;

+                return;

+            }

+            this.isVisible = true;

+        }

+

         public linkWithMesh(mesh: AbstractMesh): void {

         public linkWithMesh(mesh: AbstractMesh): void {

             if (!this._host || this._root !== this._host._rootContainer) {

             if (!this._host || this._root !== this._host._rootContainer) {

                 Tools.Error("Cannot link a control to a mesh if the control is not at root level");

                 Tools.Error("Cannot link a control to a mesh if the control is not at root level");

+ 41 - 21
src/Bones/babylon.bone.ts
查看文件 

@@ -21,50 +21,68 @@ module BABYLON {
 
         private _parent: Bone;

         private _parent: Bone;

 

 

         private _scaleMatrix = Matrix.Identity();

         private _scaleMatrix = Matrix.Identity();

-        private _scaleVector = new Vector3(1, 1, 1);

-        private _negateScaleChildren = new Vector3(1, 1, 1);

+        private _scaleVector = Vector3.One();

+        private _negateScaleChildren = Vector3.One();

         private _scalingDeterminant = 1;

         private _scalingDeterminant = 1;

 

 

-        get _matrix():Matrix{

+        get _matrix(): Matrix {

             return this._localMatrix;

             return this._localMatrix;

         }

         }

 

 

-        set _matrix(val:Matrix){

-            if(this._localMatrix){

+        set _matrix(val: Matrix) {

+            if (this._localMatrix) {

                 this._localMatrix.copyFrom(val);

                 this._localMatrix.copyFrom(val);

-            }else{

+            } else {

                 this._localMatrix = val;

                 this._localMatrix = val;

             }

             }

         }

         }

-        

-        constructor(public name: string, skeleton: Skeleton, parentBone: Bone, matrix: Matrix, restPose?: Matrix) {

+

+        constructor(public name: string, skeleton: Skeleton, parentBone: Bone = null, matrix?: Matrix, restPose?: Matrix) {

             super(name, skeleton.getScene());

             super(name, skeleton.getScene());

             this._skeleton = skeleton;

             this._skeleton = skeleton;

-            this._localMatrix = matrix;

-            this._baseMatrix = matrix.clone();

-            this._restPose = restPose ? restPose : matrix.clone();

+            this._localMatrix = matrix ? matrix : Matrix.Identity();

+            this._baseMatrix = this._localMatrix.clone();

+            this._restPose = restPose ? restPose : this._localMatrix.clone();

 

 

             skeleton.bones.push(this);

             skeleton.bones.push(this);

 

 

-            if (parentBone) {

-                this._parent = parentBone;

-                parentBone.children.push(this);

-            } else {

-                this._parent = null;

-            }

+            this.setParent(parentBone, false);

 

 

             this._updateDifferenceMatrix();

             this._updateDifferenceMatrix();

-

-            if (this.getAbsoluteTransform().determinant() < 0) {

-                this._scalingDeterminant *= -1;

-            }

         }

         }

 

 

         // Members

         // Members

+        public getSkeleton(): Skeleton {

+            return this._skeleton;

+        }

+

         public getParent(): Bone {

         public getParent(): Bone {

             return this._parent;

             return this._parent;

         }

         }

 

 

+        public setParent(parent: Bone, updateDifferenceMatrix: boolean = true): void {

+            if (this._parent === parent) {

+                return;

+            }

+

+            if (this._parent) {

+                var index = this._parent.children.indexOf(this);

+                if (index !== -1) {

+                    this._parent.children.splice(index);

+                }

+            }

+

+            this._parent = parent;

+

+            if (this._parent) {

+                this._parent.children.push(this);

+            }

+

+            if (updateDifferenceMatrix) {

+                this._updateDifferenceMatrix();

+            }

+        }

+

         public getLocalMatrix(): Matrix {

         public getLocalMatrix(): Matrix {

             return this._localMatrix;

             return this._localMatrix;

         }

         }

@@ -154,6 +172,8 @@ module BABYLON {
 
             for (var index = 0; index < this.children.length; index++) {

             for (var index = 0; index < this.children.length; index++) {

                 this.children[index]._updateDifferenceMatrix();

                 this.children[index]._updateDifferenceMatrix();

             }

             }

+

+            this._scalingDeterminant = (this._absoluteTransform.determinant() < 0 ? -1 : 1);

         }

         }

 

 

         public markAsDirty(): void {

         public markAsDirty(): void {

+ 1 - 1
src/Collisions/babylon.collider.ts
查看文件 

@@ -58,7 +58,7 @@
 
     )();

     )();

 

 

     export class Collider {

     export class Collider {

-        public radius = new Vector3(1, 1, 1);

+        public radius = Vector3.One();

         public retry = 0;

         public retry = 0;

         public velocity: Vector3;

         public velocity: Vector3;

         public basePoint: Vector3;

         public basePoint: Vector3;

+ 35 - 11
src/Materials/Textures/babylon.mirrorTexture.ts
查看文件 

@@ -10,8 +10,9 @@ module BABYLON {
 
 

 

         private _blurX: BlurPostProcess;

         private _blurX: BlurPostProcess;

         private _blurY: BlurPostProcess;

         private _blurY: BlurPostProcess;

-        private _blurKernel = 0;

-        private _blurRatio = 0.6;

+        private _blurKernelX = 0;

+        private _blurKernelY = 0;

+        private _blurRatio = 1.0;

 

 

         public set blurRatio(value: number) {

         public set blurRatio(value: number) {

             if (this._blurRatio === value) {

             if (this._blurRatio === value) {

@@ -27,18 +28,36 @@ module BABYLON {
 
         }

         }

 

 

         public set blurKernel(value: number) {

         public set blurKernel(value: number) {

-            if (this._blurKernel === value) {

+            this.blurKernelX = value;

+            this.blurKernelY = value;

+        }        

+

+        public set blurKernelX(value: number) {

+            if (this._blurKernelX === value) {

                 return;

                 return;

             }

             }

 

 

-            this._blurKernel = value;

+            this._blurKernelX = value;

             this._preparePostProcesses();

             this._preparePostProcesses();

         }

         }

 

 

-        public get blurKernel(): number {

-            return this._blurKernel;

+        public get blurKernelX(): number {

+            return this._blurKernelX;

         }        

         }        

 

 

+        public set blurKernelY(value: number) {

+            if (this._blurKernelY === value) {

+                return;

+            }

+

+            this._blurKernelY = value;

+            this._preparePostProcesses();

+        }

+

+        public get blurKernelY(): number {

+            return this._blurKernelY;

+        }             

+

         constructor(name: string, size: any, scene: Scene, generateMipMaps?: boolean, type: number = Engine.TEXTURETYPE_UNSIGNED_INT, samplingMode = Texture.BILINEAR_SAMPLINGMODE, generateDepthBuffer = true) {

         constructor(name: string, size: any, scene: Scene, generateMipMaps?: boolean, type: number = Engine.TEXTURETYPE_UNSIGNED_INT, samplingMode = Texture.BILINEAR_SAMPLINGMODE, generateDepthBuffer = true) {

             super(name, size, scene, generateMipMaps, true, type, false, samplingMode, generateDepthBuffer);

             super(name, size, scene, generateMipMaps, true, type, false, samplingMode, generateDepthBuffer);

 

 

@@ -69,18 +88,23 @@ module BABYLON {
 
         private _preparePostProcesses(): void {

         private _preparePostProcesses(): void {

             this.clearPostProcesses(true);

             this.clearPostProcesses(true);

 

 

-            if (this._blurKernel) {

+            if (this._blurKernelX && this._blurKernelY) {

                 var engine = this.getScene().getEngine();

                 var engine = this.getScene().getEngine();

 

 

                 var textureType = engine.getCaps().textureFloatRender ? Engine.TEXTURETYPE_FLOAT : Engine.TEXTURETYPE_HALF_FLOAT;

                 var textureType = engine.getCaps().textureFloatRender ? Engine.TEXTURETYPE_FLOAT : Engine.TEXTURETYPE_HALF_FLOAT;

 

 

-                this._blurX = new BABYLON.BlurPostProcess("horizontal blur", new BABYLON.Vector2(1.0, 0), this._blurKernel, this._blurRatio, null, BABYLON.Texture.BILINEAR_SAMPLINGMODE, engine, false, textureType);

+                this._blurX = new BABYLON.BlurPostProcess("horizontal blur", new BABYLON.Vector2(1.0, 0), this._blurKernelX, this._blurRatio, null, BABYLON.Texture.BILINEAR_SAMPLINGMODE, engine, false, textureType);

                 this._blurX.autoClear = false;

                 this._blurX.autoClear = false;

-                this._blurX.alwaysForcePOT = false;

 

 

-                this._blurY = new BABYLON.BlurPostProcess("vertical blur", new BABYLON.Vector2(0, 1.0), this._blurKernel, this._blurRatio, null, BABYLON.Texture.BILINEAR_SAMPLINGMODE, engine, false, textureType);

+                if (this._blurRatio === 1) {

+                    this._blurX.outputTexture = this._texture;

+                } else {

+                    this._blurX.alwaysForcePOT = true;

+                }

+

+                this._blurY = new BABYLON.BlurPostProcess("vertical blur", new BABYLON.Vector2(0, 1.0), this._blurKernelY, this._blurRatio, null, BABYLON.Texture.BILINEAR_SAMPLINGMODE, engine, false, textureType);

                 this._blurY.autoClear = false;

                 this._blurY.autoClear = false;

-                this._blurY.alwaysForcePOT = true;

+                this._blurY.alwaysForcePOT = this._blurRatio !== 1;

 

 

                 this.addPostProcess(this._blurX);

                 this.addPostProcess(this._blurX);

                 this.addPostProcess(this._blurY);   

                 this.addPostProcess(this._blurY);

+ 20 - 5
src/Materials/Textures/babylon.texture.ts
查看文件 

@@ -96,11 +96,6 @@
 
             this._format = format;

             this._format = format;

 

 

             scene = this.getScene();

             scene = this.getScene();

-            if (!url) {

-                return;

-            }

-

-            this._texture = this._getFromCache(url, noMipmap, samplingMode);

 

 

             let load = () => {

             let load = () => {

                 if (this._onLoadObservarble && this._onLoadObservarble.hasObservers()) {

                 if (this._onLoadObservarble && this._onLoadObservarble.hasObservers()) {

@@ -115,6 +110,14 @@
 
                 }

                 }

             }

             }

 

 

+            if (!url) {

+                this._delayedOnLoad = load;

+                this._delayedOnError = onError;

+                return;

+            }

+

+            this._texture = this._getFromCache(url, noMipmap, samplingMode);

+

             if (!this._texture) {

             if (!this._texture) {

                 if (!scene.useDelayedTextureLoading) {

                 if (!scene.useDelayedTextureLoading) {

                     this._texture = scene.getEngine().createTexture(url, noMipmap, invertY, scene, this._samplingMode, load, onError, this._buffer, null, this._format);

                     this._texture = scene.getEngine().createTexture(url, noMipmap, invertY, scene, this._samplingMode, load, onError, this._buffer, null, this._format);

@@ -136,6 +139,12 @@
 
             }

             }

         }

         }

 

 

+        public updateURL(url: string): void {

+            this.url = url;

+            this.delayLoadState = Engine.DELAYLOADSTATE_NOTLOADED;

+            this.delayLoad();

+        }

+

         public delayLoad(): void {

         public delayLoad(): void {

             if (this.delayLoadState !== Engine.DELAYLOADSTATE_NOTLOADED) {

             if (this.delayLoadState !== Engine.DELAYLOADSTATE_NOTLOADED) {

                 return;

                 return;

@@ -149,6 +158,12 @@
 
                 if (this._deleteBuffer) {

                 if (this._deleteBuffer) {

                     delete this._buffer;

                     delete this._buffer;

                 }

                 }

+            } else {

+                if (this._texture.isReady) {

+                    Tools.SetImmediate(() => this._delayedOnLoad());

+                } else {

+                    this._texture.onLoadedCallbacks.push(this._delayedOnLoad);

+                }

             }

             }

         }

         }

+ 19 - 1
src/Math/babylon.math.ts
查看文件 

@@ -874,6 +874,12 @@
 
             return new Vector2(0, 0);

             return new Vector2(0, 0);

         }

         }

         /**

         /**

+         * Returns a new Vector2(1, 1)

+         */

+        public static One(): Vector2 {

+            return new Vector2(1, 1);

+        }

+        /**

          * Returns a new Vector2 set from the passed index element of the passed array.

          * Returns a new Vector2 set from the passed index element of the passed array.

          */

          */

         public static FromArray(array: ArrayLike<number>, offset: number = 0): Vector2 {

         public static FromArray(array: ArrayLike<number>, offset: number = 0): Vector2 {

@@ -1463,12 +1469,18 @@
 
         }

         }

 

 

         /**

         /**

-         * Returns a new Vector3 set to (0.0, 0.0, 0.0).  

+         * Returns a new Vector3 set to (0.0, 0.0, 0.0).

          */

          */

         public static Zero(): Vector3 {

         public static Zero(): Vector3 {

             return new Vector3(0.0, 0.0, 0.0);

             return new Vector3(0.0, 0.0, 0.0);

         }

         }

         /**

         /**

+         * Returns a new Vector3 set to (1.0, 1.0, 1.0).

+         */

+        public static One(): Vector3 {

+            return new Vector3(1.0, 1.0, 1.0);

+        }

+        /**

          * Returns a new Vector3 set to (0.0, 1.0, 0.0)

          * Returns a new Vector3 set to (0.0, 1.0, 0.0)

          */

          */

         public static Up(): Vector3 {

         public static Up(): Vector3 {

@@ -2200,6 +2212,12 @@
 
             return new Vector4(0.0, 0.0, 0.0, 0.0);

             return new Vector4(0.0, 0.0, 0.0, 0.0);

         }

         }

         /**

         /**

+         * Returns a new Vector4 set to (1.0, 1.0, 1.0, 1.0)

+         */

+        public static One(): Vector4 {

+            return new Vector4(1.0, 1.0, 1.0, 1.0);

+        }

+        /**

          * Returns a new normalized Vector4 from the passed one.  

          * Returns a new normalized Vector4 from the passed one.  

          */

          */

         public static Normalize(vector: Vector4): Vector4 {

         public static Normalize(vector: Vector4): Vector4 {

+ 3 - 3
src/Mesh/babylon.abstractMesh.ts
查看文件 

@@ -114,10 +114,10 @@
 
 

 

         // Properties

         // Properties

         public definedFacingForward = true; // orientation for POV movement & rotation

         public definedFacingForward = true; // orientation for POV movement & rotation

-        public position = new Vector3(0.0, 0.0, 0.0);

-        private _rotation = new Vector3(0.0, 0.0, 0.0);

+        public position = Vector3.Zero();

+        private _rotation = Vector3.Zero();

         private _rotationQuaternion: Quaternion;

         private _rotationQuaternion: Quaternion;

-        private _scaling = new Vector3(1.0, 1.0, 1.0);

+        private _scaling = Vector3.One();

         public billboardMode = AbstractMesh.BILLBOARDMODE_NONE;

         public billboardMode = AbstractMesh.BILLBOARDMODE_NONE;

         public visibility = 1.0;

         public visibility = 1.0;

         public alphaIndex = Number.MAX_VALUE;

         public alphaIndex = Number.MAX_VALUE;

+ 1 - 1
src/Mesh/babylon.meshBuilder.ts
查看文件 

@@ -1005,7 +1005,7 @@
 
             var normals = sourceMesh.getVerticesData(VertexBuffer.NormalKind);

             var normals = sourceMesh.getVerticesData(VertexBuffer.NormalKind);

             var position = options.position || Vector3.Zero();

             var position = options.position || Vector3.Zero();

             var normal = options.normal || Vector3.Up();

             var normal = options.normal || Vector3.Up();

-            var size = options.size || new Vector3(1, 1, 1);

+            var size = options.size || Vector3.One();

             var angle = options.angle || 0;

             var angle = options.angle || 0;

 

 

             // Getting correct rotation

             // Getting correct rotation

+ 1 - 1
src/Particles/babylon.solidParticle.ts
查看文件 

@@ -6,7 +6,7 @@ module BABYLON {
 
         public position = Vector3.Zero();               // position

         public position = Vector3.Zero();               // position

         public rotation = Vector3.Zero();               // rotation

         public rotation = Vector3.Zero();               // rotation

         public rotationQuaternion: Quaternion;          // quaternion, will overwrite rotation

         public rotationQuaternion: Quaternion;          // quaternion, will overwrite rotation

-        public scaling = new Vector3(1.0, 1.0, 1.0);    // scaling

+        public scaling = Vector3.One();                 // scaling

         public uvs = new Vector4(0.0, 0.0, 1.0, 1.0);   // uvs

         public uvs = new Vector4(0.0, 0.0, 1.0, 1.0);   // uvs

         public velocity = Vector3.Zero();               // velocity

         public velocity = Vector3.Zero();               // velocity

         public alive = true;                            // alive

         public alive = true;                            // alive

+ 3 - 0
src/PostProcess/babylon.postProcess.ts
查看文件 

@@ -268,6 +268,9 @@
 
                 target = this._shareOutputWithPostProcess.outputTexture;

                 target = this._shareOutputWithPostProcess.outputTexture;

             } else if (this._forcedOutputTexture) {

             } else if (this._forcedOutputTexture) {

                 target = this._forcedOutputTexture;

                 target = this._forcedOutputTexture;

+

+                this.width = this._forcedOutputTexture._width;

+                this.height = this._forcedOutputTexture._height;

             } else {

             } else {

                 target = this.outputTexture;

                 target = this.outputTexture;

             }

             }