glTF loader updates

Tools/Gulp/config.json

@@ -1533,6 +1533,8 @@
                     "../../loaders/src/glTF/2.0/babylon.glTFLoader.ts",
                     "../../loaders/src/glTF/2.0/babylon.glTFLoaderExtension.ts",
                     "../../loaders/src/glTF/2.0/Extensions/MSFT_lod.ts",
+                    "../../loaders/src/glTF/2.0/Extensions/MSFT_minecraftMesh.ts",
+                    "../../loaders/src/glTF/2.0/Extensions/MSFT_sRGBFactors.ts",
                     "../../loaders/src/glTF/2.0/Extensions/KHR_draco_mesh_compression.ts",
                     "../../loaders/src/glTF/2.0/Extensions/KHR_materials_pbrSpecularGlossiness.ts",
                     "../../loaders/src/glTF/2.0/Extensions/KHR_materials_unlit.ts",
@@ -1555,6 +1557,8 @@
                     "../../loaders/src/glTF/2.0/babylon.glTFLoader.ts",
                     "../../loaders/src/glTF/2.0/babylon.glTFLoaderExtension.ts",
                     "../../loaders/src/glTF/2.0/Extensions/MSFT_lod.ts",
+                    "../../loaders/src/glTF/2.0/Extensions/MSFT_minecraftMesh.ts",
+                    "../../loaders/src/glTF/2.0/Extensions/MSFT_sRGBFactors.ts",
                     "../../loaders/src/glTF/2.0/Extensions/KHR_draco_mesh_compression.ts",
                     "../../loaders/src/glTF/2.0/Extensions/KHR_materials_pbrSpecularGlossiness.ts",
                     "../../loaders/src/glTF/2.0/Extensions/KHR_materials_unlit.ts",

loaders/src/glTF/2.0/Extensions/KHR_materials_pbrSpecularGlossiness.ts

