|
|
@@ -2692,6 +2692,7 @@ var BABYLON;
|
|
|
this._state = null;
|
|
|
this._extensions = {};
|
|
|
this._defaultSampler = {};
|
|
|
+ this._defaultBabylonMaterials = {};
|
|
|
this._requests = new Array();
|
|
|
this.coordinateSystemMode = BABYLON.GLTFLoaderCoordinateSystemMode.AUTO;
|
|
|
this.animationStartMode = BABYLON.GLTFLoaderAnimationStartMode.FIRST;
|
|
|
@@ -3076,12 +3077,13 @@ var BABYLON;
|
|
|
new BABYLON.Geometry(babylonMesh.name, _this._babylonScene, babylonVertexData, false, babylonMesh);
|
|
|
return _this._loadMorphTargetsAsync(context, primitive, babylonMesh, babylonVertexData);
|
|
|
}));
|
|
|
+ var babylonDrawMode = GLTFLoader._GetDrawMode(context, primitive.mode);
|
|
|
if (primitive.material == undefined) {
|
|
|
- babylonMesh.material = this._getDefaultMaterial();
|
|
|
+ babylonMesh.material = this._getDefaultMaterial(babylonDrawMode);
|
|
|
}
|
|
|
else {
|
|
|
var material = GLTFLoader._GetProperty(context + "/material}", this._gltf.materials, primitive.material);
|
|
|
- promises.push(this._loadMaterialAsync("#/materials/" + material._index, material, babylonMesh, function (babylonMaterial) {
|
|
|
+ promises.push(this._loadMaterialAsync("#/materials/" + material._index, material, babylonMesh, babylonDrawMode, function (babylonMaterial) {
|
|
|
babylonMesh.material = babylonMaterial;
|
|
|
}));
|
|
|
}
|
|
|
@@ -3097,10 +3099,6 @@ var BABYLON;
|
|
|
if (!attributes) {
|
|
|
throw new Error(context + ": Attributes are missing");
|
|
|
}
|
|
|
- if (primitive.mode != undefined && primitive.mode !== 4 /* TRIANGLES */) {
|
|
|
- // TODO: handle other primitive modes
|
|
|
- throw new Error(context + ": Mode (" + primitive.mode + ") is not currently supported");
|
|
|
- }
|
|
|
var promises = new Array();
|
|
|
var babylonVertexData = new BABYLON.VertexData();
|
|
|
if (primitive.indices == undefined) {
|
|
|
@@ -3484,19 +3482,9 @@ var BABYLON;
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
- var keys;
|
|
|
- if (data.input.length === 1) {
|
|
|
- var key = getNextKey(0);
|
|
|
- keys = [
|
|
|
- { frame: key.frame, value: key.value },
|
|
|
- { frame: key.frame + 1, value: key.value }
|
|
|
- ];
|
|
|
- }
|
|
|
- else {
|
|
|
- keys = new Array(data.input.length);
|
|
|
- for (var frameIndex = 0; frameIndex < data.input.length; frameIndex++) {
|
|
|
- keys[frameIndex] = getNextKey(frameIndex);
|
|
|
- }
|
|
|
+ var keys = new Array(data.input.length);
|
|
|
+ for (var frameIndex = 0; frameIndex < data.input.length; frameIndex++) {
|
|
|
+ keys[frameIndex] = getNextKey(frameIndex);
|
|
|
}
|
|
|
if (targetPath === "influence") {
|
|
|
var _loop_1 = function (targetIndex) {
|
|
|
@@ -3657,22 +3645,19 @@ var BABYLON;
|
|
|
}
|
|
|
return targetBuffer;
|
|
|
};
|
|
|
- GLTFLoader.prototype._getDefaultMaterial = function () {
|
|
|
- var id = "__gltf_default";
|
|
|
- var babylonMaterial = this._babylonScene.getMaterialByName(id);
|
|
|
+ GLTFLoader.prototype._getDefaultMaterial = function (drawMode) {
|
|
|
+ var babylonMaterial = this._defaultBabylonMaterials[drawMode];
|
|
|
if (!babylonMaterial) {
|
|
|
- babylonMaterial = new BABYLON.PBRMaterial(id, this._babylonScene);
|
|
|
+ babylonMaterial = this._createMaterial(BABYLON.PBRMaterial, "__gltf_default", drawMode);
|
|
|
babylonMaterial.transparencyMode = BABYLON.PBRMaterial.PBRMATERIAL_OPAQUE;
|
|
|
- babylonMaterial.sideOrientation = this._babylonScene.useRightHandedSystem ? BABYLON.Material.CounterClockWiseSideOrientation : BABYLON.Material.ClockWiseSideOrientation;
|
|
|
babylonMaterial.metallic = 1;
|
|
|
babylonMaterial.roughness = 1;
|
|
|
this.onMaterialLoadedObservable.notifyObservers(babylonMaterial);
|
|
|
}
|
|
|
return babylonMaterial;
|
|
|
};
|
|
|
- GLTFLoader.prototype._loadMaterialMetallicRoughnessPropertiesAsync = function (context, material) {
|
|
|
+ GLTFLoader.prototype._loadMaterialMetallicRoughnessPropertiesAsync = function (context, material, babylonMaterial) {
|
|
|
var promises = new Array();
|
|
|
- var babylonMaterial = material._babylonMaterial;
|
|
|
// Ensure metallic workflow
|
|
|
babylonMaterial.metallic = 1;
|
|
|
babylonMaterial.roughness = 1;
|
|
|
@@ -3701,36 +3686,42 @@ var BABYLON;
|
|
|
babylonMaterial.useRoughnessFromMetallicTextureAlpha = false;
|
|
|
}
|
|
|
}
|
|
|
- this._loadMaterialAlphaProperties(context, material);
|
|
|
+ this._loadMaterialAlphaProperties(context, material, babylonMaterial);
|
|
|
return Promise.all(promises).then(function () { });
|
|
|
};
|
|
|
- GLTFLoader.prototype._loadMaterialAsync = function (context, material, babylonMesh, assign) {
|
|
|
- var promise = GLTF2.GLTFLoaderExtension._LoadMaterialAsync(this, context, material, babylonMesh, assign);
|
|
|
+ GLTFLoader.prototype._loadMaterialAsync = function (context, material, babylonMesh, babylonDrawMode, assign) {
|
|
|
+ var promise = GLTF2.GLTFLoaderExtension._LoadMaterialAsync(this, context, material, babylonMesh, babylonDrawMode, assign);
|
|
|
if (promise) {
|
|
|
return promise;
|
|
|
}
|
|
|
- material._babylonMeshes = material._babylonMeshes || [];
|
|
|
- material._babylonMeshes.push(babylonMesh);
|
|
|
- if (!material._loaded) {
|
|
|
+ material._babylonData = material._babylonData || {};
|
|
|
+ var babylonData = material._babylonData[babylonDrawMode];
|
|
|
+ if (!babylonData) {
|
|
|
var promises = new Array();
|
|
|
- var babylonMaterial = this._createMaterial(material);
|
|
|
- material._babylonMaterial = babylonMaterial;
|
|
|
- promises.push(this._loadMaterialBasePropertiesAsync(context, material));
|
|
|
- promises.push(this._loadMaterialMetallicRoughnessPropertiesAsync(context, material));
|
|
|
+ var name_3 = material.name || "materialSG_" + material._index;
|
|
|
+ var babylonMaterial = this._createMaterial(BABYLON.PBRMaterial, name_3, babylonDrawMode);
|
|
|
+ promises.push(this._loadMaterialBasePropertiesAsync(context, material, babylonMaterial));
|
|
|
+ promises.push(this._loadMaterialMetallicRoughnessPropertiesAsync(context, material, babylonMaterial));
|
|
|
this.onMaterialLoadedObservable.notifyObservers(babylonMaterial);
|
|
|
- material._loaded = Promise.all(promises).then(function () { });
|
|
|
+ babylonData = {
|
|
|
+ material: babylonMaterial,
|
|
|
+ meshes: [],
|
|
|
+ loaded: Promise.all(promises).then(function () { })
|
|
|
+ };
|
|
|
+ material._babylonData[babylonDrawMode] = babylonData;
|
|
|
}
|
|
|
- assign(material._babylonMaterial);
|
|
|
- return material._loaded;
|
|
|
+ babylonData.meshes.push(babylonMesh);
|
|
|
+ assign(babylonData.material);
|
|
|
+ return babylonData.loaded;
|
|
|
};
|
|
|
- GLTFLoader.prototype._createMaterial = function (material) {
|
|
|
- var babylonMaterial = new BABYLON.PBRMaterial(material.name || "material" + material._index, this._babylonScene);
|
|
|
+ GLTFLoader.prototype._createMaterial = function (type, name, drawMode) {
|
|
|
+ var babylonMaterial = new type(name, this._babylonScene);
|
|
|
babylonMaterial.sideOrientation = this._babylonScene.useRightHandedSystem ? BABYLON.Material.CounterClockWiseSideOrientation : BABYLON.Material.ClockWiseSideOrientation;
|
|
|
+ babylonMaterial.fillMode = drawMode;
|
|
|
return babylonMaterial;
|
|
|
};
|
|
|
- GLTFLoader.prototype._loadMaterialBasePropertiesAsync = function (context, material) {
|
|
|
+ GLTFLoader.prototype._loadMaterialBasePropertiesAsync = function (context, material, babylonMaterial) {
|
|
|
var promises = new Array();
|
|
|
- var babylonMaterial = material._babylonMaterial;
|
|
|
babylonMaterial.emissiveColor = material.emissiveFactor ? BABYLON.Color3.FromArray(material.emissiveFactor) : new BABYLON.Color3(0, 0, 0);
|
|
|
if (material.doubleSided) {
|
|
|
babylonMaterial.backFaceCulling = false;
|
|
|
@@ -3762,8 +3753,7 @@ var BABYLON;
|
|
|
}
|
|
|
return Promise.all(promises).then(function () { });
|
|
|
};
|
|
|
- GLTFLoader.prototype._loadMaterialAlphaProperties = function (context, material) {
|
|
|
- var babylonMaterial = material._babylonMaterial;
|
|
|
+ GLTFLoader.prototype._loadMaterialAlphaProperties = function (context, material, babylonMaterial) {
|
|
|
var alphaMode = material.alphaMode || "OPAQUE" /* OPAQUE */;
|
|
|
switch (alphaMode) {
|
|
|
case "OPAQUE" /* OPAQUE */: {
|
|
|
@@ -3983,21 +3973,36 @@ var BABYLON;
|
|
|
GLTFLoader._ValidateUri = function (uri) {
|
|
|
return (BABYLON.Tools.IsBase64(uri) || uri.indexOf("..") === -1);
|
|
|
};
|
|
|
+ GLTFLoader._GetDrawMode = function (context, mode) {
|
|
|
+ mode = mode || 4 /* TRIANGLES */;
|
|
|
+ switch (mode) {
|
|
|
+ case 0 /* POINTS */: return BABYLON.Material.PointListDrawMode;
|
|
|
+ case 1 /* LINES */: return BABYLON.Material.LineListDrawMode;
|
|
|
+ case 2 /* LINE_LOOP */: return BABYLON.Material.LineLoopDrawMode;
|
|
|
+ case 3 /* LINE_STRIP */: return BABYLON.Material.LineStripDrawMode;
|
|
|
+ case 4 /* TRIANGLES */: return BABYLON.Material.TriangleFillMode;
|
|
|
+ case 5 /* TRIANGLE_STRIP */: return BABYLON.Material.TriangleStripDrawMode;
|
|
|
+ case 6 /* TRIANGLE_FAN */: return BABYLON.Material.TriangleFanDrawMode;
|
|
|
+ }
|
|
|
+ throw new Error(context + ": Invalid mesh primitive mode (" + mode + ")");
|
|
|
+ };
|
|
|
GLTFLoader.prototype._compileMaterialsAsync = function () {
|
|
|
var promises = new Array();
|
|
|
if (this._gltf.materials) {
|
|
|
for (var _i = 0, _a = this._gltf.materials; _i < _a.length; _i++) {
|
|
|
var material = _a[_i];
|
|
|
- var babylonMaterial = material._babylonMaterial;
|
|
|
- var babylonMeshes = material._babylonMeshes;
|
|
|
- if (babylonMaterial && babylonMeshes) {
|
|
|
- for (var _b = 0, babylonMeshes_1 = babylonMeshes; _b < babylonMeshes_1.length; _b++) {
|
|
|
- var babylonMesh = babylonMeshes_1[_b];
|
|
|
- // Ensure nonUniformScaling is set if necessary.
|
|
|
- babylonMesh.computeWorldMatrix(true);
|
|
|
- promises.push(babylonMaterial.forceCompilationAsync(babylonMesh));
|
|
|
- if (this.useClipPlane) {
|
|
|
- promises.push(babylonMaterial.forceCompilationAsync(babylonMesh, { clipPlane: true }));
|
|
|
+ if (material._babylonData) {
|
|
|
+ for (var babylonDrawMode in material._babylonData) {
|
|
|
+ var babylonData = material._babylonData[babylonDrawMode];
|
|
|
+ for (var _b = 0, _c = babylonData.meshes; _b < _c.length; _b++) {
|
|
|
+ var babylonMesh = _c[_b];
|
|
|
+ // Ensure nonUniformScaling is set if necessary.
|
|
|
+ babylonMesh.computeWorldMatrix(true);
|
|
|
+ var babylonMaterial = babylonData.material;
|
|
|
+ promises.push(babylonMaterial.forceCompilationAsync(babylonMesh));
|
|
|
+ if (this.useClipPlane) {
|
|
|
+ promises.push(babylonMaterial.forceCompilationAsync(babylonMesh, { clipPlane: true }));
|
|
|
+ }
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
@@ -4037,8 +4042,8 @@ var BABYLON;
|
|
|
delete this._gltf;
|
|
|
delete this._babylonScene;
|
|
|
this._completePromises.length = 0;
|
|
|
- for (var name_3 in this._extensions) {
|
|
|
- this._extensions[name_3].dispose();
|
|
|
+ for (var name_4 in this._extensions) {
|
|
|
+ this._extensions[name_4].dispose();
|
|
|
}
|
|
|
this._extensions = {};
|
|
|
delete this._rootBabylonMesh;
|
|
|
@@ -4049,8 +4054,8 @@ var BABYLON;
|
|
|
};
|
|
|
GLTFLoader.prototype._applyExtensions = function (actionAsync) {
|
|
|
for (var _i = 0, _a = GLTFLoader._Names; _i < _a.length; _i++) {
|
|
|
- var name_4 = _a[_i];
|
|
|
- var extension = this._extensions[name_4];
|
|
|
+ var name_5 = _a[_i];
|
|
|
+ var extension = this._extensions[name_5];
|
|
|
if (extension.enabled) {
|
|
|
var promise = actionAsync(extension);
|
|
|
if (promise) {
|
|
|
@@ -4092,7 +4097,7 @@ var BABYLON;
|
|
|
/** Override this method to modify the default behavior for loading mesh primitive vertex data. */
|
|
|
GLTFLoaderExtension.prototype._loadVertexDataAsync = function (context, primitive, babylonMesh) { return null; };
|
|
|
/** Override this method to modify the default behavior for loading materials. */
|
|
|
- GLTFLoaderExtension.prototype._loadMaterialAsync = function (context, material, babylonMesh, assign) { return null; };
|
|
|
+ GLTFLoaderExtension.prototype._loadMaterialAsync = function (context, material, babylonMesh, babylonDrawMode, assign) { return null; };
|
|
|
/** Override this method to modify the default behavior for loading uris. */
|
|
|
GLTFLoaderExtension.prototype._loadUriAsync = function (context, uri) { return null; };
|
|
|
// #endregion
|
|
|
@@ -4129,8 +4134,8 @@ var BABYLON;
|
|
|
return loader._applyExtensions(function (extension) { return extension._loadVertexDataAsync(context, primitive, babylonMesh); });
|
|
|
};
|
|
|
/** Helper method called by the loader to allow extensions to override loading materials. */
|
|
|
- GLTFLoaderExtension._LoadMaterialAsync = function (loader, context, material, babylonMesh, assign) {
|
|
|
- return loader._applyExtensions(function (extension) { return extension._loadMaterialAsync(context, material, babylonMesh, assign); });
|
|
|
+ GLTFLoaderExtension._LoadMaterialAsync = function (loader, context, material, babylonMesh, babylonDrawMode, assign) {
|
|
|
+ return loader._applyExtensions(function (extension) { return extension._loadMaterialAsync(context, material, babylonMesh, babylonDrawMode, assign); });
|
|
|
};
|
|
|
/** Helper method called by the loader to allow extensions to override loading uris. */
|
|
|
GLTFLoaderExtension._LoadUriAsync = function (loader, context, uri) {
|
|
|
@@ -4221,7 +4226,7 @@ var BABYLON;
|
|
|
return firstPromise;
|
|
|
});
|
|
|
};
|
|
|
- MSFT_lod.prototype._loadMaterialAsync = function (context, material, babylonMesh, assign) {
|
|
|
+ MSFT_lod.prototype._loadMaterialAsync = function (context, material, babylonMesh, babylonDrawMode, assign) {
|
|
|
var _this = this;
|
|
|
// Don't load material LODs if already loading a node LOD.
|
|
|
if (this._loadingNodeLOD) {
|
|
|
@@ -4238,13 +4243,14 @@ var BABYLON;
|
|
|
_this._loadMaterialSignals[materialLOD._index] = new BABYLON.Deferred();
|
|
|
}
|
|
|
}
|
|
|
- var promise = _this._loader._loadMaterialAsync("#/materials/" + materialLOD._index, materialLOD, babylonMesh, indexLOD === 0 ? assign : function () { }).then(function () {
|
|
|
+ var promise = _this._loader._loadMaterialAsync("#/materials/" + materialLOD._index, materialLOD, babylonMesh, babylonDrawMode, indexLOD === 0 ? assign : function () { }).then(function () {
|
|
|
if (indexLOD !== 0) {
|
|
|
- assign(materialLOD._babylonMaterial);
|
|
|
- var previousMaterialLOD = materialLODs[indexLOD - 1];
|
|
|
- if (previousMaterialLOD._babylonMaterial) {
|
|
|
- previousMaterialLOD._babylonMaterial.dispose();
|
|
|
- delete previousMaterialLOD._babylonMaterial;
|
|
|
+ var babylonDataLOD = materialLOD._babylonData;
|
|
|
+ assign(babylonDataLOD[babylonDrawMode].material);
|
|
|
+ var previousBabylonDataLOD = materialLODs[indexLOD - 1]._babylonData;
|
|
|
+ if (previousBabylonDataLOD[babylonDrawMode]) {
|
|
|
+ previousBabylonDataLOD[babylonDrawMode].material.dispose();
|
|
|
+ delete previousBabylonDataLOD[babylonDrawMode];
|
|
|
}
|
|
|
}
|
|
|
if (indexLOD !== materialLODs.length - 1) {
|
|
|
@@ -4433,27 +4439,32 @@ var BABYLON;
|
|
|
_this.name = NAME;
|
|
|
return _this;
|
|
|
}
|
|
|
- KHR_materials_pbrSpecularGlossiness.prototype._loadMaterialAsync = function (context, material, babylonMesh, assign) {
|
|
|
+ KHR_materials_pbrSpecularGlossiness.prototype._loadMaterialAsync = function (context, material, babylonMesh, babylonDrawMode, assign) {
|
|
|
var _this = this;
|
|
|
return this._loadExtensionAsync(context, material, function (context, extension) {
|
|
|
- material._babylonMeshes = material._babylonMeshes || [];
|
|
|
- material._babylonMeshes.push(babylonMesh);
|
|
|
- if (!material._loaded) {
|
|
|
+ material._babylonData = material._babylonData || {};
|
|
|
+ var babylonData = material._babylonData[babylonDrawMode];
|
|
|
+ if (!babylonData) {
|
|
|
var promises = new Array();
|
|
|
- var babylonMaterial = _this._loader._createMaterial(material);
|
|
|
- material._babylonMaterial = babylonMaterial;
|
|
|
- promises.push(_this._loader._loadMaterialBasePropertiesAsync(context, material));
|
|
|
- promises.push(_this._loadSpecularGlossinessPropertiesAsync(context, material, extension));
|
|
|
+ var name_1 = material.name || "materialSG_" + material._index;
|
|
|
+ var babylonMaterial = _this._loader._createMaterial(BABYLON.PBRMaterial, name_1, babylonDrawMode);
|
|
|
+ promises.push(_this._loader._loadMaterialBasePropertiesAsync(context, material, babylonMaterial));
|
|
|
+ promises.push(_this._loadSpecularGlossinessPropertiesAsync(context, material, extension, babylonMaterial));
|
|
|
_this._loader.onMaterialLoadedObservable.notifyObservers(babylonMaterial);
|
|
|
- material._loaded = Promise.all(promises).then(function () { });
|
|
|
+ babylonData = {
|
|
|
+ material: babylonMaterial,
|
|
|
+ meshes: [],
|
|
|
+ loaded: Promise.all(promises).then(function () { })
|
|
|
+ };
|
|
|
+ material._babylonData[babylonDrawMode] = babylonData;
|
|
|
}
|
|
|
- assign(material._babylonMaterial);
|
|
|
- return material._loaded;
|
|
|
+ babylonData.meshes.push(babylonMesh);
|
|
|
+ assign(babylonData.material);
|
|
|
+ return babylonData.loaded;
|
|
|
});
|
|
|
};
|
|
|
- KHR_materials_pbrSpecularGlossiness.prototype._loadSpecularGlossinessPropertiesAsync = function (context, material, properties) {
|
|
|
+ KHR_materials_pbrSpecularGlossiness.prototype._loadSpecularGlossinessPropertiesAsync = function (context, material, properties, babylonMaterial) {
|
|
|
var promises = new Array();
|
|
|
- var babylonMaterial = material._babylonMaterial;
|
|
|
if (properties.diffuseFactor) {
|
|
|
babylonMaterial.albedoColor = BABYLON.Color3.FromArray(properties.diffuseFactor);
|
|
|
babylonMaterial.alpha = properties.diffuseFactor[3];
|
|
|
@@ -4475,7 +4486,7 @@ var BABYLON;
|
|
|
babylonMaterial.reflectivityTexture.hasAlpha = true;
|
|
|
babylonMaterial.useMicroSurfaceFromReflectivityMapAlpha = true;
|
|
|
}
|
|
|
- this._loader._loadMaterialAlphaProperties(context, material);
|
|
|
+ this._loader._loadMaterialAlphaProperties(context, material, babylonMaterial);
|
|
|
return Promise.all(promises).then(function () { });
|
|
|
};
|
|
|
return KHR_materials_pbrSpecularGlossiness;
|
David Catuhe