@fps-games/engine 0.0.1-beta.5 → 0.0.1-beta.9

package/dist/babylon/renderer/shadows/static-projected-shadow-artifact-system.js

@@ -0,0 +1,645 @@
+import { Vector3 } from '@babylonjs/core/Maths/math.vector.js';
+import { Texture } from '@babylonjs/core/Materials/Textures/texture.js';
+import { Mesh } from '@babylonjs/core/Meshes/mesh.js';
+import { VertexData } from '@babylonjs/core/Meshes/mesh.vertexData.js';
+import { createStaticProjectedShadowSdfMaterial, markStaticProjectedShadowInternal, STATIC_PROJECTED_SHADOW_ALPHA_INDEX, } from './static-projected-shadow-rendering.js';
+import { DEFAULT_STATIC_PROJECTED_SHADOW_OPTIONS, } from './types.js';
+export function createStaticProjectedShadowArtifactSystem(scene, artifact, options = {}) {
+    return new BabylonStaticProjectedShadowArtifactSystem(scene, artifact, options);
+}
+class BabylonStaticProjectedShadowArtifactSystem {
+    scene;
+    artifact;
+    options;
+    pages = new Map();
+    loadedTextureIds = new Set();
+    bindingSyncObserver = null;
+    textureLoadEpoch = 0;
+    initialized = false;
+    diagnostics = {
+        status: 'missing',
+        reason: 'Static shadow artifact is missing.',
+        chunkCount: 0,
+        textureCount: 0,
+    };
+    constructor(scene, artifact, options) {
+        this.scene = scene;
+        this.artifact = artifact ?? null;
+        this.options = resolveStaticProjectedShadowArtifactOptions(options);
+    }
+    initialize() {
+        if (this.initialized)
+            return;
+        this.initialized = true;
+        this.rebuild();
+    }
+    setArtifact(artifact) {
+        this.artifact = artifact ?? null;
+        this.rebuild();
+    }
+    setOptions(options) {
+        this.options = resolveStaticProjectedShadowArtifactOptions(options, this.options);
+        this.rebuild();
+    }
+    getArtifact() {
+        return this.artifact;
+    }
+    getDiagnostics() {
+        return { ...this.diagnostics };
+    }
+    getChunkCount() {
+        return [...this.pages.values()].reduce((sum, page) => sum + page.chunkIds.length, 0);
+    }
+    dispose() {
+        this.textureLoadEpoch += 1;
+        this.loadedTextureIds.clear();
+        if (this.bindingSyncObserver) {
+            this.scene.onBeforeRenderObservable.remove(this.bindingSyncObserver);
+            this.bindingSyncObserver = null;
+        }
+        this.disposeChunks();
+        this.initialized = false;
+        this.diagnostics = {
+            status: 'missing',
+            reason: 'Static shadow artifact is missing.',
+            chunkCount: 0,
+            textureCount: 0,
+        };
+    }
+    rebuild() {
+        if (!this.initialized)
+            return;
+        this.textureLoadEpoch += 1;
+        this.loadedTextureIds.clear();
+        this.disposeChunks();
+        if (!this.options.enabled) {
+            this.setBindingSyncEnabled(false);
+            this.diagnostics = {
+                status: 'disabled',
+                reason: 'Static projected shadows are disabled.',
+                chunkCount: 0,
+                textureCount: 0,
+            };
+            return;
+        }
+        if (!this.artifact) {
+            this.setBindingSyncEnabled(false);
+            this.diagnostics = {
+                status: 'missing',
+                reason: 'Static shadow artifact is missing.',
+                chunkCount: 0,
+                textureCount: 0,
+            };
+            return;
+        }
+        const artifactDiagnostic = diagnoseStaticProjectedShadowArtifact(this.artifact, this.options.expectedHashes);
+        if (artifactDiagnostic.status !== 'loaded') {
+            this.setBindingSyncEnabled(false);
+            this.diagnostics = artifactDiagnostic;
+            return;
+        }
+        const sdfRadiusPx = readFiniteNumberWithFallback(this.artifact.stats?.sdfRadiusPx, DEFAULT_STATIC_PROJECTED_SHADOW_OPTIONS.bake.sdfRadiusPx);
+        for (const page of this.artifact.pages) {
+            const rendered = this.createAtlasPage(page, this.artifact.chunks.filter(chunk => chunk.pageId === page.id), sdfRadiusPx);
+            if (rendered)
+                this.pages.set(rendered.id, rendered);
+        }
+        const renderedChunkCount = [...this.pages.values()].reduce((sum, page) => sum + page.chunkIds.length, 0);
+        this.diagnostics = {
+            status: 'loaded',
+            reason: null,
+            chunkCount: renderedChunkCount,
+            textureCount: this.pages.size,
+            ...createArtifactDiagnosticStats(this.artifact, 'loaded'),
+            sourceHash: this.artifact.sourceHash,
+            lightHash: this.artifact.lightHash,
+            profileHash: this.artifact.profileHash,
+            expectedSourceHash: this.options.expectedHashes?.sourceHash ?? null,
+            expectedLightHash: this.options.expectedHashes?.lightHash ?? null,
+            expectedProfileHash: this.options.expectedHashes?.profileHash ?? null,
+        };
+        this.refreshBindings();
+        this.setBindingSyncEnabled(this.hasBindings());
+    }
+    refreshBindings() {
+        for (const page of this.pages.values()) {
+            const visible = page.bindings.length === 0
+                ? true
+                : page.bindings.some(binding => resolveBindingVisibility(this.scene, binding));
+            page.mesh.setEnabled(visible);
+        }
+    }
+    createAtlasPage(page, chunks, sdfRadiusPx) {
+        const textureDataUrl = readPngDataUrl(page.sdfTextureDataUrl);
+        if (!textureDataUrl || chunks.length === 0)
+            return null;
+        const name = `staticProjectedArtifact_${sanitizeName(page.id)}`;
+        const texture = new Texture(textureDataUrl, this.scene, true, false, Texture.BILINEAR_SAMPLINGMODE);
+        texture.name = `${name}_staticProjectedShadowSdfAtlas`;
+        texture.hasAlpha = true;
+        texture.wrapU = Texture.CLAMP_ADDRESSMODE;
+        texture.wrapV = Texture.CLAMP_ADDRESSMODE;
+        texture.updateSamplingMode(Texture.BILINEAR_SAMPLINGMODE);
+        this.observeTextureReady(page.id, texture, this.textureLoadEpoch);
+        const material = createStaticProjectedShadowSdfMaterial(name, this.scene, texture, {
+            color: this.options.appearance.color,
+            blur: this.options.bake.blur,
+            sdfRadiusPx,
+        });
+        const mesh = this.createAtlasMesh(`${name}_staticProjectedShadowAtlas`, chunks);
+        if (!mesh) {
+            texture.dispose();
+            material.dispose();
+            return null;
+        }
+        mesh.material = material;
+        const bindings = chunks.map(readStaticProjectedShadowArtifactBinding).filter((binding) => !!binding);
+        if (bindings.length > 0) {
+            mesh.metadata = {
+                ...(isRecord(mesh.metadata) ? mesh.metadata : {}),
+                staticProjectedShadowBindings: bindings.map(cloneStaticProjectedShadowArtifactBinding),
+            };
+        }
+        return {
+            id: page.id,
+            mesh,
+            material,
+            texture,
+            chunkIds: chunks.map(chunk => chunk.id),
+            bindings,
+        };
+    }
+    createAtlasMesh(name, chunks) {
+        const positions = [];
+        const normals = [];
+        const uvs = [];
+        const indices = [];
+        for (const chunk of chunks) {
+            const bounds = readChunkBounds(chunk);
+            if (!bounds)
+                continue;
+            const base = positions.length / 3;
+            positions.push(bounds.minX, bounds.center.y, bounds.minZ, bounds.maxX, bounds.center.y, bounds.minZ, bounds.maxX, bounds.center.y, bounds.maxZ, bounds.minX, bounds.center.y, bounds.maxZ);
+            normals.push(0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0);
+            uvs.push(chunk.atlasUv.u0, chunk.atlasUv.v0, chunk.atlasUv.u1, chunk.atlasUv.v0, chunk.atlasUv.u1, chunk.atlasUv.v1, chunk.atlasUv.u0, chunk.atlasUv.v1);
+            indices.push(base, base + 1, base + 2, base, base + 2, base + 3);
+        }
+        if (positions.length === 0)
+            return null;
+        const mesh = new Mesh(name, this.scene);
+        const vertexData = new VertexData();
+        vertexData.positions = positions;
+        vertexData.normals = normals;
+        vertexData.uvs = uvs;
+        vertexData.indices = indices;
+        vertexData.applyToMesh(mesh);
+        mesh.isPickable = false;
+        mesh.alphaIndex = STATIC_PROJECTED_SHADOW_ALPHA_INDEX;
+        markStaticProjectedShadowInternal(mesh);
+        return mesh;
+    }
+    observeTextureReady(textureId, texture, epoch) {
+        const notify = () => {
+            if (epoch !== this.textureLoadEpoch)
+                return;
+            if (this.loadedTextureIds.has(textureId))
+                return;
+            this.loadedTextureIds.add(textureId);
+            this.options.onTextureReady?.(createTextureReadyEvent({
+                textureId,
+                texture,
+                loadedTextureCount: this.loadedTextureIds.size,
+                totalTextureCount: this.getTextureCount(),
+            }));
+        };
+        const scheduleNotify = () => {
+            void Promise.resolve().then(notify);
+        };
+        if (typeof texture.isReady === 'function' && texture.isReady()) {
+            scheduleNotify();
+            return;
+        }
+        const observable = texture.onLoadObservable;
+        if (observable?.addOnce) {
+            observable.addOnce(scheduleNotify);
+            return;
+        }
+        scheduleNotify();
+    }
+    disposeChunks() {
+        for (const page of this.pages.values()) {
+            if (!page.mesh.isDisposed())
+                page.mesh.dispose();
+            page.texture.dispose();
+            page.material.dispose();
+        }
+        this.pages.clear();
+    }
+    hasBindings() {
+        for (const page of this.pages.values()) {
+            if (page.bindings.length > 0)
+                return true;
+        }
+        return false;
+    }
+    setBindingSyncEnabled(enabled) {
+        if (enabled) {
+            if (!this.bindingSyncObserver) {
+                this.bindingSyncObserver = this.scene.onBeforeRenderObservable.add(() => this.refreshBindings());
+            }
+            return;
+        }
+        if (this.bindingSyncObserver) {
+            this.scene.onBeforeRenderObservable.remove(this.bindingSyncObserver);
+            this.bindingSyncObserver = null;
+        }
+    }
+    getTextureCount() {
+        return this.pages.size;
+    }
+}
+function createTextureReadyEvent(input) {
+    return {
+        chunkId: input.textureId,
+        textureName: input.texture.name,
+        loadedTextureCount: input.loadedTextureCount,
+        totalTextureCount: input.totalTextureCount,
+    };
+}
+function resolveStaticProjectedShadowArtifactOptions(options = {}, fallback = {
+    enabled: DEFAULT_STATIC_PROJECTED_SHADOW_OPTIONS.enabled,
+    appearance: DEFAULT_STATIC_PROJECTED_SHADOW_OPTIONS.appearance,
+    bake: { blur: DEFAULT_STATIC_PROJECTED_SHADOW_OPTIONS.bake.blur },
+    expectedHashes: null,
+    onTextureReady: undefined,
+    debug: DEFAULT_STATIC_PROJECTED_SHADOW_OPTIONS.debug,
+}) {
+    return {
+        enabled: readBoolean(options.enabled, fallback.enabled),
+        appearance: {
+            color: {
+                r: readClampedNumber(options.appearance?.color.r, fallback.appearance.color.r, 0, 1),
+                g: readClampedNumber(options.appearance?.color.g, fallback.appearance.color.g, 0, 1),
+                b: readClampedNumber(options.appearance?.color.b, fallback.appearance.color.b, 0, 1),
+                a: readClampedNumber(options.appearance?.color.a, fallback.appearance.color.a, 0, 1),
+            },
+        },
+        bake: {
+            blur: readNonNegativeNumber(options.bake?.blur, fallback.bake.blur),
+        },
+        expectedHashes: readArtifactHashInput(options.expectedHashes, fallback.expectedHashes),
+        onTextureReady: options.onTextureReady ?? fallback.onTextureReady,
+        debug: readBoolean(options.debug, fallback.debug),
+    };
+}
+function diagnoseStaticProjectedShadowArtifact(artifact, expectedHashes) {
+    if (!Array.isArray(artifact.chunks) || artifact.version == null) {
+        return createArtifactDiagnostic('invalid', 'Static shadow artifact is invalid.', artifact, expectedHashes);
+    }
+    const shapeError = validateStaticProjectedShadowArtifactShape(artifact);
+    if (shapeError) {
+        return createArtifactDiagnostic('invalid', shapeError, artifact, expectedHashes);
+    }
+    if (!readNonEmptyString(artifact.sourceHash) || !readNonEmptyString(artifact.lightHash) || !readNonEmptyString(artifact.profileHash)) {
+        return createArtifactDiagnostic('invalid', 'Static shadow artifact is missing required hashes.', artifact, expectedHashes);
+    }
+    const chunkMismatch = findStaticProjectedShadowArtifactChunkHashMismatch(artifact);
+    if (chunkMismatch) {
+        return createArtifactDiagnostic('invalid', `Static shadow artifact chunk hash mismatch: ${chunkMismatch}.`, artifact, expectedHashes);
+    }
+    const mismatches = [
+        expectedHashes?.sourceHash && expectedHashes.sourceHash !== artifact.sourceHash ? 'source' : null,
+        expectedHashes?.lightHash && expectedHashes.lightHash !== artifact.lightHash ? 'light' : null,
+        expectedHashes?.profileHash && expectedHashes.profileHash !== artifact.profileHash ? 'profile' : null,
+    ].filter((entry) => !!entry);
+    if (mismatches.length > 0) {
+        return createArtifactDiagnostic('out-of-date', `Static shadow artifact hash mismatch: ${mismatches.join(', ')}.`, artifact, expectedHashes);
+    }
+    return createArtifactDiagnostic('loaded', null, artifact, expectedHashes);
+}
+function validateStaticProjectedShadowArtifactShape(artifact) {
+    if (artifact.version !== 2 || artifact.format !== 'sdf-atlas' || !Array.isArray(artifact.pages)) {
+        return 'Static shadow artifact is invalid.';
+    }
+    const pages = new Map();
+    for (const pageValue of artifact.pages) {
+        if (!isRecord(pageValue))
+            return 'Static shadow artifact atlas page is invalid.';
+        const page = pageValue;
+        const pageId = readNonEmptyString(page.id);
+        if (!pageId || pages.has(pageId) || !readPngDataUrl(page.sdfTextureDataUrl)) {
+            return 'Static shadow artifact atlas page is invalid.';
+        }
+        if (!Number.isInteger(page.width) || page.width <= 0 || !Number.isInteger(page.height) || page.height <= 0) {
+            return 'Static shadow artifact atlas page is invalid.';
+        }
+        pages.set(pageId, page);
+    }
+    const chunkIds = new Set();
+    for (const chunkValue of artifact.chunks) {
+        if (!isRecord(chunkValue))
+            return 'Static shadow artifact chunk is invalid.';
+        const chunk = chunkValue;
+        const chunkId = readNonEmptyString(chunk.id);
+        if (!chunkId || chunkIds.has(chunkId))
+            return 'Static shadow artifact chunk is invalid.';
+        chunkIds.add(chunkId);
+        const page = pages.get(readNonEmptyString(chunk.pageId) ?? '');
+        if (!page)
+            return 'Static shadow artifact chunk references a missing atlas page.';
+        if (!readChunkBounds(chunk))
+            return 'Static shadow artifact chunk bounds are invalid.';
+        if (!isValidAtlasRect(chunk, page))
+            return 'Static shadow artifact chunk atlas rect is invalid.';
+        if (!isValidAtlasUv(chunk))
+            return 'Static shadow artifact chunk atlas UV is invalid.';
+        if (!isValidSourceNodeIds(chunk.sourceNodeIds))
+            return 'Static shadow artifact chunk source ids are invalid.';
+    }
+    return null;
+}
+function isValidAtlasRect(chunk, page) {
+    const rect = chunk.atlasRect;
+    if (!rect)
+        return false;
+    if (!Number.isInteger(rect.x) || rect.x < 0 || !Number.isInteger(rect.y) || rect.y < 0)
+        return false;
+    if (!Number.isInteger(rect.width) || rect.width <= 0 || !Number.isInteger(rect.height) || rect.height <= 0)
+        return false;
+    return rect.x + rect.width <= page.width && rect.y + rect.height <= page.height;
+}
+function isValidAtlasUv(chunk) {
+    const uv = chunk.atlasUv;
+    if (!uv)
+        return false;
+    const values = [uv.u0, uv.v0, uv.u1, uv.v1];
+    if (!values.every(value => Number.isFinite(value) && value >= 0 && value <= 1))
+        return false;
+    return uv.u1 > uv.u0 && uv.v1 > uv.v0;
+}
+function isValidSourceNodeIds(value) {
+    return Array.isArray(value) && value.length > 0 && value.every(entry => !!readNonEmptyString(entry));
+}
+function findStaticProjectedShadowArtifactChunkHashMismatch(artifact) {
+    for (const chunk of artifact.chunks) {
+        const chunkId = readNonEmptyString(chunk.id) ?? '(unknown)';
+        if (createSourceNodeIdsHash(chunk.sourceNodeIds) !== chunk.sourceHash)
+            return `${chunkId}: source`;
+        if (chunk.lightHash !== artifact.lightHash)
+            return `${chunkId}: light`;
+        if (chunk.profileHash !== artifact.profileHash)
+            return `${chunkId}: profile`;
+    }
+    return null;
+}
+function createArtifactDiagnostic(status, reason, artifact, expectedHashes) {
+    return {
+        status,
+        reason,
+        chunkCount: status === 'loaded' ? artifact.chunks.length : 0,
+        textureCount: 0,
+        ...createArtifactDiagnosticStats(artifact, status),
+        sourceHash: readNonEmptyString(artifact.sourceHash),
+        lightHash: readNonEmptyString(artifact.lightHash),
+        profileHash: readNonEmptyString(artifact.profileHash),
+        expectedSourceHash: expectedHashes?.sourceHash ?? null,
+        expectedLightHash: expectedHashes?.lightHash ?? null,
+        expectedProfileHash: expectedHashes?.profileHash ?? null,
+    };
+}
+function createArtifactDiagnosticStats(artifact, status) {
+    if (status === 'invalid') {
+        return {
+            sourceRootCount: 0,
+            sourceMeshCount: null,
+            attemptedChunkCount: null,
+            skippedChunkCount: null,
+            pageCount: null,
+            resolution: null,
+            chunkSize: null,
+            atlasSize: null,
+            atlasUsedPixels: null,
+            atlasAllocatedPixels: null,
+            atlasOccupancy: null,
+            texelsPerMeter: null,
+            effectiveTexelsPerMeter: null,
+            maxAtlasPages: null,
+            sdfRadiusPx: null,
+            spatialChunkSize: null,
+            effectiveSpatialChunkSize: null,
+            targetChunkCount: null,
+            bakedChunkCount: null,
+            reusedChunkCount: null,
+            durationMs: null,
+            stats: null,
+        };
+    }
+    const stats = artifact.stats ?? null;
+    const pageCount = stats?.pageCount ?? artifact.pages.length;
+    return {
+        sourceRootCount: stats?.sourceRootCount ?? uniqueArtifactSourceNodeIds(artifact).length,
+        sourceMeshCount: stats?.sourceMeshCount ?? null,
+        attemptedChunkCount: stats?.attemptedChunkCount ?? artifact.chunks.length,
+        skippedChunkCount: stats?.skippedChunkCount ?? null,
+        pageCount,
+        resolution: stats?.resolution ?? null,
+        chunkSize: stats?.chunkSize ?? null,
+        atlasSize: stats?.atlasSize ?? null,
+        atlasUsedPixels: stats?.atlasUsedPixels ?? null,
+        atlasAllocatedPixels: stats?.atlasAllocatedPixels ?? null,
+        atlasOccupancy: stats?.atlasOccupancy ?? null,
+        texelsPerMeter: stats?.texelsPerMeter ?? null,
+        effectiveTexelsPerMeter: stats?.effectiveTexelsPerMeter ?? null,
+        maxAtlasPages: stats?.maxAtlasPages ?? null,
+        sdfRadiusPx: stats?.sdfRadiusPx ?? null,
+        spatialChunkSize: stats?.spatialChunkSize ?? null,
+        effectiveSpatialChunkSize: stats?.effectiveSpatialChunkSize ?? null,
+        targetChunkCount: stats?.targetChunkCount ?? null,
+        bakedChunkCount: stats?.bakedChunkCount ?? null,
+        reusedChunkCount: stats?.reusedChunkCount ?? null,
+        durationMs: stats?.durationMs ?? null,
+        stats,
+    };
+}
+function uniqueArtifactSourceNodeIds(artifact) {
+    return [...new Set(artifact.chunks.flatMap(chunk => Array.isArray(chunk.sourceNodeIds) ? chunk.sourceNodeIds : []))];
+}
+function readChunkBounds(chunk) {
+    const minX = readFiniteNumber(chunk.bounds?.minX);
+    const maxX = readFiniteNumber(chunk.bounds?.maxX);
+    const minZ = readFiniteNumber(chunk.bounds?.minZ);
+    const maxZ = readFiniteNumber(chunk.bounds?.maxZ);
+    const y = readFiniteNumber(chunk.bounds?.y);
+    if (minX == null || maxX == null || minZ == null || maxZ == null || y == null)
+        return null;
+    if (maxX <= minX || maxZ <= minZ)
+        return null;
+    return {
+        center: new Vector3((minX + maxX) * 0.5, y, (minZ + maxZ) * 0.5),
+        minX,
+        maxX,
+        minZ,
+        maxZ,
+    };
+}
+function readPngDataUrl(value) {
+    return typeof value === 'string' && /^data:image\/png[;,]/i.test(value.trim())
+        ? value.trim()
+        : null;
+}
+function readArtifactHashInput(value, fallback) {
+    if (value === null)
+        return null;
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return fallback;
+    const hashes = value;
+    const sourceHash = readNonEmptyString(hashes.sourceHash);
+    const lightHash = readNonEmptyString(hashes.lightHash);
+    const profileHash = readNonEmptyString(hashes.profileHash);
+    if (!sourceHash && !lightHash && !profileHash)
+        return null;
+    return {
+        ...(sourceHash ? { sourceHash } : {}),
+        ...(lightHash ? { lightHash } : {}),
+        ...(profileHash ? { profileHash } : {}),
+    };
+}
+function readStaticProjectedShadowArtifactBinding(chunk) {
+    const binding = chunk.binding;
+    if (!isRecord(binding))
+        return null;
+    const id = readNonEmptyString(binding.id);
+    const ownerCasterId = readNonEmptyString(binding.ownerCasterId);
+    const receiverId = readNonEmptyString(binding.receiverId);
+    const generatedAt = readNonEmptyString(binding.generatedAt);
+    const sourceHash = readNonEmptyString(binding.sourceHash);
+    if (!id
+        || !ownerCasterId
+        || !receiverId
+        || !generatedAt
+        || !sourceHash
+        || binding.visibleWhenOwnerVisible !== true
+        || binding.staleWhenOwnerTransformChanges !== true
+        || binding.staleWhenLightChanges !== true) {
+        return null;
+    }
+    const lightId = readNonEmptyString(binding.lightId);
+    const textureAssetId = readNonEmptyString(binding.textureAssetId);
+    const projectionNodeId = readNonEmptyString(binding.projectionNodeId);
+    return {
+        id,
+        ownerCasterId,
+        receiverId,
+        ...(lightId ? { lightId } : {}),
+        ...(textureAssetId ? { textureAssetId } : {}),
+        ...(projectionNodeId ? { projectionNodeId } : {}),
+        visibleWhenOwnerVisible: true,
+        staleWhenOwnerTransformChanges: true,
+        staleWhenLightChanges: true,
+        generatedAt,
+        sourceHash,
+    };
+}
+function cloneStaticProjectedShadowArtifactBinding(binding) {
+    return {
+        id: binding.id,
+        ownerCasterId: binding.ownerCasterId,
+        receiverId: binding.receiverId,
+        ...(binding.lightId ? { lightId: binding.lightId } : {}),
+        ...(binding.textureAssetId ? { textureAssetId: binding.textureAssetId } : {}),
+        ...(binding.projectionNodeId ? { projectionNodeId: binding.projectionNodeId } : {}),
+        visibleWhenOwnerVisible: true,
+        staleWhenOwnerTransformChanges: true,
+        staleWhenLightChanges: true,
+        generatedAt: binding.generatedAt,
+        sourceHash: binding.sourceHash,
+    };
+}
+function resolveBindingVisibility(scene, binding) {
+    if (!binding)
+        return true;
+    const owner = findSceneNode(scene, binding.ownerCasterId) ?? (binding.projectionNodeId ? findSceneNode(scene, binding.projectionNodeId) : null);
+    return !!owner && isSceneNodeEnabledAndVisible(owner);
+}
+function findSceneNode(scene, idOrName) {
+    const sceneWithLookup = scene;
+    const byId = sceneWithLookup.getNodeById?.(idOrName);
+    if (byId)
+        return byId;
+    const byName = sceneWithLookup.getNodeByName?.(idOrName);
+    if (byName)
+        return byName;
+    const collections = [
+        scene.meshes,
+        scene.transformNodes,
+        scene.lights,
+    ];
+    for (const collection of collections) {
+        const match = collection.find(node => {
+            const candidate = node;
+            return candidate.id === idOrName || candidate.name === idOrName;
+        });
+        if (match)
+            return match;
+    }
+    return null;
+}
+function isSceneNodeEnabledAndVisible(node) {
+    let current = node;
+    while (current && typeof current === 'object') {
+        const candidate = current;
+        if (typeof candidate.isEnabled === 'function' && !candidate.isEnabled())
+            return false;
+        if (candidate.isVisible === false)
+            return false;
+        current = candidate.parent;
+    }
+    return true;
+}
+function readNonEmptyString(value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : null;
+}
+function isRecord(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+function createSourceNodeIdsHash(sourceNodeIds) {
+    return createFnv1aHash([...new Set(sourceNodeIds)]);
+}
+function createFnv1aHash(value) {
+    const text = stableStringify(value);
+    let hash = 0x811c9dc5;
+    for (let index = 0; index < text.length; index += 1) {
+        hash ^= text.charCodeAt(index);
+        hash = Math.imul(hash, 0x01000193);
+    }
+    return `fnv1a:${(hash >>> 0).toString(16).padStart(8, '0')}`;
+}
+function stableStringify(value) {
+    if (value == null || typeof value !== 'object')
+        return JSON.stringify(value);
+    if (Array.isArray(value))
+        return `[${value.map(stableStringify).join(',')}]`;
+    const entries = Object.entries(value)
+        .sort(([left], [right]) => left.localeCompare(right));
+    return `{${entries.map(([key, entry]) => `${JSON.stringify(key)}:${stableStringify(entry)}`).join(',')}}`;
+}
+function sanitizeName(value) {
+    return value.trim().replace(/[^a-z0-9_-]+/gi, '_') || 'chunk';
+}
+function readBoolean(value, fallback) {
+    return typeof value === 'boolean' ? value : fallback;
+}
+function readFiniteNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : null;
+}
+function readFiniteNumberWithFallback(value, fallback) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : fallback;
+}
+function readNonNegativeNumber(value, fallback) {
+    const next = readFiniteNumberWithFallback(value, fallback);
+    return next >= 0 ? next : fallback;
+}
+function readClampedNumber(value, fallback, min, max) {
+    return Math.min(max, Math.max(min, readFiniteNumberWithFallback(value, fallback)));
+}
+//# sourceMappingURL=static-projected-shadow-artifact-system.js.map