@@ -25,7 +25,7 @@ module BABYLON.GLTF2.Extensions {
                     const promises = new Array<Promise<void>>();
 
                     const name = material.name || `materialSG_${material._index}`;
-                    const babylonMaterial = this._loader._createMaterial(PBRMaterial, name, babylonDrawMode);
+                    const babylonMaterial = this._loader._createMaterial(name, babylonDrawMode);
 
                     promises.push(this._loader._loadMaterialBasePropertiesAsync(context, material, babylonMaterial));
                     promises.push(this._loadSpecularGlossinessPropertiesAsync(extensionContext, material, extension, babylonMaterial));

loaders/src/glTF/2.0/Extensions/KHR_materials_unlit.ts

@@ -15,7 +15,7 @@ module BABYLON.GLTF2.Extensions {
                 let babylonData = material._babylonData[babylonDrawMode];
                 if (!babylonData) {
                     const name = material.name || `materialUnlit_${material._index}`;
-                    const babylonMaterial = this._loader._createMaterial(PBRMaterial, name, babylonDrawMode);
+                    const babylonMaterial = this._loader._createMaterial(name, babylonDrawMode);
                     babylonMaterial.unlit = true;
 
                     const promise = this._loadUnlitPropertiesAsync(context, material, babylonMaterial);

loaders/src/glTF/2.0/Extensions/MSFT_minecraftMesh.ts

@@ -0,0 +1,36 @@
+/// <reference path="../../../../../dist/preview release/babylon.d.ts"/>
+
+module BABYLON.GLTF2.Extensions {
+    const NAME = "MSFT_minecraftMesh";
+
+    /** @hidden */
+    export class MSFT_minecraftMesh extends GLTFLoaderExtension {
+        public readonly name = NAME;
+
+        constructor(loader: GLTFLoader) {
+            super(loader);
+
+            const meshes = loader._gltf.meshes;
+            if (meshes && meshes.length) {
+                for (const mesh of meshes) {
+                    if (mesh && mesh.extras && mesh.extras.MSFT_minecraftMesh) {
+                        this._loader.onMaterialLoadedObservable.add(this._onMaterialLoaded);
+                        break;
+                    }
+                }
+            }
+        }
+
+        private _onMaterialLoaded = (material: PBRMaterial): void => {
+            if (material.needAlphaBlending()) {
+                material.forceDepthWrite = true;
+                material.separateCullingPass = true;
+            }
+
+            material.backFaceCulling = material.forceDepthWrite;
+            material.twoSidedLighting = true;
+        };
+    }
+
+    GLTFLoader._Register(NAME, loader => new MSFT_minecraftMesh(loader));
+}

loaders/src/glTF/2.0/Extensions/MSFT_sRGBFactors.ts

@@ -0,0 +1,36 @@
+/// <reference path="../../../../../dist/preview release/babylon.d.ts"/>
+
+module BABYLON.GLTF2.Extensions {
+    const NAME = "MSFT_sRGBFactors";
+
+    /** @hidden */
+    export class MSFT_sRGBFactors extends GLTFLoaderExtension {
+        public readonly name = NAME;
+
+        constructor(loader: GLTFLoader) {
+            super(loader);
+
+            const materials = loader._gltf.materials;
+            if (materials && materials.length) {
+                for (const material of materials) {
+                    if (material && material.extras && material.extras.MSFT_sRGBFactors) {
+                        this._loader.onMaterialLoadedObservable.add(this._onMaterialLoaded);
+                        break;
+                    }
+                }
+            }
+        }
+
+        private _onMaterialLoaded = (material: PBRMaterial): void => {
+            if (!material.albedoTexture) {
+                material.albedoColor.toLinearSpaceToRef(material.albedoColor);
+            }
+
+            if (!material.reflectivityTexture) {
+                material.reflectivityColor.toLinearSpaceToRef(material.reflectivityColor);
+            }
+        };
+    }
+
+    GLTFLoader._Register(NAME, loader => new MSFT_sRGBFactors(loader));
+}

loaders/src/glTF/2.0/babylon.glTFLoader.ts

@@ -10,12 +10,6 @@ module BABYLON.GLTF2 {
         _total?: number;
     }
 
-    /** @hidden */
-    export interface _MaterialConstructor<T extends Material> {
-        readonly prototype: T;
-        new(name: string, scene: Scene): T;
-    }
-
     /**
      * Loader for loading a glTF 2.0 asset
      */
@@ -205,14 +199,13 @@ module BABYLON.GLTF2 {
 
         private _loadAsync(nodes: Nullable<Array<_ILoaderNode>>, scene: Scene, data: IGLTFLoaderData, rootUrl: string, onProgress?: (event: SceneLoaderProgressEvent) => void): Promise<void> {
             return Promise.resolve().then(() => {
-                this._loadExtensions();
-
                 this._babylonScene = scene;
                 this._rootUrl = rootUrl;
                 this._progressCallback = onProgress;
                 this._state = GLTFLoaderState.LOADING;
 
                 this._loadData(data);
+                this._loadExtensions();
                 this._checkExtensions();
 
                 const promises = new Array<Promise<void>>();
@@ -266,17 +259,6 @@ module BABYLON.GLTF2 {
             });
         }
 
-        private _loadExtensions(): void {
-            for (const name of GLTFLoader._ExtensionNames) {
-                const extension = GLTFLoader._ExtensionFactories[name](this);
-                this._extensions[name] = extension;
-
-                this.onExtensionLoadedObservable.notifyObservers(extension);
-            }
-
-            this.onExtensionLoadedObservable.clear();
-        }
-
         private _loadData(data: IGLTFLoaderData): void {
             this._gltf = data.json as _ILoaderGLTF;
             this._setupData();
@@ -330,6 +312,17 @@ module BABYLON.GLTF2 {
             }
         }
 
+        private _loadExtensions(): void {
+            for (const name of GLTFLoader._ExtensionNames) {
+                const extension = GLTFLoader._ExtensionFactories[name](this);
+                this._extensions[name] = extension;
+
+                this.onExtensionLoadedObservable.notifyObservers(extension);
+            }
+
+            this.onExtensionLoadedObservable.clear();
+        }
+
         private _checkExtensions(): void {
             if (this._gltf.extensionsRequired) {
                 for (const name of this._gltf.extensionsRequired) {
@@ -1268,7 +1261,7 @@ module BABYLON.GLTF2 {
         private _getDefaultMaterial(drawMode: number): Material {
             let babylonMaterial = this._defaultBabylonMaterials[drawMode];
             if (!babylonMaterial) {
-                babylonMaterial = this._createMaterial(PBRMaterial, "__gltf_default", drawMode);
+                babylonMaterial = this._createMaterial("__gltf_default", drawMode);
                 babylonMaterial.transparencyMode = PBRMaterial.PBRMATERIAL_OPAQUE;
                 babylonMaterial.metallic = 1;
                 babylonMaterial.roughness = 1;
@@ -1333,7 +1326,7 @@ module BABYLON.GLTF2 {
                 const promises = new Array<Promise<void>>();
 
                 const name = material.name || `materialSG_${material._index}`;
-                const babylonMaterial = this._createMaterial(PBRMaterial, name, babylonDrawMode);
+                const babylonMaterial = this._createMaterial(name, babylonDrawMode);
 
                 promises.push(this._loadMaterialBasePropertiesAsync(context, material, babylonMaterial));
                 promises.push(this._loadMaterialMetallicRoughnessPropertiesAsync(context, material, babylonMaterial));
@@ -1356,10 +1349,11 @@ module BABYLON.GLTF2 {
         }
 
         /** @hidden */
-        public _createMaterial<T extends Material>(type: _MaterialConstructor<T>, name: string, drawMode: number): T {
-            const babylonMaterial = new type(name, this._babylonScene);
+        public _createMaterial(name: string, drawMode: number): PBRMaterial {
+            const babylonMaterial = new PBRMaterial(name, this._babylonScene);
             babylonMaterial.sideOrientation = this._babylonScene.useRightHandedSystem ? Material.CounterClockWiseSideOrientation : Material.ClockWiseSideOrientation;
             babylonMaterial.fillMode = drawMode;
+            babylonMaterial.enableSpecularAntiAliasing = true;
             return babylonMaterial;
         }