@fps-games/editor 0.1.3-beta.4 → 0.1.4-beta.2

package/node_modules/@fps-games/editor-babylon/dist/material-property-adapter.js

@@ -1,14 +1,20 @@
-import { getBabylonRuntime } from './runtime-globals';
+import { getBabylonRuntime } from './runtime-globals.js';
 export const MATERIAL_CANONICAL_PATHS = [
     'material.albedoColor',
     'material.emissiveColor',
     'material.metallic',
     'material.roughness',
     'material.alpha',
+    'material.alphaCutOff',
+    'material.transparencyMode',
     'material.backFaceCulling',
     'material.albedoTexture.url',
     'material.normalTexture.url',
+    'material.normalTexture.level',
     'material.metallicTexture.url',
+    'material.occlusionTexture.url',
+    'material.emissiveTexture.url',
+    'material.opacityTexture.url',
     'material.pbr.albedoColor',
     'material.pbr.baseWeight',
     'material.pbr.reflectivityColor',
@@ -23,9 +29,14 @@ export const MATERIAL_CANONICAL_PATHS = [
     'material.standard.ambientColor',
     'material.standard.useSpecularOverAlpha',
 ];
+const ARTIST_BASE_TEXTURE_ADJUSTMENT_PLUGIN_KEY = '__fpsArtistBaseTextureAdjustmentPlugin';
 const MATERIAL_SHARED_KEY_TO_PATH = {
     alpha: 'material.alpha',
     _alpha: 'material.alpha',
+    alphaCutOff: 'material.alphaCutOff',
+    _alphaCutOff: 'material.alphaCutOff',
+    transparencyMode: 'material.transparencyMode',
+    _transparencyMode: 'material.transparencyMode',
     backFaceCulling: 'material.backFaceCulling',
     _backFaceCulling: 'material.backFaceCulling',
     albedoTexture: 'material.albedoTexture.url',
@@ -38,6 +49,12 @@ const MATERIAL_SHARED_KEY_TO_PATH = {
     _bumpTexture: 'material.normalTexture.url',
     metallicTexture: 'material.metallicTexture.url',
     _metallicTexture: 'material.metallicTexture.url',
+    ambientTexture: 'material.occlusionTexture.url',
+    _ambientTexture: 'material.occlusionTexture.url',
+    emissiveTexture: 'material.emissiveTexture.url',
+    _emissiveTexture: 'material.emissiveTexture.url',
+    opacityTexture: 'material.opacityTexture.url',
+    _opacityTexture: 'material.opacityTexture.url',
 };
 const MATERIAL_PBR_KEY_TO_PATH = {
     albedoColor: 'material.pbr.albedoColor',
@@ -79,6 +96,8 @@ function isMaterialLike(value) {
     const className = value.getClassName?.();
     if (typeof className === 'string' && /material$/i.test(className))
         return true;
+    if (Array.isArray(value.subMaterials))
+        return true;
     return 'albedoColor' in value
         || 'diffuseColor' in value
         || 'reflectivityColor' in value
@@ -90,12 +109,24 @@ function isMaterialLike(value) {
 function hasMaterial(value) {
     return !!value && typeof value === 'object' && !!value.material;
 }
+function readRuntimeSubMaterials(material) {
+    if (!material || typeof material !== 'object' || !Array.isArray(material.subMaterials))
+        return null;
+    return material.subMaterials.filter((subMaterial) => (subMaterial && typeof subMaterial === 'object' && subMaterial !== material));
+}
 function isFiniteNumber(value) {
     return typeof value === 'number' && Number.isFinite(value);
 }
 export function resolveMaterialRuntimeKind(material) {
     if (!material || typeof material !== 'object')
         return 'unknown';
+    const subMaterials = readRuntimeSubMaterials(material);
+    if (subMaterials?.length) {
+        const firstKnownKind = subMaterials
+            .map(resolveMaterialRuntimeKind)
+            .find(kind => kind !== 'unknown');
+        return firstKnownKind ?? 'unknown';
+    }
     const className = typeof material.getClassName === 'function' ? material.getClassName() : '';
     const normalizedClassName = typeof className === 'string' ? className.toLowerCase() : '';
     if (normalizedClassName.includes('standardmaterial'))
@@ -169,6 +200,9 @@ function normalizeMaterialValue(path, value) {
         case 'material.metallic':
         case 'material.roughness':
         case 'material.alpha':
+        case 'material.alphaCutOff':
+        case 'material.transparencyMode':
+        case 'material.normalTexture.level':
         case 'material.pbr.baseWeight':
         case 'material.pbr.microSurface':
         case 'material.pbr.lightFalloff':
@@ -180,6 +214,9 @@ function normalizeMaterialValue(path, value) {
         case 'material.albedoTexture.url':
         case 'material.normalTexture.url':
         case 'material.metallicTexture.url':
+        case 'material.occlusionTexture.url':
+        case 'material.emissiveTexture.url':
+        case 'material.opacityTexture.url':
             return normalizeTextureUrl(value);
         default:
             return SKIP;
@@ -204,6 +241,13 @@ function matchesNodeSegment(candidate, expected) {
     const suffix = candidate.includes(':') ? candidate.slice(candidate.lastIndexOf(':') + 1) : candidate;
     return suffix === expected;
 }
+function normalizeOwnerPathSegment(segment) {
+    const trimmed = segment.trim();
+    return trimmed.includes(':') ? trimmed.slice(trimmed.lastIndexOf(':') + 1) : trimmed;
+}
+function isSyntheticOwnerRootSegment(segment) {
+    return segment === '__root__';
+}
 function buildOwnerNodePath(ownerNode, rootNode) {
     if (ownerNode === rootNode)
         return '';
@@ -244,14 +288,26 @@ function resolveRuntimeMaterialProperty(material, path) {
             return 'roughness' in material ? 'roughness' : null;
         case 'material.alpha':
             return 'alpha' in material ? 'alpha' : null;
+        case 'material.alphaCutOff':
+            return 'alphaCutOff' in material ? 'alphaCutOff' : null;
+        case 'material.transparencyMode':
+            return 'transparencyMode' in material ? 'transparencyMode' : null;
         case 'material.backFaceCulling':
             return 'backFaceCulling' in material ? 'backFaceCulling' : null;
         case 'material.albedoTexture.url':
             return 'albedoTexture' in material ? 'albedoTexture' : 'diffuseTexture' in material ? 'diffuseTexture' : null;
         case 'material.normalTexture.url':
             return 'normalTexture' in material ? 'normalTexture' : 'bumpTexture' in material ? 'bumpTexture' : null;
+        case 'material.normalTexture.level':
+            return 'normalTexture' in material ? 'normalTexture' : 'bumpTexture' in material ? 'bumpTexture' : null;
         case 'material.metallicTexture.url':
             return 'metallicTexture' in material ? 'metallicTexture' : null;
+        case 'material.occlusionTexture.url':
+            return 'ambientTexture' in material ? 'ambientTexture' : null;
+        case 'material.emissiveTexture.url':
+            return 'emissiveTexture' in material ? 'emissiveTexture' : null;
+        case 'material.opacityTexture.url':
+            return 'opacityTexture' in material ? 'opacityTexture' : null;
         case 'material.pbr.albedoColor':
             return '_albedoColor' in material ? '_albedoColor' : 'albedoColor' in material ? 'albedoColor' : null;
         case 'material.pbr.baseWeight':
@@ -344,6 +400,14 @@ export function applyMaterialValueToRuntimeMaterial(material, scene, path, value
     const writableMaterial = material;
     if (!writableMaterial || typeof writableMaterial !== 'object')
         return false;
+    const subMaterials = readRuntimeSubMaterials(writableMaterial);
+    if (subMaterials?.length) {
+        let changed = false;
+        for (const subMaterial of new Set(subMaterials)) {
+            changed = applyMaterialValueToRuntimeMaterial(subMaterial, scene, path, value, options) || changed;
+        }
+        return changed;
+    }
     const property = resolveRuntimeMaterialProperty(writableMaterial, path);
     if (!property)
         return false;
@@ -369,7 +433,19 @@ export function applyMaterialValueToRuntimeMaterial(material, scene, path, value
         writableMaterial[property] = Color3 ? new Color3(color.r, color.g, color.b) : { r: color.r, g: color.g, b: color.b };
         return true;
     }
-    if (path === 'material.albedoTexture.url' || path === 'material.normalTexture.url' || path === 'material.metallicTexture.url') {
+    if (path === 'material.normalTexture.level') {
+        const texture = writableMaterial[property];
+        if (!texture || typeof texture !== 'object' || !('level' in texture))
+            return false;
+        texture.level = typeof value === 'number' && Number.isFinite(value) ? value : texture.level;
+        return true;
+    }
+    if (path === 'material.albedoTexture.url'
+        || path === 'material.normalTexture.url'
+        || path === 'material.metallicTexture.url'
+        || path === 'material.occlusionTexture.url'
+        || path === 'material.emissiveTexture.url'
+        || path === 'material.opacityTexture.url') {
         if (value == null) {
             writableMaterial[property] = null;
             return true;
@@ -389,8 +465,18 @@ export function applyArtistMaterialProfileToRuntimeMaterial(material, scene, pro
     const writableMaterial = material;
     if (!writableMaterial || typeof writableMaterial !== 'object' || !profile)
         return false;
+    const subMaterials = readRuntimeSubMaterials(writableMaterial);
+    if (subMaterials?.length) {
+        let changed = false;
+        for (const subMaterial of new Set(subMaterials)) {
+            changed = applyArtistMaterialProfileToRuntimeMaterial(subMaterial, scene, profile, options) || changed;
+        }
+        return changed;
+    }
     let changed = false;
+    changed = applyArtistLightingModelProfile(writableMaterial, profile) || changed;
     changed = applyArtistBaseColorProfile(writableMaterial, scene, profile, options) || changed;
+    changed = applyArtistNormalProfile(writableMaterial, scene, profile, options) || changed;
     const materialRuntimeKind = resolveMaterialRuntimeKind(writableMaterial);
     if (materialRuntimeKind === 'pbr' && isFiniteNumber(profile.metallic)) {
         changed = applyMaterialValueToRuntimeMaterial(writableMaterial, scene, 'material.metallic', clamp01(profile.metallic), options) || changed;
@@ -398,15 +484,35 @@ export function applyArtistMaterialProfileToRuntimeMaterial(material, scene, pro
     if (materialRuntimeKind === 'pbr' && isFiniteNumber(profile.roughness)) {
         changed = applyMaterialValueToRuntimeMaterial(writableMaterial, scene, 'material.roughness', clamp01(profile.roughness), options) || changed;
     }
+    if (materialRuntimeKind === 'pbr') {
+        changed = applyArtistPbrTextureProfiles(writableMaterial, scene, profile, options) || changed;
+    }
     changed = applyArtistEmissionProfile(writableMaterial, scene, profile, options) || changed;
+    changed = applyArtistAlphaProfile(writableMaterial, scene, profile, options) || changed;
+    return changed;
+}
+function applyArtistLightingModelProfile(material, profile) {
+    if (profile.lightingModel !== 'lit' && profile.lightingModel !== 'unlit')
+        return false;
+    const unlit = profile.lightingModel === 'unlit';
+    let changed = false;
+    if ('unlit' in material && material.unlit !== unlit) {
+        material.unlit = unlit;
+        changed = true;
+    }
+    if ('disableLighting' in material && material.disableLighting !== unlit) {
+        material.disableLighting = unlit;
+        changed = true;
+    }
     return changed;
 }
 function applyArtistBaseColorProfile(material, scene, profile, options) {
     const baseColor = profile.baseColor;
     if (!baseColor)
         return false;
+    const hasTextureField = hasProfileTextureField(baseColor, 'texture');
     const hasBaseColorInput = baseColor.color !== undefined
-        || baseColor.texture !== undefined
+        || hasTextureField
         || baseColor.brightness !== undefined
         || baseColor.saturation !== undefined
         || baseColor.contrast !== undefined
@@ -414,17 +520,212 @@ function applyArtistBaseColorProfile(material, scene, profile, options) {
     if (!hasBaseColorInput)
         return false;
     let changed = false;
-    const textureUrl = typeof baseColor.texture?.url === 'string' ? baseColor.texture.url.trim() : '';
-    if (textureUrl) {
-        changed = applyMaterialValueToRuntimeMaterial(material, scene, 'material.albedoTexture.url', textureUrl, options) || changed;
+    const textureUrl = readTextureUrl(baseColor.texture, options);
+    if (textureUrl || hasTextureField) {
+        changed = applyMaterialValueToRuntimeMaterial(material, scene, 'material.albedoTexture.url', textureUrl ?? null, options) || changed;
     }
-    const sourceColor = readProfileColor(baseColor.color)
-        ?? readMaterialColor(material, 'albedoColor')
-        ?? readMaterialColor(material, 'diffuseColor');
+    const hasBaseTexture = textureUrl
+        ? true
+        : hasTextureField
+            ? false
+            : hasRuntimeBaseTexture(material);
+    changed = applyArtistBaseTextureAdjustmentPipeline(material, baseColor, hasBaseTexture, options) || changed;
+    const sourceColor = readProfileColor(baseColor.color);
     if (!sourceColor)
         return changed;
-    const transformed = transformArtistBaseColor(sourceColor, baseColor);
-    return applyMaterialValueToRuntimeMaterial(material, scene, 'material.albedoColor', transformed, options) || changed;
+    return applyMaterialValueToRuntimeMaterial(material, scene, 'material.albedoColor', sourceColor, options) || changed;
+}
+function applyArtistBaseTextureAdjustmentPipeline(material, baseColor, hasBaseTexture, options) {
+    const adjustment = resolveArtistBaseTextureAdjustment(baseColor, hasBaseTexture);
+    const existingPlugin = readArtistBaseTextureAdjustmentPlugin(material);
+    if (!adjustment.enabled) {
+        existingPlugin?.updateAdjustment?.(adjustment);
+        existingPlugin?.setEnabled?.(false);
+        return !!existingPlugin;
+    }
+    const plugin = existingPlugin ?? createArtistBaseTextureAdjustmentPlugin(material, options);
+    if (!plugin)
+        return false;
+    plugin.updateAdjustment?.(adjustment);
+    plugin.setEnabled?.(true);
+    return true;
+}
+function resolveArtistBaseTextureAdjustment(baseColor, hasBaseTexture) {
+    const brightness = isFiniteNumber(baseColor.brightness) ? Math.max(0, baseColor.brightness) : 1;
+    const contrast = isFiniteNumber(baseColor.contrast) ? baseColor.contrast : 1;
+    const saturation = isFiniteNumber(baseColor.saturation) ? Math.max(0, baseColor.saturation) : 1;
+    const hue = isFiniteNumber(baseColor.hue) ? baseColor.hue : 0;
+    const enabled = hasBaseTexture && (Math.abs(brightness - 1) > 1e-6
+        || Math.abs(contrast - 1) > 1e-6
+        || Math.abs(saturation - 1) > 1e-6
+        || Math.abs(hue) > 1e-6);
+    return { enabled, brightness, saturation, contrast, hue };
+}
+function readArtistBaseTextureAdjustmentPlugin(material) {
+    const plugin = material?.[ARTIST_BASE_TEXTURE_ADJUSTMENT_PLUGIN_KEY];
+    return plugin && typeof plugin === 'object' ? plugin : null;
+}
+function hasRuntimeBaseTexture(material) {
+    const property = resolveRuntimeMaterialProperty(material, 'material.albedoTexture.url');
+    return !!(property && material?.[property]);
+}
+function hasProfileTextureField(owner, key) {
+    return !!owner && typeof owner === 'object' && Object.prototype.hasOwnProperty.call(owner, key);
+}
+function createArtistBaseTextureAdjustmentPlugin(material, options) {
+    const MaterialPluginBase = getBabylonRuntime(options.babylon)?.MaterialPluginBase;
+    if (typeof MaterialPluginBase !== 'function' || !material || typeof material !== 'object')
+        return null;
+    const baseTextureProperty = resolveRuntimeMaterialProperty(material, 'material.albedoTexture.url');
+    class ArtistBaseTextureAdjustmentPluginRuntime extends MaterialPluginBase {
+        constructor(targetMaterial) {
+            super(targetMaterial, 'FpsArtistBaseTextureAdjustment', 210, undefined, true, true);
+            this.adjustment = {
+                enabled: false,
+                brightness: 1,
+                saturation: 1,
+                contrast: 1,
+                hue: 0,
+            };
+            this.doNotSerialize = true;
+        }
+        getClassName() {
+            return 'FpsArtistBaseTextureAdjustment';
+        }
+        updateAdjustment(adjustment) {
+            this.adjustment = adjustment;
+        }
+        setEnabled(enabled) {
+            this.adjustment = { ...this.adjustment, enabled };
+        }
+        getUniforms() {
+            return {
+                externalUniforms: [
+                    'fpsArtistBaseTextureAdjust',
+                    'fpsArtistBaseTextureAdjustEnabled',
+                ],
+            };
+        }
+        bindForSubMesh(uniformBuffer) {
+            const effect = uniformBuffer?.currentEffect;
+            effect?.setFloat4?.('fpsArtistBaseTextureAdjust', this.adjustment.brightness, this.adjustment.saturation, this.adjustment.contrast, this.adjustment.hue);
+            effect?.setFloat?.('fpsArtistBaseTextureAdjustEnabled', this.adjustment.enabled ? 1 : 0);
+        }
+        getCustomCode(shaderType) {
+            if (shaderType !== 'fragment')
+                return null;
+            const customCode = {
+                CUSTOM_FRAGMENT_DEFINITIONS: ARTIST_BASE_TEXTURE_ADJUSTMENT_GLSL,
+            };
+            if (baseTextureProperty === 'albedoTexture') {
+                customCode.CUSTOM_FRAGMENT_BEFORE_LIGHTS = `
+if (fpsArtistBaseTextureAdjustEnabled > 0.5) {
+  surfaceAlbedo = fpsArtistAdjustBaseTextureColor(surfaceAlbedo, fpsArtistBaseTextureAdjust);
+}`;
+            }
+            else if (baseTextureProperty === 'diffuseTexture') {
+                customCode.CUSTOM_FRAGMENT_UPDATE_DIFFUSE = `
+if (fpsArtistBaseTextureAdjustEnabled > 0.5) {
+  baseColor.rgb = fpsArtistAdjustBaseTextureColor(baseColor.rgb, fpsArtistBaseTextureAdjust);
+}`;
+            }
+            return customCode;
+        }
+    }
+    const plugin = new ArtistBaseTextureAdjustmentPluginRuntime(material);
+    material[ARTIST_BASE_TEXTURE_ADJUSTMENT_PLUGIN_KEY] = plugin;
+    return plugin;
+}
+const ARTIST_BASE_TEXTURE_ADJUSTMENT_GLSL = `
+uniform vec4 fpsArtistBaseTextureAdjust;
+uniform float fpsArtistBaseTextureAdjustEnabled;
+
+vec3 fpsArtistRgbToHsl(vec3 color) {
+  float maxChannel = max(max(color.r, color.g), color.b);
+  float minChannel = min(min(color.r, color.g), color.b);
+  float lightness = (maxChannel + minChannel) * 0.5;
+  if (maxChannel == minChannel) {
+    return vec3(0.0, 0.0, lightness);
+  }
+  float delta = maxChannel - minChannel;
+  float saturation = lightness > 0.5 ? delta / (2.0 - maxChannel - minChannel) : delta / (maxChannel + minChannel);
+  float hue = 0.0;
+  if (maxChannel == color.r) {
+    hue = (color.g - color.b) / delta + (color.g < color.b ? 6.0 : 0.0);
+  } else if (maxChannel == color.g) {
+    hue = (color.b - color.r) / delta + 2.0;
+  } else {
+    hue = (color.r - color.g) / delta + 4.0;
+  }
+  return vec3(hue / 6.0, saturation, lightness);
+}
+
+float fpsArtistHueToRgb(float p, float q, float t) {
+  if (t < 0.0) t += 1.0;
+  if (t > 1.0) t -= 1.0;
+  if (t < 1.0 / 6.0) return p + (q - p) * 6.0 * t;
+  if (t < 1.0 / 2.0) return q;
+  if (t < 2.0 / 3.0) return p + (q - p) * (2.0 / 3.0 - t) * 6.0;
+  return p;
+}
+
+vec3 fpsArtistHslToRgb(vec3 hsl) {
+  if (hsl.y == 0.0) return vec3(hsl.z);
+  float q = hsl.z < 0.5 ? hsl.z * (1.0 + hsl.y) : hsl.z + hsl.y - hsl.z * hsl.y;
+  float p = 2.0 * hsl.z - q;
+  return vec3(
+    fpsArtistHueToRgb(p, q, hsl.x + 1.0 / 3.0),
+    fpsArtistHueToRgb(p, q, hsl.x),
+    fpsArtistHueToRgb(p, q, hsl.x - 1.0 / 3.0)
+  );
+}
+
+vec3 fpsArtistAdjustBaseTextureColor(vec3 color, vec4 adjustment) {
+  vec3 adjusted = clamp(color * max(adjustment.x, 0.0), 0.0, 1.0);
+  adjusted = clamp((adjusted - vec3(0.5)) * adjustment.z + vec3(0.5), 0.0, 1.0);
+  vec3 hsl = fpsArtistRgbToHsl(adjusted);
+  hsl.x = fract(hsl.x + adjustment.w / 360.0);
+  hsl.y = clamp(hsl.y * max(adjustment.y, 0.0), 0.0, 1.0);
+  return fpsArtistHslToRgb(hsl);
+}
+`;
+function applyArtistNormalProfile(material, scene, profile, options) {
+    const normal = profile.normal;
+    if (!normal)
+        return false;
+    let changed = false;
+    const hasTextureField = hasProfileTextureField(normal, 'texture');
+    const textureUrl = readTextureUrl(normal.texture, options);
+    if (textureUrl || hasTextureField) {
+        changed = applyMaterialValueToRuntimeMaterial(material, scene, 'material.normalTexture.url', textureUrl ?? null, options) || changed;
+    }
+    if (isFiniteNumber(normal.strength)) {
+        changed = applyMaterialValueToRuntimeMaterial(material, scene, 'material.normalTexture.level', Math.max(0, normal.strength), options) || changed;
+    }
+    return changed;
+}
+function applyArtistPbrTextureProfiles(material, scene, profile, options) {
+    let changed = false;
+    const metallicRoughness = profile.metallicRoughness;
+    const hasMetallicRoughnessTextureField = hasProfileTextureField(metallicRoughness, 'texture');
+    const metallicRoughnessUrl = readTextureUrl(profile.metallicRoughness?.texture, options);
+    if (metallicRoughnessUrl || hasMetallicRoughnessTextureField) {
+        changed = applyMaterialValueToRuntimeMaterial(material, scene, 'material.metallicTexture.url', metallicRoughnessUrl ?? null, options) || changed;
+        if (metallicRoughnessUrl)
+            applyBabylonPbrMetallicRoughnessTextureConventions(material);
+    }
+    const occlusion = profile.occlusion;
+    const hasOcclusionTextureField = hasProfileTextureField(occlusion, 'texture');
+    const occlusionUrl = readTextureUrl(profile.occlusion?.texture, options);
+    if (occlusionUrl || hasOcclusionTextureField) {
+        changed = applyMaterialValueToRuntimeMaterial(material, scene, 'material.occlusionTexture.url', occlusionUrl ?? null, options) || changed;
+    }
+    const occlusionStrength = profile.occlusion?.strength;
+    if (isFiniteNumber(occlusionStrength) && 'ambientTextureStrength' in material) {
+        material.ambientTextureStrength = Math.max(0, occlusionStrength);
+        changed = true;
+    }
+    return changed;
 }
 function applyArtistEmissionProfile(material, scene, profile, options) {
     const emission = profile.emission;
@@ -443,23 +744,63 @@ function applyArtistEmissionProfile(material, scene, profile, options) {
     if (emission.color !== undefined || emission.intensity !== undefined) {
         changed = applyMaterialValueToRuntimeMaterial(material, scene, 'material.emissiveColor', emissiveColor, options) || changed;
     }
-    const maskUrl = typeof emission.maskTexture?.url === 'string' ? emission.maskTexture.url.trim() : '';
-    if (!maskUrl)
-        return changed;
-    const property = 'emissiveTexture' in material ? 'emissiveTexture' : null;
-    if (!property)
-        return changed;
-    if (!scene)
-        return changed;
-    const Texture = getBabylonRuntime(options.babylon)?.Texture;
-    if (!Texture)
-        return changed;
-    const texture = new Texture(maskUrl, scene, false, false);
-    if ('level' in texture) {
-        texture.level = intensity;
+    const hasTextureField = hasProfileTextureField(emission, 'texture');
+    const hasMaskTextureField = hasProfileTextureField(emission, 'maskTexture');
+    const textureUrl = readTextureUrl(emission.texture, options) ?? readTextureUrl(emission.maskTexture, options);
+    if (textureUrl || hasTextureField || hasMaskTextureField) {
+        changed = applyMaterialValueToRuntimeMaterial(material, scene, 'material.emissiveTexture.url', textureUrl ?? null, options) || changed;
+        if (textureUrl && material.emissiveTexture && 'level' in material.emissiveTexture) {
+            material.emissiveTexture.level = intensity;
+        }
+    }
+    return changed;
+}
+function applyArtistAlphaProfile(material, scene, profile, options) {
+    const alpha = profile.alpha;
+    if (!alpha)
+        return false;
+    let changed = false;
+    const transparencyMode = resolveBabylonTransparencyMode(alpha.mode);
+    if (transparencyMode != null) {
+        changed = applyMaterialValueToRuntimeMaterial(material, scene, 'material.transparencyMode', transparencyMode, options) || changed;
+    }
+    if (isFiniteNumber(alpha.opacity)) {
+        changed = applyMaterialValueToRuntimeMaterial(material, scene, 'material.alpha', clamp01(alpha.opacity), options) || changed;
+    }
+    if (isFiniteNumber(alpha.cutoff)) {
+        changed = applyMaterialValueToRuntimeMaterial(material, scene, 'material.alphaCutOff', clamp01(alpha.cutoff), options) || changed;
+    }
+    const hasTextureField = hasProfileTextureField(alpha, 'texture');
+    const textureUrl = readTextureUrl(alpha.texture, options);
+    if (textureUrl || hasTextureField) {
+        changed = applyMaterialValueToRuntimeMaterial(material, scene, 'material.opacityTexture.url', textureUrl ?? null, options) || changed;
+    }
+    return changed;
+}
+function readTextureUrl(texture, options) {
+    if (!texture || typeof texture !== 'object')
+        return null;
+    const resolved = options.resolveTextureUrl?.(texture);
+    if (typeof resolved === 'string' && resolved.trim())
+        return resolved.trim();
+    return typeof texture.url === 'string' && texture.url.trim() ? texture.url.trim() : null;
+}
+function resolveBabylonTransparencyMode(mode) {
+    if (mode === 'opaque')
+        return 0;
+    if (mode === 'mask')
+        return 1;
+    if (mode === 'blend')
+        return 2;
+    return null;
+}
+function applyBabylonPbrMetallicRoughnessTextureConventions(material) {
+    if ('useMetallnessFromMetallicTextureBlue' in material) {
+        material.useMetallnessFromMetallicTextureBlue = true;
+    }
+    if ('useRoughnessFromMetallicTextureGreen' in material) {
+        material.useRoughnessFromMetallicTextureGreen = true;
     }
-    material[property] = texture;
-    return true;
 }
 function readProfileColor(color) {
     if (!color || !isFiniteNumber(color.r) || !isFiniteNumber(color.g) || !isFiniteNumber(color.b))
@@ -477,74 +818,6 @@ function readMaterialColor(material, property) {
         return null;
     return { r, g, b };
 }
-function transformArtistBaseColor(source, baseColor) {
-    const brightness = isFiniteNumber(baseColor.brightness) ? baseColor.brightness : 1;
-    const contrast = isFiniteNumber(baseColor.contrast) ? baseColor.contrast : 1;
-    const saturation = isFiniteNumber(baseColor.saturation) ? baseColor.saturation : 1;
-    const hue = isFiniteNumber(baseColor.hue) ? baseColor.hue : 0;
-    let r = clamp01(source.r * Math.max(0, brightness));
-    let g = clamp01(source.g * Math.max(0, brightness));
-    let b = clamp01(source.b * Math.max(0, brightness));
-    r = clamp01((r - 0.5) * contrast + 0.5);
-    g = clamp01((g - 0.5) * contrast + 0.5);
-    b = clamp01((b - 0.5) * contrast + 0.5);
-    const hsl = rgbToHsl(r, g, b);
-    hsl.h = normalizeHue(hsl.h + hue);
-    hsl.s = clamp01(hsl.s * Math.max(0, saturation));
-    return hslToRgb(hsl.h, hsl.s, hsl.l);
-}
-function rgbToHsl(r, g, b) {
-    const max = Math.max(r, g, b);
-    const min = Math.min(r, g, b);
-    const l = (max + min) / 2;
-    if (max === min)
-        return { h: 0, s: 0, l };
-    const d = max - min;
-    const s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
-    let h = 0;
-    switch (max) {
-        case r:
-            h = (g - b) / d + (g < b ? 6 : 0);
-            break;
-        case g:
-            h = (b - r) / d + 2;
-            break;
-        default:
-            h = (r - g) / d + 4;
-            break;
-    }
-    return { h: h * 60, s, l };
-}
-function hslToRgb(h, s, l) {
-    if (s === 0)
-        return { r: l, g: l, b: l };
-    const hueToRgb = (p, q, t) => {
-        let nextT = t;
-        if (nextT < 0)
-            nextT += 1;
-        if (nextT > 1)
-            nextT -= 1;
-        if (nextT < 1 / 6)
-            return p + (q - p) * 6 * nextT;
-        if (nextT < 1 / 2)
-            return q;
-        if (nextT < 2 / 3)
-            return p + (q - p) * (2 / 3 - nextT) * 6;
-        return p;
-    };
-    const normalizedHue = normalizeHue(h) / 360;
-    const q = l < 0.5 ? l * (1 + s) : l + s - l * s;
-    const p = 2 * l - q;
-    return {
-        r: clamp01(hueToRgb(p, q, normalizedHue + 1 / 3)),
-        g: clamp01(hueToRgb(p, q, normalizedHue)),
-        b: clamp01(hueToRgb(p, q, normalizedHue - 1 / 3)),
-    };
-}
-function normalizeHue(value) {
-    const result = value % 360;
-    return result < 0 ? result + 360 : result;
-}
 function clamp01(value) {
     return Math.min(1, Math.max(0, value));
 }
@@ -563,11 +836,43 @@ export function resolveMaterialOwnerNode(rootNode, ownerNodePath) {
         const children = current?.getChildren?.() ?? [];
         const next = children.find((child) => matchesNodeSegment(stableNodeSegment(child), segment)) ?? null;
         if (!next)
-            return null;
+            return findMaterialOwnerNodeByNormalizedPath(rootNode, segments);
         current = next;
     }
     return current;
 }
+function findMaterialOwnerNodeByNormalizedPath(rootNode, expectedSegments) {
+    const normalizedExpected = expectedSegments.map(normalizeOwnerPathSegment).filter(Boolean);
+    if (normalizedExpected.length === 0)
+        return rootNode;
+    const visit = (node, parentPath) => {
+        const segment = stableNodeSegment(node);
+        const normalizedSegment = segment ? normalizeOwnerPathSegment(segment) : '';
+        const nextPath = normalizedSegment && !isSyntheticOwnerRootSegment(normalizedSegment)
+            ? [...parentPath, normalizedSegment]
+            : parentPath;
+        if (nextPath.length === normalizedExpected.length
+            && nextPath.every((value, index) => value === normalizedExpected[index])) {
+            return node;
+        }
+        if (nextPath.length >= normalizedExpected.length)
+            return null;
+        const children = node?.getChildren?.() ?? [];
+        for (const child of children) {
+            const found = visit(child, nextPath);
+            if (found)
+                return found;
+        }
+        return null;
+    };
+    const children = rootNode?.getChildren?.() ?? [];
+    for (const child of children) {
+        const found = visit(child, []);
+        if (found)
+            return found;
+    }
+    return null;
+}
 export function applyMaterialValueToRuntimeNode(ownerNode, scene, path, value, options = {}) {
     return applyMaterialValueToRuntimeMaterial(ownerNode?.material, scene, path, value, options);
 }