@fps-games/engine 0.0.1-beta.2 → 0.0.1-beta.20

package/dist/babylon/renderer/materials/material-runtime.js

@@ -0,0 +1,660 @@
+import { Color3 } from '@babylonjs/core/Maths/math.color.js';
+import { Texture } from '@babylonjs/core/Materials/Textures/texture.js';
+import { MaterialPluginBase } from '@babylonjs/core/Materials/materialPluginBase.js';
+const ARTIST_BASE_TEXTURE_ADJUSTMENT_PLUGIN_KEY = '__fpsArtistBaseTextureAdjustmentPlugin';
+const DEFAULT_BABYLON_MATERIAL_RUNTIME = { Color3, Texture, MaterialPluginBase };
+function getBabylonRuntime(runtime) {
+    return runtime ?? DEFAULT_BABYLON_MATERIAL_RUNTIME;
+}
+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'))
+        return 'standard';
+    if (normalizedClassName.includes('pbr'))
+        return 'pbr';
+    if ('diffuseColor' in material || 'specularColor' in material || 'specularPower' in material)
+        return 'standard';
+    if ('albedoColor' in material
+        || '_albedoColor' in material
+        || 'reflectivityColor' in material
+        || '_reflectivityColor' in material
+        || 'microSurface' in material
+        || '_microSurface' in material)
+        return 'pbr';
+    return 'unknown';
+}
+function resolveRuntimeMaterialProperty(material, path) {
+    switch (path) {
+        case 'material.albedoColor':
+            return 'albedoColor' in material ? 'albedoColor' : 'diffuseColor' in material ? 'diffuseColor' : null;
+        case 'material.emissiveColor':
+            return 'emissiveColor' in material ? 'emissiveColor' : null;
+        case 'material.metallic':
+            return 'metallic' in material ? 'metallic' : null;
+        case 'material.roughness':
+            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':
+            return '_baseWeight' in material ? '_baseWeight' : 'baseWeight' in material ? 'baseWeight' : null;
+        case 'material.pbr.reflectivityColor':
+            return '_reflectivityColor' in material ? '_reflectivityColor' : 'reflectivityColor' in material ? 'reflectivityColor' : null;
+        case 'material.pbr.microSurface':
+            return '_microSurface' in material ? '_microSurface' : 'microSurface' in material ? 'microSurface' : null;
+        case 'material.pbr.emissiveColor':
+            return '_emissiveColor' in material ? '_emissiveColor' : 'emissiveColor' in material ? 'emissiveColor' : null;
+        case 'material.pbr.emissiveIntensity':
+            return '_emissiveIntensity' in material ? '_emissiveIntensity' : 'emissiveIntensity' in material ? 'emissiveIntensity' : null;
+        case 'material.pbr.ambientColor':
+            return '_ambientColor' in material ? '_ambientColor' : 'ambientColor' in material ? 'ambientColor' : null;
+        case 'material.pbr.lightFalloff':
+            return '_lightFalloff' in material ? '_lightFalloff' : 'lightFalloff' in material ? 'lightFalloff' : null;
+        case 'material.standard.diffuseColor':
+            return 'diffuseColor' in material ? 'diffuseColor' : '_diffuseColor' in material ? '_diffuseColor' : null;
+        case 'material.standard.specularColor':
+            return 'specularColor' in material ? 'specularColor' : '_specularColor' in material ? '_specularColor' : null;
+        case 'material.standard.specularPower':
+            return 'specularPower' in material ? 'specularPower' : '_specularPower' in material ? '_specularPower' : null;
+        case 'material.standard.emissiveColor':
+            return 'emissiveColor' in material ? 'emissiveColor' : '_emissiveColor' in material ? '_emissiveColor' : null;
+        case 'material.standard.ambientColor':
+            return 'ambientColor' in material ? 'ambientColor' : '_ambientColor' in material ? '_ambientColor' : null;
+        case 'material.standard.useSpecularOverAlpha':
+            return 'useSpecularOverAlpha' in material ? 'useSpecularOverAlpha' : '_useSpecularOverAlpha' in material ? '_useSpecularOverAlpha' : null;
+        default:
+            return null;
+    }
+}
+export function applyMaterialValueToRuntimeMaterial(material, scene, path, value, options = {}) {
+    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;
+    if (path === 'material.albedoColor'
+        || path === 'material.emissiveColor'
+        || path === 'material.pbr.albedoColor'
+        || path === 'material.pbr.reflectivityColor'
+        || path === 'material.pbr.emissiveColor'
+        || path === 'material.pbr.ambientColor'
+        || path === 'material.standard.diffuseColor'
+        || path === 'material.standard.specularColor'
+        || path === 'material.standard.emissiveColor'
+        || path === 'material.standard.ambientColor') {
+        if (!value || typeof value !== 'object')
+            return false;
+        const color = value;
+        const target = writableMaterial[property];
+        if (target?.copyFromFloats) {
+            target.copyFromFloats(color.r, color.g, color.b);
+            return true;
+        }
+        const Color3 = getBabylonRuntime(options.babylon)?.Color3;
+        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.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;
+        }
+        if (typeof value !== 'string' || !scene)
+            return false;
+        const Texture = getBabylonRuntime(options.babylon)?.Texture;
+        if (!Texture)
+            return false;
+        writableMaterial[property] = new Texture(value, scene, false, false);
+        return true;
+    }
+    writableMaterial[property] = value;
+    return true;
+}
+export function applyArtistMaterialProfileToRuntimeMaterial(material, scene, profile, options = {}) {
+    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;
+    }
+    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;
+    if (changed)
+        markRuntimeMaterialDirty(writableMaterial);
+    return changed;
+}
+/**
+ * Applies only the lightweight runtime value represented by one artist profile
+ * path. Texture ownership and shader-structure changes deliberately return
+ * false so callers can fall back to the full profile transaction.
+ */
+export function applyArtistMaterialProfileValueToRuntimeMaterial(material, scene, path, profile, options = {}) {
+    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 = applyArtistMaterialProfileValueToRuntimeMaterial(subMaterial, scene, path, profile, options) || changed;
+        }
+        return changed;
+    }
+    if (path === 'material.baseColor.color') {
+        const color = readProfileColor(profile.baseColor?.color);
+        return color
+            ? applyMaterialValueToRuntimeMaterial(writableMaterial, scene, 'material.albedoColor', color, options)
+            : false;
+    }
+    if (path === 'material.baseColor.brightness'
+        || path === 'material.baseColor.saturation'
+        || path === 'material.baseColor.contrast'
+        || path === 'material.baseColor.hue') {
+        return profile.baseColor
+            ? applyArtistBaseTextureAdjustmentPipeline(writableMaterial, profile.baseColor, hasRuntimeBaseTexture(writableMaterial), options)
+            : false;
+    }
+    if (path === 'material.normal.strength') {
+        return isFiniteNumber(profile.normal?.strength)
+            ? applyMaterialValueToRuntimeMaterial(writableMaterial, scene, 'material.normalTexture.level', Math.max(0, profile.normal.strength), options)
+            : false;
+    }
+    if (path === 'material.metallic') {
+        return resolveMaterialRuntimeKind(writableMaterial) === 'pbr' && isFiniteNumber(profile.metallic)
+            ? applyMaterialValueToRuntimeMaterial(writableMaterial, scene, 'material.metallic', clamp01(profile.metallic), options)
+            : false;
+    }
+    if (path === 'material.roughness') {
+        return resolveMaterialRuntimeKind(writableMaterial) === 'pbr' && isFiniteNumber(profile.roughness)
+            ? applyMaterialValueToRuntimeMaterial(writableMaterial, scene, 'material.roughness', clamp01(profile.roughness), options)
+            : false;
+    }
+    if (path === 'material.occlusion.strength') {
+        if (!isFiniteNumber(profile.occlusion?.strength) || !('ambientTextureStrength' in writableMaterial)) {
+            return false;
+        }
+        writableMaterial.ambientTextureStrength = Math.max(0, profile.occlusion.strength);
+        return true;
+    }
+    if (path === 'material.emission.color' || path === 'material.emission.intensity') {
+        return applyArtistEmissionValues(writableMaterial, scene, profile, options);
+    }
+    if (path === 'material.alpha.opacity') {
+        return isFiniteNumber(profile.alpha?.opacity)
+            ? applyMaterialValueToRuntimeMaterial(writableMaterial, scene, 'material.alpha', clamp01(profile.alpha.opacity), options)
+            : false;
+    }
+    if (path === 'material.alpha.cutoff') {
+        return isFiniteNumber(profile.alpha?.cutoff)
+            ? applyMaterialValueToRuntimeMaterial(writableMaterial, scene, 'material.alphaCutOff', clamp01(profile.alpha.cutoff), options)
+            : false;
+    }
+    return false;
+}
+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
+        || hasTextureField
+        || baseColor.brightness !== undefined
+        || baseColor.saturation !== undefined
+        || baseColor.contrast !== undefined
+        || baseColor.hue !== undefined;
+    if (!hasBaseColorInput)
+        return false;
+    let changed = false;
+    const textureUrl = readTextureUrl(baseColor.texture, options);
+    if (textureUrl || hasTextureField) {
+        changed = applyMaterialValueToRuntimeMaterial(material, scene, 'material.albedoTexture.url', textureUrl ?? null, options) || changed;
+    }
+    const hasBaseTexture = textureUrl
+        ? true
+        : hasTextureField
+            ? false
+            : hasRuntimeBaseTexture(material);
+    changed = applyArtistBaseTextureAdjustmentPipeline(material, baseColor, hasBaseTexture, options) || changed;
+    const sourceColor = readProfileColor(baseColor.color);
+    if (!sourceColor)
+        return 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 {
+        adjustment = {
+            enabled: false,
+            brightness: 1,
+            saturation: 1,
+            contrast: 1,
+            hue: 0,
+        };
+        constructor(targetMaterial) {
+            super(targetMaterial, 'FpsArtistBaseTextureAdjustment', 210, undefined, true, true);
+            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) {
+            changed = applyBabylonPbrMetallicRoughnessTextureConventions(material) || changed;
+        }
+    }
+    const occlusion = profile.occlusion;
+    const hasOcclusionTextureField = hasProfileTextureField(occlusion, 'texture');
+    const occlusionUrl = readTextureUrl(profile.occlusion?.texture, options);
+    const hasOcclusionInput = !!occlusion && typeof occlusion === 'object' && (hasOcclusionTextureField
+        || occlusionUrl != null
+        || occlusion.strength !== undefined);
+    if (hasOcclusionInput) {
+        changed = applyMaterialValueToRuntimeMaterial(material, scene, 'material.occlusionTexture.url', occlusionUrl ?? null, options) || changed;
+        changed = disableBabylonPbrMetallicRoughnessAmbientOcclusion(material) || 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;
+    if (!emission)
+        return false;
+    let changed = applyArtistEmissionValues(material, scene, profile, options);
+    const materialRuntimeKind = resolveMaterialRuntimeKind(material);
+    const canWritePbrEmissiveIntensity = materialRuntimeKind === 'pbr'
+        && resolveRuntimeMaterialProperty(material, 'material.pbr.emissiveIntensity') != null;
+    const intensity = isFiniteNumber(emission.intensity) ? Math.max(0, emission.intensity) : null;
+    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
+            && !canWritePbrEmissiveIntensity
+            && material.emissiveTexture
+            && 'level' in material.emissiveTexture) {
+            material.emissiveTexture.level = intensity ?? 0;
+        }
+    }
+    return changed;
+}
+function applyArtistEmissionValues(material, scene, profile, options) {
+    const emission = profile.emission;
+    if (!emission || (emission.color === undefined && emission.intensity === undefined))
+        return false;
+    const materialRuntimeKind = resolveMaterialRuntimeKind(material);
+    const canWritePbrEmissiveIntensity = materialRuntimeKind === 'pbr'
+        && resolveRuntimeMaterialProperty(material, 'material.pbr.emissiveIntensity') != null;
+    const intensity = isFiniteNumber(emission.intensity) ? Math.max(0, emission.intensity) : null;
+    const color = readProfileColor(emission.color);
+    let changed = false;
+    if (canWritePbrEmissiveIntensity) {
+        if (color) {
+            changed = applyMaterialValueToRuntimeMaterial(material, scene, 'material.pbr.emissiveColor', color, options) || changed;
+        }
+        if (intensity != null) {
+            changed = applyMaterialValueToRuntimeMaterial(material, scene, 'material.pbr.emissiveIntensity', intensity, options) || changed;
+        }
+        return changed;
+    }
+    const fallbackIntensity = intensity ?? 0;
+    const fallbackColor = color
+        ?? readMaterialColor(material, 'emissiveColor')
+        ?? { r: 1, g: 1, b: 1 };
+    return applyMaterialValueToRuntimeMaterial(material, scene, 'material.emissiveColor', {
+        r: fallbackColor.r * fallbackIntensity,
+        g: fallbackColor.g * fallbackIntensity,
+        b: fallbackColor.b * fallbackIntensity,
+    }, options);
+}
+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) {
+    let changed = false;
+    if ('useMetallnessFromMetallicTextureBlue' in material && material.useMetallnessFromMetallicTextureBlue !== true) {
+        material.useMetallnessFromMetallicTextureBlue = true;
+        changed = true;
+    }
+    if ('useRoughnessFromMetallicTextureGreen' in material && material.useRoughnessFromMetallicTextureGreen !== true) {
+        material.useRoughnessFromMetallicTextureGreen = true;
+        changed = true;
+    }
+    if ('useRoughnessFromMetallicTextureAlpha' in material && material.useRoughnessFromMetallicTextureAlpha !== false) {
+        material.useRoughnessFromMetallicTextureAlpha = false;
+        changed = true;
+    }
+    return disableBabylonPbrMetallicRoughnessAmbientOcclusion(material) || changed;
+}
+function disableBabylonPbrMetallicRoughnessAmbientOcclusion(material) {
+    if (!material || typeof material !== 'object')
+        return false;
+    if (!('useAmbientOcclusionFromMetallicTextureRed' in material))
+        return false;
+    if (material.useAmbientOcclusionFromMetallicTextureRed === false)
+        return false;
+    material.useAmbientOcclusionFromMetallicTextureRed = false;
+    return true;
+}
+function markRuntimeMaterialDirty(material) {
+    if (!material || typeof material !== 'object')
+        return;
+    if (material.getScene?.()?.blockMaterialDirtyMechanism === true)
+        return;
+    material.markDirty?.();
+}
+function readProfileColor(color) {
+    if (!color || !isFiniteNumber(color.r) || !isFiniteNumber(color.g) || !isFiniteNumber(color.b))
+        return null;
+    return { r: color.r, g: color.g, b: color.b };
+}
+function readMaterialColor(material, property) {
+    const value = material?.[property];
+    if (!value || typeof value !== 'object')
+        return null;
+    const r = isFiniteNumber(value.r) ? value.r : isFiniteNumber(value._r) ? value._r : null;
+    const g = isFiniteNumber(value.g) ? value.g : isFiniteNumber(value._g) ? value._g : null;
+    const b = isFiniteNumber(value.b) ? value.b : isFiniteNumber(value._b) ? value._b : null;
+    if (r == null || g == null || b == null)
+        return null;
+    return { r, g, b };
+}
+function clamp01(value) {
+    return Math.min(1, Math.max(0, value));
+}
+export function applyMaterialValueToRuntimeNode(ownerNode, scene, path, value, options = {}) {
+    return applyMaterialValueToRuntimeMaterial(ownerNode?.material, scene, path, value, options);
+}
+//# sourceMappingURL=material-runtime.js.map