@fps-games/editor 0.1.6-beta.1 → 0.1.7-beta.2

package/node_modules/@fps-games/babylon-renderer/dist/shadows/planar-shadow-system.js

@@ -1,7 +1,8 @@
 import { Constants } from '@babylonjs/core/Engines/constants.js';
 import { DirectionalLight } from '@babylonjs/core/Lights/directionalLight.js';
 import { Color3, Color4 } from '@babylonjs/core/Maths/math.color.js';
-import { Vector3 } from '@babylonjs/core/Maths/math.vector.js';
+import { Matrix, Vector3 } from '@babylonjs/core/Maths/math.vector.js';
+import { Material } from '@babylonjs/core/Materials/material.js';
 import { ShaderMaterial } from '@babylonjs/core/Materials/shaderMaterial.js';
 import { StandardMaterial } from '@babylonjs/core/Materials/standardMaterial.js';
 import { AbstractMesh } from '@babylonjs/core/Meshes/abstractMesh.js';
@@ -14,6 +15,8 @@ import { getPlanarShadowShaderAttributes, getPlanarShadowShaderSamplers, getPlan
 import { DEFAULT_PLANAR_SHADOW_OPTIONS, } from './types.js';
 const PLANAR_SHADOW_ALPHA_INDEX = 4;
 const DEFAULT_SHADOW_DIRECTION = new Vector3(-0.3, -1, -0.2).normalize();
+const STANDARD_ALPHA_LUMINANCE_WEIGHTS = new Vector3(0.3, 0.59, 0.11);
+const PBR_ALPHA_LUMINANCE_WEIGHTS = new Vector3(0.2126, 0.7152, 0.0722);
 export function createPlanarShadowSystem(scene, directionalLight, options = {}) {
     return new BabylonPlanarShadowSystem(scene, directionalLight, options);
 }
@@ -51,20 +54,30 @@ class BabylonPlanarShadowSystem {
     addCaster(mesh) {
         const root = this.findCasterRoot(mesh);
         if (!this.initialized || this.casters.has(root))
-            return;
+            return false;
         if (!this.isValidShadowSource(mesh))
-            return;
+            return false;
         const shadow = this.createShadowForNode(root);
-        if (shadow)
-            this.casters.set(shadow.source, shadow);
+        if (!shadow)
+            return false;
+        this.casters.set(shadow.source, shadow);
+        return true;
     }
     removeCaster(mesh) {
         const root = this.findCasterRoot(mesh);
         this.disposeCaster(root);
     }
     addReceiver(mesh) {
-        if (!this.options.stencil.enabled || this.receivers.has(mesh))
+        this.registerReceiver(mesh, true);
+    }
+    registerReceiver(mesh, manual) {
+        if (!this.options.stencil.enabled || this.hasDisabledReceiver(mesh))
+            return;
+        const existing = this.receivers.get(mesh);
+        if (existing) {
+            existing.manual = existing.manual || manual;
             return;
+        }
         const originalRenderingGroup = mesh instanceof Mesh ? mesh.renderingGroupId : 0;
         if (mesh instanceof Mesh)
             mesh.renderingGroupId = this.options.stencil.receiverRenderingGroup;
@@ -80,7 +93,7 @@ class BabylonPlanarShadowSystem {
             stencil.opStencilFail = Constants.KEEP;
             stencil.opDepthFail = Constants.KEEP;
         }
-        this.receivers.set(mesh, { mesh, originalRenderingGroup, material });
+        this.receivers.set(mesh, { mesh, originalRenderingGroup, material, manual });
     }
     removeReceiver(mesh) {
         const info = this.receivers.get(mesh);
@@ -131,15 +144,17 @@ class BabylonPlanarShadowSystem {
     setOptions(options) {
         const wasEnabled = this.options.enabled;
         const requiredUniqueMaterials = this.requiresPerShadowMaterial();
+        const previousStrategy = this.options.projection.strategy;
         this.options = resolvePlanarShadowOptions(options, this.options);
         this.casterPatterns = [...this.options.casters.includePatterns];
         const requiresUniqueMaterials = this.requiresPerShadowMaterial();
+        const strategyChanged = previousStrategy !== this.options.projection.strategy;
         if (!wasEnabled && this.options.enabled)
             this.initialize();
         else if (wasEnabled && !this.options.enabled)
             this.dispose();
         else {
-            if (requiredUniqueMaterials !== requiresUniqueMaterials)
+            if (requiredUniqueMaterials !== requiresUniqueMaterials || strategyChanged)
                 this.rebuildCasters();
             this.refresh();
         }
@@ -153,6 +168,28 @@ class BabylonPlanarShadowSystem {
     getReceiverCount() {
         return this.receivers.size;
     }
+    getCasterDebugInfo() {
+        return [...this.casters.values()].map((info) => ({
+            sourceName: info.source.name,
+            sourceMeshNames: [...info.sourceMeshNames],
+            sourceMeshUniqueIds: [...info.sourceMeshUniqueIds],
+            shadowName: info.shadow.name,
+            strategy: info.strategy,
+            hasSkeleton: info.hasSkeleton,
+            projectedMeshCount: info.projectedMeshCount,
+            convexHullMeshCount: info.convexHullMeshCount,
+            alphaCutoutMeshCount: info.alphaCutoutMeshCount,
+            alphaCutoutChannels: [...info.alphaCutoutChannels],
+            alphaCutoutUvSets: [...info.alphaCutoutUvSets],
+            alphaCutoutLevels: [...info.alphaCutoutLevels],
+            alphaCutoutLuminanceWeights: info.alphaCutoutLuminanceWeights.map((weights) => ({
+                x: weights.x,
+                y: weights.y,
+                z: weights.z,
+            })),
+            fallbackReasons: [...info.fallbackReasons],
+        }));
+    }
     dispose() {
         if (this.renderObserver) {
             this.scene.onBeforeRenderObservable.remove(this.renderObserver);
@@ -183,14 +220,17 @@ class BabylonPlanarShadowSystem {
         this.scene.setRenderingAutoClearDepthStencil(this.options.stencil.receiverRenderingGroup, true, false, true);
         this.scene.setRenderingAutoClearDepthStencil(this.options.stencil.shadowRenderingGroup, false, false, false);
     }
-    createShadowMaterial(defines = []) {
-        const usesBoneTexture = defines.includes('BONETEXTURE');
-        const usesBones = defines.includes('BONE');
+    createShadowMaterial(defines = [], alphaCutout = null) {
+        const materialDefines = alphaCutout
+            ? [...defines, 'ALPHA_CUTOUT', ...(alphaCutout.layers[1] ? ['ALPHA_CUTOUT_SECONDARY'] : [])]
+            : defines;
+        const usesBoneTexture = materialDefines.includes('BONETEXTURE');
+        const usesBones = materialDefines.includes('BONE');
         const material = new ShaderMaterial(`fps.planarShadow.${this.materials.size}`, this.scene, { vertex: PLANAR_SHADOW_SHADER_NAME, fragment: PLANAR_SHADOW_SHADER_NAME }, {
             attributes: getPlanarShadowShaderAttributes(),
             uniforms: getPlanarShadowShaderUniforms(),
             samplers: getPlanarShadowShaderSamplers(),
-            defines,
+            defines: materialDefines,
         });
         material.backFaceCulling = false;
         material.disableDepthWrite = true;
@@ -200,6 +240,15 @@ class BabylonPlanarShadowSystem {
         material.onBindObservable.add((mesh) => {
             if (mesh instanceof AbstractMesh)
                 this.bindShadowProjectionUniforms(material, mesh);
+            if (alphaCutout) {
+                const primary = alphaCutout.layers[0];
+                material.setTexture('shadowAlphaSampler', primary.texture);
+                material.setFloat('u_shadowAlphaCutoff', alphaCutout.cutoff);
+                bindPlanarShadowAlphaCutoutLayer(material, '', primary);
+                const secondary = alphaCutout.layers[1];
+                if (secondary)
+                    bindPlanarShadowAlphaCutoutLayer(material, '2', secondary);
+            }
         });
         if (usesBones) {
             let lastBoundTexture = null;
@@ -345,13 +394,19 @@ class BabylonPlanarShadowSystem {
     refreshReceivers() {
         if (!this.options.stencil.enabled)
             return;
-        for (const mesh of [...this.receivers.keys()]) {
+        for (const [mesh, info] of [...this.receivers]) {
+            if (info.manual) {
+                if (this.hasDisabledReceiver(mesh) || this.matchesExcludePattern(mesh) || this.hasExcludedAncestor(mesh)) {
+                    this.removeReceiver(mesh);
+                }
+                continue;
+            }
             if (!this.matchesReceiver(mesh))
                 this.removeReceiver(mesh);
         }
         for (const mesh of this.scene.meshes) {
             if (this.matchesReceiver(mesh))
-                this.addReceiver(mesh);
+                this.registerReceiver(mesh, false);
         }
     }
     pruneDisposedCasters() {
@@ -423,30 +478,59 @@ class BabylonPlanarShadowSystem {
         const shadowRoot = new TransformNode(`${root.name}_planarShadowRoot`, this.scene);
         let hasSkeleton = false;
         const pairs = [];
+        const fallbackReasons = [];
         let sharedSkeleton = null;
         let sharedMaterial = null;
         for (const mesh of validMeshes) {
             if (!(mesh instanceof Mesh) && !(mesh instanceof InstancedMesh))
                 continue;
             const geometrySource = mesh instanceof InstancedMesh ? mesh.sourceMesh : mesh;
-            if (geometrySource.skeleton) {
-                const material = this.resolveShadowMaterial(geometrySource, sharedSkeleton, sharedMaterial);
-                hasSkeleton = true;
-                sharedSkeleton = geometrySource.skeleton;
-                sharedMaterial = material;
-                if (!material)
-                    continue;
-                const shadowMesh = this.createProjectedShadowMesh(mesh, material);
+            const strategy = this.options.projection.strategy;
+            if (strategy !== 'convex-hull') {
+                const alphaCutout = resolvePlanarShadowAlphaCutout(geometrySource);
+                const material = this.resolveShadowMaterial(geometrySource, sharedSkeleton, sharedMaterial, alphaCutout);
+                if (geometrySource.skeleton) {
+                    hasSkeleton = true;
+                    sharedSkeleton = geometrySource.skeleton;
+                    if (!alphaCutout)
+                        sharedMaterial = material;
+                }
+                const shadowMesh = material ? this.createProjectedShadowMesh(mesh, material) : null;
                 if (shadowMesh) {
+                    const alphaCutoutLayers = alphaCutout?.layers.filter((layer) => !!layer) ?? [];
                     shadowMesh.parent = shadowRoot;
-                    pairs.push({ mode: 'projected-mesh', source: mesh, shadow: shadowMesh });
+                    pairs.push({
+                        mode: 'projected-mesh',
+                        source: mesh,
+                        shadow: shadowMesh,
+                        alphaCutout: !!alphaCutout,
+                        alphaCutoutChannels: alphaCutoutLayers.map((layer) => layer.channel),
+                        alphaCutoutUvSets: alphaCutoutLayers.map((layer) => layer.coordinatesIndex),
+                        alphaCutoutLevels: alphaCutoutLayers.map((layer) => layer.level),
+                        alphaCutoutLuminanceWeights: alphaCutoutLayers.map((layer) => layer.luminanceWeights),
+                    });
+                    continue;
                 }
-                continue;
+                fallbackReasons.push(`${mesh.name}: projected mesh clone unavailable`);
+                if (strategy === 'projected-mesh')
+                    continue;
             }
             const shadowMesh = this.createHullShadowMesh(mesh);
             if (shadowMesh) {
                 shadowMesh.parent = shadowRoot;
-                pairs.push({ mode: 'flat-hull', source: mesh, shadow: shadowMesh });
+                pairs.push({
+                    mode: 'flat-hull',
+                    source: mesh,
+                    shadow: shadowMesh,
+                    alphaCutout: false,
+                    alphaCutoutChannels: [],
+                    alphaCutoutUvSets: [],
+                    alphaCutoutLevels: [],
+                    alphaCutoutLuminanceWeights: [],
+                });
+            }
+            else {
+                fallbackReasons.push(`${mesh.name}: convex hull geometry unavailable`);
             }
         }
         if (pairs.length === 0) {
@@ -463,6 +547,8 @@ class BabylonPlanarShadowSystem {
                     this.updateHullShadowMesh(pair.source, pair.shadow);
                 }
                 else {
+                    pair.shadow.setEnabled(pair.source.isEnabled());
+                    pair.shadow.isVisible = pair.source.isVisible;
                     pair.source.computeWorldMatrix(true).decompose(pair.shadow.scaling, pair.shadow.rotationQuaternion, pair.shadow.position);
                 }
             }
@@ -473,7 +559,18 @@ class BabylonPlanarShadowSystem {
         return {
             source: root,
             shadow: shadowRoot,
+            sourceMeshNames: uniqueStrings(pairs.map((pair) => pair.source.name)),
+            sourceMeshUniqueIds: uniqueNumbers(pairs.map((pair) => pair.source.uniqueId)),
             hasSkeleton,
+            strategy: summarizePlanarShadowStrategy(pairs),
+            projectedMeshCount: pairs.filter((pair) => pair.mode === 'projected-mesh').length,
+            convexHullMeshCount: pairs.filter((pair) => pair.mode === 'flat-hull').length,
+            alphaCutoutMeshCount: pairs.filter((pair) => pair.alphaCutout).length,
+            alphaCutoutChannels: pairs.flatMap((pair) => pair.alphaCutoutChannels),
+            alphaCutoutUvSets: pairs.flatMap((pair) => pair.alphaCutoutUvSets),
+            alphaCutoutLevels: pairs.flatMap((pair) => pair.alphaCutoutLevels),
+            alphaCutoutLuminanceWeights: pairs.flatMap((pair) => pair.alphaCutoutLuminanceWeights),
+            fallbackReasons,
         };
     }
     resolveSkeletonShadowMaterial(geometrySource, sharedSkeleton, sharedMaterial) {
@@ -486,7 +583,14 @@ class BabylonPlanarShadowSystem {
         this.materials.add(material);
         return material;
     }
-    resolveShadowMaterial(geometrySource, sharedSkeleton, sharedMaterial) {
+    resolveShadowMaterial(geometrySource, sharedSkeleton, sharedMaterial, alphaCutout = null) {
+        if (alphaCutout) {
+            const material = geometrySource.skeleton
+                ? this.createShadowMaterial(getPlanarShadowSkeletonDefines(geometrySource.skeleton?.bones.length ?? 0, !!this.scene.getEngine().getCaps().textureFloat && (geometrySource.skeleton?.bones.length ?? 0) > 4, geometrySource.isVerticesDataPresent('matricesIndicesExtra')), alphaCutout)
+                : this.createShadowMaterial([], alphaCutout);
+            this.materials.add(material);
+            return material;
+        }
         if (this.requiresPerShadowMaterial()) {
             const material = geometrySource.skeleton
                 ? this.createShadowMaterial(getPlanarShadowSkeletonDefines(geometrySource.skeleton?.bones.length ?? 0, !!this.scene.getEngine().getCaps().textureFloat && (geometrySource.skeleton?.bones.length ?? 0) > 4, geometrySource.isVerticesDataPresent('matricesIndicesExtra')))
@@ -578,7 +682,11 @@ class BabylonPlanarShadowSystem {
         const size = mesh.getBoundingInfo()?.boundingBox.extendSizeWorld;
         if (!size)
             return true;
-        return size.x * size.y * size.z >= this.options.casters.minVolume;
+        const volume = size.x * size.y * size.z;
+        if (volume >= this.options.casters.minVolume)
+            return true;
+        const maxProjectedArea = Math.max(size.x * size.y, size.x * size.z, size.y * size.z);
+        return maxProjectedArea >= this.options.casters.minVolume;
     }
     findCasterRoot(mesh) {
         let topmost = mesh;
@@ -603,6 +711,7 @@ class BabylonPlanarShadowSystem {
     matchesReceiver(mesh) {
         return this.options.stencil.enabled
             && !hasDisablePlanarShadowMetadata(mesh)
+            && !this.hasDisabledReceiver(mesh)
             && !this.matchesExcludePattern(mesh)
             && !this.hasExcludedAncestor(mesh)
             && this.matchesReceiverPattern(mesh);
@@ -629,6 +738,9 @@ class BabylonPlanarShadowSystem {
         }
         return false;
     }
+    hasDisabledReceiver(mesh) {
+        return hasDisabledPlanarShadowReceiver(mesh, node => this.matchesRootBoundaryPattern(node));
+    }
     isAlreadyCoveredByCaster(node) {
         for (const caster of this.casters.keys()) {
             if (caster === node || isDescendantOf(node, caster) || isDescendantOf(caster, node))
@@ -697,6 +809,14 @@ function buildPlanarShadowHullGeometry(source, options) {
         normals: normalsOut,
     };
 }
+function bindPlanarShadowAlphaCutoutLayer(material, suffix, layer) {
+    material.setFloat(`u_shadowAlphaLevel${suffix}`, layer.level);
+    material.setFloat(`u_shadowAlphaChannelMode${suffix}`, layer.channel === 'red' ? 2 : layer.channel === 'luminance' ? 1 : 0);
+    material.setVector3(`u_shadowAlphaLuminanceWeights${suffix}`, layer.luminanceWeights);
+    material.setFloat(`u_shadowAlphaUvSet${suffix}`, layer.coordinatesIndex);
+    material.setMatrix(`u_shadowAlphaMatrix${suffix}`, layer.texture.getTextureMatrix?.() ?? Matrix.Identity());
+    material.setTexture(`shadowAlphaSampler${suffix}`, layer.texture);
+}
 function buildPlaneBasis(normal) {
     const seed = Math.abs(Vector3.Dot(normal, Vector3.Up())) > 0.95
         ? Vector3.Right()
@@ -756,6 +876,7 @@ function resolvePlanarShadowOptions(override, base = DEFAULT_PLANAR_SHADOW_OPTIO
         direction: { mode: 'follow-light' },
         projection: {
             footprintScale: readNonNegativeFiniteNumber(override.projection?.footprintScale, base.projection.footprintScale),
+            strategy: readPlanarShadowProjectionStrategy(override.projection?.strategy, base.projection.strategy),
         },
         stencil: {
             enabled: override.stencil?.enabled ?? base.stencil.enabled,
@@ -777,6 +898,26 @@ function resolvePlanarShadowOptions(override, base = DEFAULT_PLANAR_SHADOW_OPTIO
         debug: override.debug ?? base.debug,
     };
 }
+function summarizePlanarShadowStrategy(pairs) {
+    const projectedCount = pairs.filter((pair) => pair.mode === 'projected-mesh').length;
+    const hullCount = pairs.filter((pair) => pair.mode === 'flat-hull').length;
+    if (projectedCount > 0 && hullCount === 0)
+        return 'projected-mesh';
+    if (hullCount > 0 && projectedCount === 0)
+        return 'convex-hull';
+    return 'auto';
+}
+function uniqueStrings(values) {
+    return [...new Set(values.filter(value => value.length > 0))];
+}
+function uniqueNumbers(values) {
+    return [...new Set(values.filter(value => Number.isFinite(value)))];
+}
+function readPlanarShadowProjectionStrategy(value, fallback) {
+    return value === 'auto' || value === 'projected-mesh' || value === 'convex-hull'
+        ? value
+        : fallback;
+}
 function cloneResolvedOptions(options) {
     return resolvePlanarShadowOptions(options);
 }
@@ -821,6 +962,29 @@ function hasDisablePlanarShadowMetadata(node) {
         && (metadata.disablePlanarShadow === true
             || metadata.planarShadowInternal === true);
 }
+function hasDisabledPlanarShadowReceiver(node, isRootBoundary) {
+    let current = node;
+    while (current) {
+        if (readEditorProjectionShadowReceive(current) === 'none')
+            return true;
+        current = current.parent instanceof AbstractMesh && !isRootBoundary(current.parent)
+            ? current.parent
+            : null;
+    }
+    return false;
+}
+function readEditorProjectionShadowReceive(node) {
+    const metadata = node.metadata;
+    if (!metadata || typeof metadata !== 'object')
+        return undefined;
+    const editorProjection = metadata.editorProjection;
+    if (!editorProjection || typeof editorProjection !== 'object')
+        return undefined;
+    const shadow = editorProjection.shadow;
+    if (!shadow || typeof shadow !== 'object')
+        return undefined;
+    return shadow.receive;
+}
 function isDisposedNode(node) {
     return typeof node.isDisposed === 'function' && node.isDisposed();
 }
@@ -833,6 +997,145 @@ function readMeshMaterial(mesh) {
         ? material
         : null;
 }
+function resolvePlanarShadowAlphaCutout(mesh) {
+    return findAlphaCutout(mesh.material);
+}
+function findAlphaCutout(material) {
+    if (!material || typeof material !== 'object')
+        return null;
+    const record = material;
+    const cutoff = readAlphaCutoff(record.alphaCutOff ?? record.alphaCutoff);
+    const geometryOpacityTexture = readBaseTexture(record.geometryOpacityTexture);
+    if (geometryOpacityTexture && materialUsesOpacityAlpha(record)) {
+        const layer = createPlanarShadowAlphaCutoutLayer(geometryOpacityTexture, 'red', PBR_ALPHA_LUMINANCE_WEIGHTS);
+        return layer ? {
+            cutoff,
+            layers: [layer],
+        } : null;
+    }
+    const surfaceLayer = resolvePlanarShadowSurfaceAlphaLayer(record);
+    const opacityTexture = readBaseTexture(record.opacityTexture);
+    if (opacityTexture && materialUsesOpacityAlpha(record)) {
+        const opacityLayer = createPlanarShadowAlphaCutoutLayer(opacityTexture, opacityTexture.getAlphaFromRGB ? 'luminance' : 'alpha', resolveOpacityLuminanceWeights(record));
+        if (!opacityLayer)
+            return surfaceLayer ? { cutoff, layers: [surfaceLayer] } : null;
+        return {
+            cutoff,
+            layers: surfaceLayer ? [opacityLayer, surfaceLayer] : [opacityLayer],
+        };
+    }
+    if (surfaceLayer)
+        return { cutoff, layers: [surfaceLayer] };
+    const subMaterials = Array.isArray(record.subMaterials) ? record.subMaterials : [];
+    for (const subMaterial of subMaterials) {
+        const resolved = findAlphaCutout(subMaterial);
+        if (resolved)
+            return resolved;
+    }
+    return null;
+}
+function resolvePlanarShadowSurfaceAlphaLayer(material) {
+    const albedoTexture = readBaseTexture(material.albedoTexture);
+    if (albedoTexture && materialUsesAlbedoAlpha(material, albedoTexture)) {
+        return createPlanarShadowAlphaCutoutLayer(albedoTexture, 'alpha', STANDARD_ALPHA_LUMINANCE_WEIGHTS, 1);
+    }
+    const diffuseTexture = readBaseTexture(material.diffuseTexture);
+    if (diffuseTexture && materialUsesDiffuseAlpha(material, diffuseTexture)) {
+        return createPlanarShadowAlphaCutoutLayer(diffuseTexture, 'alpha', STANDARD_ALPHA_LUMINANCE_WEIGHTS, 1);
+    }
+    const baseColorTexture = readBaseTexture(material.baseColorTexture);
+    if (baseColorTexture && materialUsesBaseAlpha(material, baseColorTexture)) {
+        return createPlanarShadowAlphaCutoutLayer(baseColorTexture, 'alpha', STANDARD_ALPHA_LUMINANCE_WEIGHTS, 1);
+    }
+    const baseTexture = readBaseTexture(material.baseTexture);
+    if (baseTexture && materialUsesBaseAlpha(material, baseTexture)) {
+        return createPlanarShadowAlphaCutoutLayer(baseTexture, 'alpha', STANDARD_ALPHA_LUMINANCE_WEIGHTS, 1);
+    }
+    return null;
+}
+function createPlanarShadowAlphaCutoutLayer(texture, channel, luminanceWeights, level = readTextureLevel(texture)) {
+    const coordinatesIndex = readSupportedTextureCoordinatesIndex(texture);
+    return coordinatesIndex == null
+        ? null
+        : {
+            texture,
+            channel,
+            coordinatesIndex,
+            level,
+            luminanceWeights,
+        };
+}
+function readBaseTexture(value) {
+    return value && typeof value === 'object' && typeof value.getClassName === 'function'
+        ? value
+        : null;
+}
+function readSupportedTextureCoordinatesIndex(texture) {
+    return texture.coordinatesIndex === 0
+        || texture.coordinatesIndex === 1
+        || texture.coordinatesIndex === 2
+        || texture.coordinatesIndex === 3
+        || texture.coordinatesIndex === 4
+        || texture.coordinatesIndex === 5
+        ? texture.coordinatesIndex
+        : null;
+}
+function readTextureLevel(texture) {
+    return typeof texture.level === 'number' && Number.isFinite(texture.level) ? Math.max(0, texture.level) : 1;
+}
+function resolveOpacityLuminanceWeights(material) {
+    const className = typeof material.getClassName === 'function'
+        ? String(material.getClassName.call(material))
+        : '';
+    return className.includes('PBR') ? PBR_ALPHA_LUMINANCE_WEIGHTS : STANDARD_ALPHA_LUMINANCE_WEIGHTS;
+}
+function materialUsesDiffuseAlpha(material, texture) {
+    return materialAllowsTextureAlpha(material)
+        && texture.hasAlpha === true
+        && (material.useAlphaFromDiffuseTexture === true || materialUsesTextureAlpha(material, texture));
+}
+function materialUsesAlbedoAlpha(material, texture) {
+    return materialAllowsTextureAlpha(material)
+        && texture.hasAlpha === true
+        && (material.useAlphaFromAlbedoTexture === true || materialUsesTextureAlpha(material, texture));
+}
+function materialUsesBaseAlpha(material, texture) {
+    return materialAllowsTextureAlpha(material)
+        && texture.hasAlpha === true
+        && (material.useAlphaFromBaseColorTexture === true
+            || material._useAlphaFromBaseColorTexture === true
+            || materialUsesTextureAlpha(material, texture));
+}
+function materialUsesTextureAlpha(material, texture) {
+    if (texture.hasAlpha !== true)
+        return false;
+    const needAlphaTesting = material.needAlphaTesting;
+    if (typeof needAlphaTesting === 'function' && needAlphaTesting.call(material) === true)
+        return true;
+    return material.transparencyMode === Material.MATERIAL_ALPHATEST
+        || material.transparencyMode === Material.MATERIAL_ALPHATESTANDBLEND;
+}
+function materialUsesOpacityAlpha(material) {
+    if (material.transparencyMode === Material.MATERIAL_OPAQUE)
+        return false;
+    const needAlphaTesting = material.needAlphaTesting;
+    if (typeof needAlphaTesting === 'function' && needAlphaTesting.call(material) === true)
+        return true;
+    const needAlphaBlending = material.needAlphaBlending;
+    if (typeof needAlphaBlending === 'function' && needAlphaBlending.call(material) === true)
+        return true;
+    return material.transparencyMode === Material.MATERIAL_ALPHATEST
+        || material.transparencyMode === Material.MATERIAL_ALPHABLEND
+        || material.transparencyMode === Material.MATERIAL_ALPHATESTANDBLEND;
+}
+function materialAllowsTextureAlpha(material) {
+    return material.transparencyMode !== Material.MATERIAL_OPAQUE;
+}
+function readAlphaCutoff(value) {
+    return typeof value === 'number' && Number.isFinite(value)
+        ? Math.min(1, Math.max(0, value))
+        : 0.1;
+}
 function clamp01(value) {
     return Math.min(1, Math.max(0, value));
 }