Merge remote-tracking branch 'remotes/BabylonJS/master' into BabylonJS-master

Babylon/Mesh/babylon.mesh.js

@@ -140,7 +140,7 @@ var BABYLON = BABYLON || {};
     };
 
     BABYLON.Mesh.prototype.getPivotMatrix = function () {
-        return this._localMatrix;
+        return this._pivotMatrix;
     };
 
     BABYLON.Mesh.prototype.isSynchronized = function () {

Exporters/XNA - OBJ/BabylonExport.Core/Entities/Mesh.cs

@@ -28,7 +28,7 @@ namespace BabylonExport.Core
         public void AddPart(string name, List<T> addedVertices, List<int> addedIndices)
         {
             if (concatenatedName == "")
-                concatenatedName += " # ";
+                concatenatedName += "#"; // ProfessorF-Removed spaces before and after #
 
             concatenatedName += name;
 

Exporters/XNA - OBJ/BabylonExport.Core/Entities/StandardMaterial.cs

@@ -70,6 +70,11 @@ namespace BabylonExport.Core
             babylonMaterial.diffuseTexture = new BabylonTexture();
             babylonMaterial.diffuseTexture.name = Path.GetFileName(DiffuseTexture);
 
+            if (babylonMaterial.diffuseTexture.name.ToLower().EndsWith(".png"))
+            {
+                babylonMaterial.diffuseTexture.hasAlpha = true;
+            }
+
             scene.AddTexture(DiffuseTexture);
         }
     }

Exporters/XNA - OBJ/BabylonExport.Core/Exporters/IExporter.cs

@@ -8,6 +8,6 @@ namespace BabylonExport.Core
 
         string SupportedExtensions { get; }
 
-        void GenerateBabylonFile(string file, string outputFile, bool skinned);
+        void GenerateBabylonFile(string file, string outputFile, bool skinned, bool rightToLeft);
     }
 }

Exporters/XNA - OBJ/BabylonExport.Core/Exporters/MXB/NovaExporter.cs

@@ -39,7 +39,7 @@ namespace BabylonExport.Core.Exporters
             }
         }
 
-        public void GenerateBabylonFile(string file, string outputFile, bool skinned)
+        public void GenerateBabylonFile(string file, string outputFile, bool skinned, bool rightToLeft)
         {
             try
             {

Exporters/XNA - OBJ/BabylonExport.Core/Exporters/OBJ/ObjExporter.cs

@@ -35,7 +35,7 @@ namespace BabylonExport.Core.Exporters
             }
         }
 
