@onerjs/serializers 9.0.1 → 9.0.3

package/glTF/2.0/glTFMaterialExporter.d.ts

@@ -78,6 +78,7 @@ export declare class GLTFMaterialExporter {
      * @param babylonPBRMaterial BJS PBR Metallic Roughness Material
      * @param glTFPbrMetallicRoughness glTF PBR Metallic Roughness interface
      * @param hasUVs specifies if texture coordinates are present on the submesh to determine if textures should be applied
+     * @param skipBaseColorTexture when true, do not generate/assign the base color texture (an extension will own it)
      * @returns glTF PBR Metallic Roughness factors
      */
     private _convertMetalRoughFactorsToMetallicRoughnessAsync;
@@ -94,7 +95,7 @@ export declare class GLTFMaterialExporter {
     exportPBRMaterialAsync(babylonPBRMaterial: PBRBaseMaterial, hasUVs: boolean): Promise<number>;
     private _setMetallicRoughnessPbrMaterialAsync;
     exportOpenPBRMaterialAsync(babylonOpenPBRMaterial: OpenPBRMaterial, hasUVs: boolean): Promise<number>;
-    exportTextureAsync(babylonTexture: BaseTexture, overrideId?: Nullable<number>): Promise<Nullable<ITextureInfo>>;
+    exportTextureAsync(babylonTexture: BaseTexture, overrideId?: Nullable<number | string>): Promise<Nullable<ITextureInfo>>;
     private _exportTextureImageAsync;
     private _exportImageAsync;
     private _exportTextureInfo;

package/glTF/2.0/glTFMaterialExporter.js

@@ -14,6 +14,7 @@ import { SpecularPowerToRoughness } from "@onerjs/core/Helpers/materialConversio
 import { OpenPBRMaterial } from "@onerjs/core/Materials/PBR/openpbrMaterial.js";
 import { MergeTexturesAsync, CreateRGBAConfiguration, CreateTextureInput, CreateConstantInput } from "@onerjs/core/Materials/Textures/textureMerger.js";
 import { GetCachedImageAsync, GetFileExtensionFromMimeType } from "../../exportImageUtils.js";
+import { CopyTextureSampling, GetSampledTextureKey } from "./glTFUtilities.js";
 const Epsilon = 1e-6;
 const DielectricSpecular = new Color3(0.04, 0.04, 0.04);
 const MaxSpecularPower = 1024;
@@ -107,6 +108,30 @@ function ConvertPixelArrayToFloat32(pixels) {
         throw new Error("Unsupported pixel format!");
     }
 }
+/**
+ * Packs occlusion (R), roughness (G) and metallic (B) into one texture.
+ * glTF requires metallic and roughness to share sampling, but occlusion is referenced separately with its own
+ * UV set and transform, so occlusion is packed raw in a second, independent merge.
+ * The returned texture carries the metallic-roughness sampling parameters.
+ * @param occlusionTexture The ambient occlusion texture (red channel), if any
+ * @param roughnessTexture The roughness texture (channel 0), if any
+ * @param metallicTexture The metallic texture (channel 0), if any
+ * @param scene The scene used to create the merged textures
+ * @returns The packed texture
+ */
+async function CreateOcclusionMetallicRoughnessTextureAsync(occlusionTexture, roughnessTexture, metallicTexture, scene) {
+    const metallicRoughness = await MergeTexturesAsync("MetalRoughTexture", {
+        ...CreateRGBAConfiguration(CreateConstantInput(1.0), roughnessTexture ? CreateTextureInput(roughnessTexture, 0) : CreateConstantInput(1.0), metallicTexture ? CreateTextureInput(metallicTexture, 0) : CreateConstantInput(1.0)),
+        sharedSampling: true,
+    }, scene);
+    if (!occlusionTexture) {
+        return metallicRoughness;
+    }
+    const packed = await MergeTexturesAsync("OcclusionMetalRoughTexture", CreateRGBAConfiguration(CreateTextureInput(occlusionTexture, 0), CreateTextureInput(metallicRoughness, 1), CreateTextureInput(metallicRoughness, 2)), scene);
+    CopyTextureSampling(metallicRoughness, packed);
+    metallicRoughness.dispose();
+    return packed;
+}
 /**
  * Utility methods for working with glTF material conversion properties.
  * @internal
@@ -115,6 +140,7 @@ export class GLTFMaterialExporter {
     constructor(_exporter) {
         this._exporter = _exporter;
         // Mapping to store textures
+        // Keyed by texture uniqueId, or by a string key describing the inputs (and their sampling) of a merged texture
         this._textureMap = new Map();
         // Mapping of internal textures to images to avoid exporting duplicate images
         this._internalTextureToImage = {};
@@ -413,9 +439,10 @@ export class GLTFMaterialExporter {
      * @param babylonPBRMaterial BJS PBR Metallic Roughness Material
      * @param glTFPbrMetallicRoughness glTF PBR Metallic Roughness interface
      * @param hasUVs specifies if texture coordinates are present on the submesh to determine if textures should be applied
+     * @param skipBaseColorTexture when true, do not generate/assign the base color texture (an extension will own it)
      * @returns glTF PBR Metallic Roughness factors
      */
-    async _convertMetalRoughFactorsToMetallicRoughnessAsync(baseColor, metallic, roughness, albedoTexture, metallicTexture, roughnessTexture, babylonPBRMaterial, glTFPbrMetallicRoughness, hasUVs) {
+    async _convertMetalRoughFactorsToMetallicRoughnessAsync(baseColor, metallic, roughness, albedoTexture, metallicTexture, roughnessTexture, babylonPBRMaterial, glTFPbrMetallicRoughness, hasUVs, skipBaseColorTexture = false) {
         const promises = [];
         const metallicRoughness = {
             baseColor: baseColor,
@@ -424,33 +451,38 @@ export class GLTFMaterialExporter {
         };
         if (hasUVs) {
             if (babylonPBRMaterial instanceof OpenPBRMaterial) {
-                if (babylonPBRMaterial.geometryOpacityTexture) {
-                    // Merge baseColor and opacity
-                    const albedoId = albedoTexture && albedoTexture.getInternalTexture() ? albedoTexture.getInternalTexture().uniqueId : 0;
-                    const opacityId = babylonPBRMaterial.geometryOpacityTexture && babylonPBRMaterial.geometryOpacityTexture.getInternalTexture()
-                        ? babylonPBRMaterial.geometryOpacityTexture.getInternalTexture().uniqueId
-                        : 0;
-                    const mergedId = Number(`${albedoId}${opacityId}`);
-                    const glTFTexture = this._textureMap.get(mergedId);
-                    if (glTFTexture) {
-                        glTFPbrMetallicRoughness.baseColorTexture = glTFTexture;
+                // Skip base color texture generation when an extension (e.g. KHR_materials_transmission)
+                // will overwrite the base color anyway; otherwise the texture/image baked here would be
+                // orphaned in the output. The extension re-bakes base color (including opacity) itself.
+                if (!skipBaseColorTexture) {
+                    if (babylonPBRMaterial.geometryOpacityTexture) {
+                        // Merge baseColor and opacity
+                        // The merge bakes input transforms, so the cache key must include each input's sampling state
+                        const mergedId = `baseColorOpacity|${GetSampledTextureKey(albedoTexture, "none")}|${GetSampledTextureKey(babylonPBRMaterial.geometryOpacityTexture, "none")}`;
+                        const glTFTexture = this._textureMap.get(mergedId);
+                        if (glTFTexture) {
+                            glTFPbrMetallicRoughness.baseColorTexture = glTFTexture;
+                        }
+                        else {
+                            promises.push(MergeTexturesAsync("baseColorOpacityTexture", {
+                                ...CreateRGBAConfiguration(albedoTexture ? CreateTextureInput(albedoTexture, 0) : CreateConstantInput(1.0), albedoTexture ? CreateTextureInput(albedoTexture, 1) : CreateConstantInput(1.0), albedoTexture ? CreateTextureInput(albedoTexture, 2) : CreateConstantInput(1.0), CreateTextureInput(babylonPBRMaterial.geometryOpacityTexture, 0)),
+                                sharedSampling: true,
+                            }, babylonPBRMaterial.getScene()).then(async (mergedTexture) => {
+                                const glTFTexture = await this.exportTextureAsync(mergedTexture, mergedId);
+                                if (glTFTexture) {
+                                    glTFPbrMetallicRoughness.baseColorTexture = glTFTexture;
+                                }
+                            }));
+                        }
                     }
                     else {
-                        promises.push(MergeTexturesAsync("baseColorOpacityTexture", CreateRGBAConfiguration(albedoTexture ? CreateTextureInput(albedoTexture, 0) : CreateConstantInput(1.0), albedoTexture ? CreateTextureInput(albedoTexture, 1) : CreateConstantInput(1.0), albedoTexture ? CreateTextureInput(albedoTexture, 2) : CreateConstantInput(1.0), CreateTextureInput(babylonPBRMaterial.geometryOpacityTexture, 0)), babylonPBRMaterial.getScene()).then(async (mergedTexture) => {
-                            const glTFTexture = await this.exportTextureAsync(mergedTexture, mergedId);
-                            if (glTFTexture) {
-                                glTFPbrMetallicRoughness.baseColorTexture = glTFTexture;
-                            }
-                        }));
-                    }
-                }
-                else {
-                    if (albedoTexture) {
-                        promises.push(this.exportTextureAsync(albedoTexture).then((glTFTexture) => {
-                            if (glTFTexture) {
-                                glTFPbrMetallicRoughness.baseColorTexture = glTFTexture;
-                            }
-                        }));
+                        if (albedoTexture) {
+                            promises.push(this.exportTextureAsync(albedoTexture).then((glTFTexture) => {
+                                if (glTFTexture) {
+                                    glTFPbrMetallicRoughness.baseColorTexture = glTFTexture;
+                                }
+                            }));
+                        }
                     }
                 }
                 if (babylonPBRMaterial._useMetallicFromMetallicTextureBlue && metallicTexture) {
@@ -461,15 +493,14 @@ export class GLTFMaterialExporter {
                     }));
                 }
                 else if (roughnessTexture || metallicTexture) {
-                    const metallicId = metallicTexture && metallicTexture.getInternalTexture() ? metallicTexture.getInternalTexture().uniqueId : 0;
-                    const roughnessId = roughnessTexture && roughnessTexture.getInternalTexture() ? roughnessTexture.getInternalTexture().uniqueId : 0;
-                    const mergedId = Number(`${metallicId}${roughnessId}`);
+                    // The merge bakes input transforms (and packs occlusion), so the cache key must include every input's sampling state
+                    const mergedId = `occlusionMetallicRoughness|${GetSampledTextureKey(babylonPBRMaterial.ambientOcclusionTexture, "none")}|${GetSampledTextureKey(metallicTexture, "none")}|${GetSampledTextureKey(roughnessTexture, "none")}`;
                     const glTFTexture = this._textureMap.get(mergedId);
                     if (glTFTexture) {
                         glTFPbrMetallicRoughness.metallicRoughnessTexture = glTFTexture;
                     }
                     else {
-                        promises.push(MergeTexturesAsync("MetalRoughTexture", CreateRGBAConfiguration(babylonPBRMaterial.ambientOcclusionTexture ? CreateTextureInput(babylonPBRMaterial.ambientOcclusionTexture, 0) : CreateConstantInput(1.0), roughnessTexture ? CreateTextureInput(roughnessTexture, 0) : CreateConstantInput(1.0), metallicTexture ? CreateTextureInput(metallicTexture, 0) : CreateConstantInput(1.0)), babylonPBRMaterial.getScene()).then(async (mergedTexture) => {
+                        promises.push(CreateOcclusionMetallicRoughnessTextureAsync(babylonPBRMaterial.ambientOcclusionTexture, roughnessTexture, metallicTexture, babylonPBRMaterial.getScene()).then(async (mergedTexture) => {
                             const glTFTexture = await this.exportTextureAsync(mergedTexture, mergedId);
                             if (glTFTexture) {
                                 glTFPbrMetallicRoughness.metallicRoughnessTexture = glTFTexture;
@@ -749,7 +780,13 @@ export class GLTFMaterialExporter {
         if (albedoColor) {
             glTFPbrMetallicRoughness.baseColorFactor = [albedoColor.r, albedoColor.g, albedoColor.b, alpha];
         }
-        const metallicRoughness = await this._convertMetalRoughFactorsToMetallicRoughnessAsync(babylonOpenPBRMaterial.baseColor, babylonOpenPBRMaterial.baseMetalness, babylonOpenPBRMaterial.specularRoughness, babylonOpenPBRMaterial.baseColorTexture, babylonOpenPBRMaterial.baseMetalnessTexture, babylonOpenPBRMaterial.specularRoughnessTexture, babylonOpenPBRMaterial, glTFPbrMetallicRoughness, hasUVs);
+        // KHR_materials_transmission overwrites the base color for OpenPBR materials with surface
+        // transmission/subsurface (glTF tints transmission by base color, OpenPBR does not). When that
+        // extension is active, let it own the base color texture so we don't bake an orphaned one here.
+        const skipBaseColorTexture = this._exporter.isExtensionEnabled("KHR_materials_transmission") &&
+            !babylonOpenPBRMaterial.unlit &&
+            (babylonOpenPBRMaterial.transmissionWeight > 0 || babylonOpenPBRMaterial.subsurfaceWeight > 0);
+        const metallicRoughness = await this._convertMetalRoughFactorsToMetallicRoughnessAsync(babylonOpenPBRMaterial.baseColor, babylonOpenPBRMaterial.baseMetalness, babylonOpenPBRMaterial.specularRoughness, babylonOpenPBRMaterial.baseColorTexture, babylonOpenPBRMaterial.baseMetalnessTexture, babylonOpenPBRMaterial.specularRoughnessTexture, babylonOpenPBRMaterial, glTFPbrMetallicRoughness, hasUVs, skipBaseColorTexture);
         await this._setMetallicRoughnessPbrMaterialAsync(metallicRoughness, babylonOpenPBRMaterial, glTFMaterial, glTFPbrMetallicRoughness, hasUVs);
         await this._finishMaterialAsync(glTFMaterial, babylonOpenPBRMaterial);
         const materials = this._exporter._materials;