-        public void GenerateBabylonFile(string file, string outputFile, bool skinned)
+        public void GenerateBabylonFile(string file, string outputFile, bool skinned, bool rightToLeft)
         {
             var text = File.ReadAllText(file);
 

Exporters/XNA - OBJ/BabylonExport.Core/Exporters/ThroughXNA/XNAExporter.cs

@@ -26,7 +26,7 @@ namespace BabylonExport.Core.Exporters.XNA
 
         private int texturesCount = 0;
 
-        public void GenerateBabylonFile(string file, string outputFile, bool skinned)
+        public void GenerateBabylonFile(string file, string outputFile, bool skinned, bool rightToLeft)
         {
             if (OnImportProgressChanged != null)
                 OnImportProgressChanged(0);
@@ -54,7 +54,7 @@ namespace BabylonExport.Core.Exporters.XNA
             if (string.IsNullOrEmpty(buildError))
             {
                 var model = contentManager.Load<Model>("Model");
-                ParseModel(model, scene);
+                ParseModel(model, scene, rightToLeft);
             }
             else
             {
@@ -79,7 +79,7 @@ namespace BabylonExport.Core.Exporters.XNA
                 OnImportProgressChanged(100);
         }
 
-        void ParseModel(Model model, BabylonScene scene)
+        void ParseModel(Model model, BabylonScene scene, bool rightToLeft)
         {
             var effects = model.Meshes.SelectMany(m => m.Effects).ToList();
             var meshes = model.Meshes.ToList();
@@ -116,7 +116,7 @@ namespace BabylonExport.Core.Exporters.XNA
 
             foreach (var mesh in meshes)
             {
-                ParseMesh(mesh, scene, currentSkeleton);
+                ParseMesh(mesh, scene, currentSkeleton, rightToLeft);
                 if (OnImportProgressChanged != null)
                     OnImportProgressChanged(((progress++) * 100) / total);
             }
@@ -176,7 +176,7 @@ namespace BabylonExport.Core.Exporters.XNA
             skeleton.bones = bones.ToArray();
         }
 
-        void ParseMesh(ModelMesh modelMesh, BabylonScene scene, BabylonSkeleton skeleton)
+        void ParseMesh(ModelMesh modelMesh, BabylonScene scene, BabylonSkeleton skeleton, bool rightToLeft)
         {
             var proxyID = ProxyMesh.CreateBabylonMesh(modelMesh.Name, scene);
             int indexName = 0;
@@ -188,6 +188,16 @@ namespace BabylonExport.Core.Exporters.XNA
                 var indices = new ushort[part.PrimitiveCount * 3];
                 part.IndexBuffer.GetData(part.StartIndex * 2, indices, 0, indices.Length);
 
+                if (rightToLeft)
+                {
+                    for (int ib = 0; ib < indices.Length; ib += 3) // reverse winding of triangles
+                    {
+                        ushort ti = indices[ib];
+                        indices[ib] = indices[ib + 2];
+                        indices[ib + 2] = ti;
+                    }
+                }
+
                 if (part.VertexBuffer.VertexDeclaration.VertexStride >= PositionNormalTexturedWeights.Stride)
                 {
                     var mesh = new Mesh<PositionNormalTexturedWeights>(material);
@@ -198,13 +208,19 @@ namespace BabylonExport.Core.Exporters.XNA
                     for (int index = 0; index < vertices.Length; index++)
                     {
                         vertices[index].TextureCoordinates.Y = 1.0f - vertices[index].TextureCoordinates.Y;
+                        if (rightToLeft)
+                        {
+                            vertices[index].Position.Z = -vertices[index].Position.Z;
+                            vertices[index].Normal.Z = -vertices[index].Normal.Z;
+                        }
                     }
 
-                    mesh.AddPart(indexName.ToString(), vertices.ToList(), indices.Select(i => (int)i).ToList());
+                    mesh.AddPart(modelMesh.Name+"#"+indexName.ToString(), vertices.ToList(), indices.Select(i => (int)i).ToList());
                     mesh.CreateBabylonMesh(scene, proxyID, skeleton);
                 }
                 else
                 {
+                    if (part.VertexBuffer.VertexDeclaration.VertexStride < PositionNormalTextured.Stride) return; // Error: Not a PositionNormalTextured mesh!
                     var mesh = new Mesh<PositionNormalTextured>(material);
                     var vertices = new PositionNormalTextured[part.NumVertices];
                     part.VertexBuffer.GetData(part.VertexOffset * part.VertexBuffer.VertexDeclaration.VertexStride, vertices, 0, vertices.Length, part.VertexBuffer.VertexDeclaration.VertexStride);
@@ -212,9 +228,14 @@ namespace BabylonExport.Core.Exporters.XNA
                     for (int index = 0; index < vertices.Length; index++)
                     {
                         vertices[index].TextureCoordinates.Y = 1.0f - vertices[index].TextureCoordinates.Y;
+                        if (rightToLeft)
+                        {
+                            vertices[index].Position.Z = -vertices[index].Position.Z;
+                            vertices[index].Normal.Z = -vertices[index].Normal.Z;
+                        }
                     }
 
-                    mesh.AddPart(indexName.ToString(), vertices.ToList(), indices.Select(i => (int)i).ToList());
+                    mesh.AddPart(modelMesh.Name + "#" + indexName.ToString(), vertices.ToList(), indices.Select(i => (int)i).ToList());
                     mesh.CreateBabylonMesh(scene, proxyID, skeleton);
                 }
 

Exporters/XNA - OBJ/BabylonExport/Program.cs

@@ -43,6 +43,7 @@ namespace BabylonExport
                     // Parsing arguments
                     string input = "";
                     bool skinned = false;
+                    bool rightToLeft = false;
                     foreach (var arg in args)
                     {
                         var order = arg.Substring(0, 3);
@@ -58,6 +59,9 @@ namespace BabylonExport
                             case "/sk":
                                 skinned = true;
                                 break;
+                            case "/rl":
+                                rightToLeft = true;
+                                break;
                             default:
                                 DisplayUsage();
                                 return;
@@ -104,7 +108,7 @@ namespace BabylonExport
                                 Console.WriteLine("Generation of " + outputName + " started");
                                 Console.WriteLine();
                                 Console.ResetColor();
-                                importer.GenerateBabylonFile(input, outputName, skinned);
+                                importer.GenerateBabylonFile(input, outputName, skinned, rightToLeft);
                                 Console.ForegroundColor = ConsoleColor.Green;
                                 Console.WriteLine();
                                 Console.WriteLine();
@@ -163,7 +167,7 @@ namespace BabylonExport
 
         static void DisplayUsage()
         {
-            Console.WriteLine("Babylon Import usage: BabylonImport.exe /i:\"source file\" /o:\"output folder\" [/sk]");
+            Console.WriteLine("Babylon Import usage: BabylonImport.exe /i:\"source file\" /o:\"output folder\" [/sk] [/rl]");
         }
     }
 }

Typescript/Animations/babylon.animation.d.ts

@@ -6,16 +6,16 @@ declare module BABYLON {
         targetProperty: string;
         targetPropertyPath: string[];
         framePerSecond: number;
-        dataType: string;
+        dataType: number;
         loopMode: number;
         _keys: number[];
         _offsetCache: Object;
         _highLimitsCache: Object;
 
-        constructor(name: string, targetProperty: string, framePerSecond: number, dataType: string, loopMode: number);
+        constructor(name: string, targetProperty: string, framePerSecond: number, dataType: number, loopMode: number);
 
         clone(): Animation;
-        setKeys(values: number[]);
+        setKeys(values: any[]);
         _interpolate(currentFrame: number, repeatCount: number, loopMode: number, offsetValue: number, highLimitValue: number);
         animate(target: Object, delay: number, from: number, to: number, loop: boolean, speedRatio: number): boolean;
         
@@ -28,4 +28,4 @@ declare module BABYLON {
         static ANIMATIONLOOPMODE_CYCLE: number;
         static ANIMATIONLOOPMODE_CONSTANT: number;
     }
-}
+}   

Typescript/Materials/textures/babylon.texture.d.ts

@@ -6,7 +6,7 @@ declare module BABYLON {
         url: string
         animations: Animation[];
 
-        constructor(url: string, scene: Scene, noMipmap: boolean, invertY: boolean);
+        constructor(url: string, scene: Scene, noMipmap?: boolean, invertY?: boolean);
 
         static EXPLICIT_MODE: number;
         static SPHERICAL_MODE: number;

Typescript/Mesh/babylon.mesh.d.ts

@@ -14,7 +14,7 @@ declare module BABYLON {
         subMeshes: SubMesh[];
         animations: Animation[];
 
-        constructor(name: string, vertexDeclaration: number[], scene: Scene);
+        constructor(name: string, scene: Scene);
 
         static BILLBOARDMODE_NONE: number;
         static BILLBOARDMODE_X: number;

Typescript/Mesh/babylon.vertexBuffer.d.ts

@@ -10,12 +10,12 @@ declare module BABYLON {
         update(data: any[]): void;
         dispose(): void;
 
-        PositionKind: string;
-        NormalKind: string;
-        UVKind: string;
-        UV2Kind: string;
-        ColorKind: string;
-        MatricesIndicesKind: string;
-        MatricesWeightsKind: string;
+        static PositionKind: string;
+        static NormalKind: string;
+        static UVKind: string;
+        static UV2Kind: string;
+        static ColorKind: string;
+        static MatricesIndicesKind: string;
+        static MatricesWeightsKind: string;
     }
 }

Typescript/Tools/babylon.tools.d.ts

@@ -20,7 +20,7 @@ declare module BABYLON.Tools {
     function _MeasureFps(): void;
 
     class SmartArray {
-        data: Array;
+        data: any[];
         length: number;
 
         constructor(capacity: number);

Typescript/babylon.scene.d.ts

@@ -57,8 +57,8 @@ declare module BABYLON {
         executeWhenReady(func: Function): void;
         getWaitingItemsCount(): number;
 
-        beginAnimation(target: string, from: number, to: number, loop: boolean, speedRatio: number, onAnimationEnd: Function): void;
-        stopAnimation(target: string);
+        beginAnimation(target: Mesh, from: number, to: number, loop: boolean, speedRatio?: number, onAnimationEnd?: Function): void;
+        stopAnimation(target: Mesh);
 
         getViewMatrix(): Matrix;
         getProjectionMatrix(): Matrix;