@fps-games/editor 0.1.4-beta.5 → 0.1.5-beta.1

package/node_modules/@fps-games/babylon-renderer/dist/shadows/static-projected-shadow-baker.js

@@ -0,0 +1,813 @@
+import { DirectionalLight } from '@babylonjs/core/Lights/directionalLight.js';
+import { Matrix, Vector3 } from '@babylonjs/core/Maths/math.vector.js';
+import { RenderTargetTexture } from '@babylonjs/core/Materials/Textures/renderTargetTexture.js';
+import { AbstractMesh } from '@babylonjs/core/Meshes/abstractMesh.js';
+import { InstancedMesh } from '@babylonjs/core/Meshes/instancedMesh.js';
+import { Mesh } from '@babylonjs/core/Meshes/mesh.js';
+import { buildStaticProjectedShadowBounds, collectStaticProjectedShadowNodeMeshes, createStaticProjectedShadowMaskTexture, } from './static-projected-shadow-bake.js';
+import { copyStaticProjectedShadowSdfTileToAtlas, createStaticProjectedShadowAtlasPixels, createStaticProjectedShadowSdfTileFromMaskPixels, packStaticProjectedShadowAtlasTiles, } from './static-projected-shadow-atlas.js';
+import { resolveStaticProjectedShadowOptions } from './static-projected-shadow-system.js';
+import { DEFAULT_STATIC_PROJECTED_SHADOW_OPTIONS, } from './types.js';
+const DEFAULT_SHADOW_DIRECTION = new Vector3(-0.3, -1, -0.2).normalize();
+export function createStaticProjectedShadowBaker(options) {
+    return new BabylonStaticProjectedShadowBaker(options);
+}
+export function collectStaticProjectedShadowBakeRoots(scene) {
+    const candidates = scene.meshes.filter(isExplicitStaticProjectedShadowRoot);
+    const candidateSet = new Set(candidates);
+    return candidates.filter(mesh => !hasSelectedAncestor(mesh, candidateSet));
+}
+export function createStaticProjectedShadowBakeHashes(input) {
+    const options = resolveStaticProjectedShadowOptions(input.options ?? {});
+    const planeY = options.plane.height + options.plane.yOffset;
+    const lightDir = resolveBakeLightDirection(input.directionalLight);
+    const roots = createBakeRoots(input.roots ?? collectStaticProjectedShadowBakeRoots(input.scene), {
+        lightDir,
+        planeY,
+        padding: options.bake.padding,
+    });
+    return createBakeHashes({ roots, lightDir, planeY, options });
+}
+export function createStaticProjectedShadowProfileHash(options = {}) {
+    return createBakeProfileHash(resolveStaticProjectedShadowOptions(options));
+}
+class BabylonStaticProjectedShadowBaker {
+    constructor(config) {
+        this.config = config;
+        this.readMaskTexturePixels = config.readMaskTexturePixels ?? defaultReadMaskTexturePixels;
+        this.processSdfTile = config.processSdfTile ?? defaultProcessSdfTile;
+        this.encodeAtlasTexture = config.encodeAtlasTexture ?? defaultEncodeAtlasTexture;
+        this.yieldToMainThread = config.yieldToMainThread;
+        this.now = config.now ?? (() => new Date().toISOString());
+    }
+    async bake(input = {}) {
+        const startedAt = nowMs();
+        const options = resolveStaticProjectedShadowOptions(this.config.options ?? {});
+        const planeY = options.plane.height + options.plane.yOffset;
+        const lightDir = resolveBakeLightDirection(this.config.directionalLight);
+        const roots = createBakeRoots(input.roots ?? this.config.roots ?? collectStaticProjectedShadowBakeRoots(this.config.scene), {
+            lightDir,
+            planeY,
+            padding: options.bake.padding,
+        });
+        const sourceMeshCount = roots.reduce((sum, root) => sum + root.meshes.length, 0);
+        const { sourceHash, lightHash, profileHash } = createBakeHashes({ roots, lightDir, planeY, options });
+        const chunkPlan = createBakeChunkPlan(roots, {
+            chunkSize: options.bake.spatialChunkSize,
+            targetChunkCount: options.bake.targetChunkCount,
+            planeY,
+        });
+        const chunks = chunkPlan.chunks;
+        const previousArtifact = input.previousArtifact ?? this.config.previousArtifact ?? null;
+        let chunkWorks = chunks.map(createBakeChunkWork);
+        let reusedChunks = collectReusableArtifactChunks(previousArtifact, chunkWorks, {
+            lightHash,
+            profileHash,
+            planeHeight: options.plane.height,
+            planeYOffset: options.plane.yOffset,
+        });
+        let dirtyChunkWorks = chunkWorks.filter(work => !reusedChunks.chunkIds.has(work.chunk.id));
+        let packing = packDirtyChunkWorks(dirtyChunkWorks, options.bake, Math.max(1, options.bake.maxAtlasPages - reusedChunks.pages.length));
+        if (dirtyChunkWorks.length > 0
+            && reusedChunks.chunks.length > 0
+            && reusedChunks.pages.length + packing.pages.length > options.bake.maxAtlasPages) {
+            reusedChunks = createEmptyReusableArtifactChunks();
+            dirtyChunkWorks = chunkWorks;
+            packing = packDirtyChunkWorks(dirtyChunkWorks, options.bake, options.bake.maxAtlasPages);
+        }
+        await this.reportProgress({
+            phase: 'collect',
+            sourceRootCount: roots.length,
+            sourceMeshCount,
+            completedChunkCount: reusedChunks.chunks.length,
+            totalChunkCount: chunks.length,
+            encodedTextureCount: 0,
+            atlasPageCount: packing.pages.length,
+            effectiveTexelsPerMeter: packing.effectiveTexelsPerMeter,
+            effectiveSpatialChunkSize: chunkPlan.effectiveChunkSize,
+            bakedChunkCount: 0,
+            reusedChunkCount: reusedChunks.chunks.length,
+        });
+        await this.yieldProgress({
+            phase: 'reuse',
+            sourceRootCount: roots.length,
+            sourceMeshCount,
+            completedChunkCount: reusedChunks.chunks.length,
+            totalChunkCount: chunks.length,
+            encodedTextureCount: 0,
+            atlasPageCount: packing.pages.length,
+            effectiveTexelsPerMeter: packing.effectiveTexelsPerMeter,
+            effectiveSpatialChunkSize: chunkPlan.effectiveChunkSize,
+            bakedChunkCount: 0,
+            reusedChunkCount: reusedChunks.chunks.length,
+        });
+        const atlasPixelsByPageId = new Map();
+        const pageLayoutsById = new Map(packing.pages.map(page => [page.id, page]));
+        const reusedPageIds = new Set(reusedChunks.pages.map(page => page.id));
+        const bakedPageIds = createBakedPageIds(packing.pages.map(page => page.id), reusedPageIds);
+        for (const page of packing.pages) {
+            atlasPixelsByPageId.set(page.id, createStaticProjectedShadowAtlasPixels(page.width, page.height));
+        }
+        const pendingChunks = [];
+        for (let index = 0; index < dirtyChunkWorks.length; index += 1) {
+            const work = dirtyChunkWorks[index];
+            const chunk = work.chunk;
+            const layout = packing.layoutsByTileId.get(chunk.id);
+            if (!layout)
+                continue;
+            const completedBefore = reusedChunks.chunks.length + index;
+            await this.reportProgress({
+                phase: 'chunk',
+                sourceRootCount: roots.length,
+                sourceMeshCount,
+                completedChunkCount: completedBefore,
+                totalChunkCount: chunks.length,
+                encodedTextureCount: pendingChunks.length,
+                currentChunkId: chunk.id,
+                atlasPageCount: packing.pages.length,
+                effectiveTexelsPerMeter: packing.effectiveTexelsPerMeter,
+                effectiveSpatialChunkSize: chunkPlan.effectiveChunkSize,
+                bakedChunkCount: pendingChunks.length,
+                reusedChunkCount: reusedChunks.chunks.length,
+            });
+            const mask = await createStaticProjectedShadowMaskTexture(chunk.roots.flatMap(root => root.meshes), {
+                scene: this.config.scene,
+                name: chunk.id,
+                bounds: chunk.bounds,
+                lightDir,
+                planeY,
+                resolution: {
+                    width: layout.width,
+                    height: layout.height,
+                },
+            });
+            if (!mask) {
+                await this.reportProgress({
+                    phase: 'chunk',
+                    sourceRootCount: roots.length,
+                    sourceMeshCount,
+                    completedChunkCount: completedBefore + 1,
+                    totalChunkCount: chunks.length,
+                    encodedTextureCount: pendingChunks.length,
+                    currentChunkId: chunk.id,
+                    atlasPageCount: packing.pages.length,
+                    effectiveTexelsPerMeter: packing.effectiveTexelsPerMeter,
+                    effectiveSpatialChunkSize: chunkPlan.effectiveChunkSize,
+                    bakedChunkCount: pendingChunks.length,
+                    reusedChunkCount: reusedChunks.chunks.length,
+                });
+                await this.yieldProgress({
+                    phase: 'chunk',
+                    sourceRootCount: roots.length,
+                    sourceMeshCount,
+                    completedChunkCount: completedBefore + 1,
+                    totalChunkCount: chunks.length,
+                    encodedTextureCount: pendingChunks.length,
+                    currentChunkId: chunk.id,
+                    atlasPageCount: packing.pages.length,
+                    effectiveTexelsPerMeter: packing.effectiveTexelsPerMeter,
+                    effectiveSpatialChunkSize: chunkPlan.effectiveChunkSize,
+                    bakedChunkCount: pendingChunks.length,
+                    reusedChunkCount: reusedChunks.chunks.length,
+                });
+                continue;
+            }
+            try {
+                await this.reportProgress({
+                    phase: 'sdf',
+                    sourceRootCount: roots.length,
+                    sourceMeshCount,
+                    completedChunkCount: completedBefore,
+                    totalChunkCount: chunks.length,
+                    encodedTextureCount: pendingChunks.length,
+                    currentChunkId: chunk.id,
+                    atlasPageCount: packing.pages.length,
+                    effectiveTexelsPerMeter: packing.effectiveTexelsPerMeter,
+                    effectiveSpatialChunkSize: chunkPlan.effectiveChunkSize,
+                    bakedChunkCount: pendingChunks.length,
+                    reusedChunkCount: reusedChunks.chunks.length,
+                });
+                const maskPixels = await this.readMaskTexturePixels({
+                    texture: mask.texture,
+                    chunkId: chunk.id,
+                    bounds: chunk.bounds,
+                    width: layout.width,
+                    height: layout.height,
+                });
+                if (!maskPixels || maskPixels.width !== layout.width || maskPixels.height !== layout.height)
+                    continue;
+                const sdfTile = await this.processSdfTile({
+                    chunkId: chunk.id,
+                    pixels: maskPixels.pixels,
+                    width: maskPixels.width,
+                    height: maskPixels.height,
+                    sdfRadiusPx: options.bake.sdfRadiusPx,
+                });
+                if (!sdfTile?.hasCoverage || sdfTile.width !== maskPixels.width || sdfTile.height !== maskPixels.height)
+                    continue;
+                const atlasPixels = atlasPixelsByPageId.get(layout.pageId);
+                const pageLayout = pageLayoutsById.get(layout.pageId);
+                if (!atlasPixels)
+                    continue;
+                if (!pageLayout)
+                    continue;
+                copyStaticProjectedShadowSdfTileToAtlas(atlasPixels, pageLayout.width, sdfTile.sdfAlpha, maskPixels.width, maskPixels.height, layout.copyX, layout.copyY);
+                const pageId = bakedPageIds.get(layout.pageId) ?? layout.pageId;
+                pendingChunks.push({
+                    id: chunk.id,
+                    bounds: {
+                        minX: roundNumber(chunk.bounds.minX),
+                        maxX: roundNumber(chunk.bounds.maxX),
+                        minZ: roundNumber(chunk.bounds.minZ),
+                        maxZ: roundNumber(chunk.bounds.maxZ),
+                        y: roundNumber(chunk.bounds.center.y),
+                    },
+                    plane: {
+                        height: roundNumber(options.plane.height),
+                        yOffset: roundNumber(options.plane.yOffset),
+                    },
+                    pageId,
+                    atlasRect: layout.atlasRect,
+                    atlasUv: layout.atlasUv,
+                    sourceNodeIds: work.sourceNodeIds,
+                    sourceHash: work.sourceHash,
+                    lightHash,
+                    profileHash,
+                });
+            }
+            finally {
+                mask.dispose();
+            }
+            await this.reportProgress({
+                phase: 'chunk',
+                sourceRootCount: roots.length,
+                sourceMeshCount,
+                completedChunkCount: completedBefore + 1,
+                totalChunkCount: chunks.length,
+                encodedTextureCount: pendingChunks.length,
+                currentChunkId: chunk.id,
+                atlasPageCount: packing.pages.length,
+                effectiveTexelsPerMeter: packing.effectiveTexelsPerMeter,
+                effectiveSpatialChunkSize: chunkPlan.effectiveChunkSize,
+                bakedChunkCount: pendingChunks.length,
+                reusedChunkCount: reusedChunks.chunks.length,
+            });
+            await this.yieldProgress({
+                phase: 'chunk',
+                sourceRootCount: roots.length,
+                sourceMeshCount,
+                completedChunkCount: completedBefore + 1,
+                totalChunkCount: chunks.length,
+                encodedTextureCount: pendingChunks.length,
+                currentChunkId: chunk.id,
+                atlasPageCount: packing.pages.length,
+                effectiveTexelsPerMeter: packing.effectiveTexelsPerMeter,
+                effectiveSpatialChunkSize: chunkPlan.effectiveChunkSize,
+                bakedChunkCount: pendingChunks.length,
+                reusedChunkCount: reusedChunks.chunks.length,
+            });
+        }
+        await this.reportProgress({
+            phase: 'pack',
+            sourceRootCount: roots.length,
+            sourceMeshCount,
+            completedChunkCount: chunks.length,
+            totalChunkCount: chunks.length,
+            encodedTextureCount: pendingChunks.length,
+            atlasPageCount: reusedChunks.pages.length + packing.pages.length,
+            effectiveTexelsPerMeter: packing.effectiveTexelsPerMeter,
+            effectiveSpatialChunkSize: chunkPlan.effectiveChunkSize,
+            bakedChunkCount: pendingChunks.length,
+            reusedChunkCount: reusedChunks.chunks.length,
+        });
+        const usedPageIds = new Set(pendingChunks.map(chunk => chunk.pageId));
+        const pages = [...reusedChunks.pages];
+        const encodedPageIds = new Set();
+        for (const page of packing.pages) {
+            const pageId = bakedPageIds.get(page.id) ?? page.id;
+            if (!usedPageIds.has(pageId))
+                continue;
+            const pixels = atlasPixelsByPageId.get(page.id);
+            if (!pixels)
+                continue;
+            await this.reportProgress({
+                phase: 'encode',
+                sourceRootCount: roots.length,
+                sourceMeshCount,
+                completedChunkCount: chunks.length,
+                totalChunkCount: chunks.length,
+                encodedTextureCount: pages.length,
+                currentChunkId: pageId,
+                atlasPageCount: reusedChunks.pages.length + packing.pages.length,
+                effectiveTexelsPerMeter: packing.effectiveTexelsPerMeter,
+                effectiveSpatialChunkSize: chunkPlan.effectiveChunkSize,
+                bakedChunkCount: pendingChunks.length,
+                reusedChunkCount: reusedChunks.chunks.length,
+            });
+            const sdfTextureDataUrl = await this.encodeAtlasTexture({
+                pageId,
+                pixels,
+                width: page.width,
+                height: page.height,
+            });
+            if (!isPngDataUrl(sdfTextureDataUrl))
+                continue;
+            pages.push({
+                id: pageId,
+                width: page.width,
+                height: page.height,
+                sdfTextureDataUrl,
+            });
+            encodedPageIds.add(pageId);
+            await this.yieldProgress({
+                phase: 'encode',
+                sourceRootCount: roots.length,
+                sourceMeshCount,
+                completedChunkCount: chunks.length,
+                totalChunkCount: chunks.length,
+                encodedTextureCount: pages.length,
+                currentChunkId: pageId,
+                atlasPageCount: reusedChunks.pages.length + packing.pages.length,
+                effectiveTexelsPerMeter: packing.effectiveTexelsPerMeter,
+                effectiveSpatialChunkSize: chunkPlan.effectiveChunkSize,
+                bakedChunkCount: pendingChunks.length,
+                reusedChunkCount: reusedChunks.chunks.length,
+            });
+        }
+        const artifactChunks = [...reusedChunks.chunks, ...pendingChunks.filter(chunk => encodedPageIds.has(chunk.pageId))]
+            .sort((left, right) => left.id.localeCompare(right.id));
+        const durationMs = Math.max(0, Math.round(nowMs() - startedAt));
+        const atlasUsage = calculateArtifactAtlasUsage(pages, artifactChunks);
+        await this.reportProgress({
+            phase: 'complete',
+            sourceRootCount: roots.length,
+            sourceMeshCount,
+            completedChunkCount: chunks.length,
+            totalChunkCount: chunks.length,
+            encodedTextureCount: pages.length,
+            atlasPageCount: pages.length,
+            effectiveTexelsPerMeter: packing.effectiveTexelsPerMeter,
+            effectiveSpatialChunkSize: chunkPlan.effectiveChunkSize,
+            bakedChunkCount: pendingChunks.length,
+            reusedChunkCount: reusedChunks.chunks.length,
+        });
+        return {
+            version: 2,
+            format: 'sdf-atlas',
+            pages,
+            chunks: artifactChunks,
+            sourceHash,
+            lightHash,
+            profileHash,
+            generatedAt: this.now(),
+            stats: {
+                sourceRootCount: roots.length,
+                sourceMeshCount,
+                attemptedChunkCount: chunks.length,
+                chunkCount: artifactChunks.length,
+                textureCount: pages.length,
+                pageCount: pages.length,
+                skippedChunkCount: Math.max(0, chunks.length - artifactChunks.length),
+                resolution: options.bake.resolution,
+                chunkSize: chunkPlan.effectiveChunkSize,
+                atlasSize: packing.atlasSize,
+                atlasUsedPixels: atlasUsage.usedPixels,
+                atlasAllocatedPixels: atlasUsage.allocatedPixels,
+                atlasOccupancy: atlasUsage.occupancy,
+                texelsPerMeter: options.bake.texelsPerMeter,
+                effectiveTexelsPerMeter: packing.effectiveTexelsPerMeter,
+                maxAtlasPages: options.bake.maxAtlasPages,
+                sdfRadiusPx: options.bake.sdfRadiusPx,
+                spatialChunkSize: options.bake.spatialChunkSize,
+                effectiveSpatialChunkSize: chunkPlan.effectiveChunkSize,
+                targetChunkCount: options.bake.targetChunkCount,
+                bakedChunkCount: pendingChunks.length,
+                reusedChunkCount: reusedChunks.chunks.length,
+                durationMs,
+            },
+        };
+    }
+    async reportProgress(progress) {
+        await this.config.onProgress?.(progress);
+    }
+    async yieldProgress(progress) {
+        await this.yieldToMainThread?.(progress);
+    }
+}
+function calculateArtifactAtlasUsage(pages, chunks) {
+    const pageIds = new Set(pages.map(page => page.id));
+    const usedPixels = chunks.reduce((sum, chunk) => (pageIds.has(chunk.pageId)
+        ? sum + Math.max(0, chunk.atlasRect.width) * Math.max(0, chunk.atlasRect.height)
+        : sum), 0);
+    const allocatedPixels = pages.reduce((sum, page) => (sum + Math.max(0, page.width) * Math.max(0, page.height)), 0);
+    return {
+        usedPixels,
+        allocatedPixels,
+        occupancy: roundNumber(allocatedPixels > 0 ? usedPixels / allocatedPixels : 0),
+    };
+}
+function createBakeHashes(input) {
+    return {
+        sourceHash: createBakeSourceHash(input.roots),
+        lightHash: createBakeLightHash(input.lightDir, input.planeY),
+        profileHash: createBakeProfileHash(input.options),
+    };
+}
+function createBakeChunkWork(chunk) {
+    const sourceNodeIds = uniqueStrings(chunk.roots.map(root => root.sourceNodeId));
+    return {
+        chunk,
+        sourceNodeIds,
+        sourceHash: createBakeHash(sourceNodeIds),
+    };
+}
+function packDirtyChunkWorks(works, bakeOptions, maxAtlasPages) {
+    return packStaticProjectedShadowAtlasTiles(works.map(work => ({
+        id: work.chunk.id,
+        width: Math.max(1e-6, work.chunk.bounds.width),
+        height: Math.max(1e-6, work.chunk.bounds.depth),
+    })), {
+        texelsPerMeter: bakeOptions.texelsPerMeter,
+        atlasSize: bakeOptions.atlasSize,
+        maxAtlasPages: Math.max(1, maxAtlasPages),
+        paddingPx: Math.min(2, Math.max(0, Math.round(bakeOptions.sdfRadiusPx))),
+    });
+}
+function createEmptyReusableArtifactChunks() {
+    return {
+        chunks: [],
+        pages: [],
+        chunkIds: new Set(),
+    };
+}
+function collectReusableArtifactChunks(artifact, works, hashes) {
+    if (!artifact || artifact.version !== 2)
+        return createEmptyReusableArtifactChunks();
+    const pagesById = new Map(artifact.pages
+        .filter(page => isPngDataUrl(page.sdfTextureDataUrl))
+        .map(page => [page.id, page]));
+    if (pagesById.size === 0)
+        return createEmptyReusableArtifactChunks();
+    const worksById = new Map(works.map(work => [work.chunk.id, work]));
+    const reusableChunks = [];
+    const reusablePages = new Map();
+    const reusableChunkIds = new Set();
+    for (const previousChunk of artifact.chunks) {
+        const work = worksById.get(previousChunk.id);
+        const page = pagesById.get(previousChunk.pageId);
+        if (!work || !page)
+            continue;
+        if (previousChunk.sourceHash !== work.sourceHash)
+            continue;
+        if (previousChunk.lightHash !== hashes.lightHash || previousChunk.profileHash !== hashes.profileHash)
+            continue;
+        if (!matchesChunkBounds(previousChunk, work.chunk.bounds))
+            continue;
+        if (!matchesChunkPlane(previousChunk, hashes.planeHeight, hashes.planeYOffset))
+            continue;
+        reusableChunks.push({ ...previousChunk, sourceNodeIds: [...previousChunk.sourceNodeIds] });
+        reusablePages.set(page.id, { ...page });
+        reusableChunkIds.add(previousChunk.id);
+    }
+    return {
+        chunks: reusableChunks,
+        pages: [...reusablePages.values()],
+        chunkIds: reusableChunkIds,
+    };
+}
+function matchesChunkBounds(chunk, bounds) {
+    return chunk.bounds.minX === roundNumber(bounds.minX)
+        && chunk.bounds.maxX === roundNumber(bounds.maxX)
+        && chunk.bounds.minZ === roundNumber(bounds.minZ)
+        && chunk.bounds.maxZ === roundNumber(bounds.maxZ)
+        && chunk.bounds.y === roundNumber(bounds.center.y);
+}
+function matchesChunkPlane(chunk, height, yOffset) {
+    return chunk.plane.height === roundNumber(height)
+        && chunk.plane.yOffset === roundNumber(yOffset);
+}
+function createBakedPageIds(pageIds, existingPageIds) {
+    const used = new Set(existingPageIds);
+    const result = new Map();
+    for (const pageId of pageIds) {
+        let next = pageId;
+        if (used.has(next)) {
+            let suffix = 0;
+            do {
+                next = `bake_${suffix}_${pageId}`;
+                suffix += 1;
+            } while (used.has(next));
+        }
+        used.add(next);
+        result.set(pageId, next);
+    }
+    return result;
+}
+function createBakeSourceHash(roots) {
+    return createBakeHash(roots.map(root => ({
+        id: root.sourceNodeId,
+        name: root.root.name,
+        matrix: serializeMatrix(root.root.getWorldMatrix()),
+        bounds: serializeBounds(root.bounds),
+    })));
+}
+function createBakeLightHash(lightDir, planeY) {
+    return createBakeHash({
+        direction: serializeVector(lightDir),
+        planeY: roundNumber(planeY),
+    });
+}
+function createBakeProfileHash(options) {
+    return createBakeHash({
+        plane: {
+            height: roundNumber(options.plane.height),
+            yOffset: roundNumber(options.plane.yOffset),
+        },
+        bake: {
+            padding: roundNumber(options.bake.padding),
+            maxSize: roundNumber(options.bake.maxSize),
+            texelsPerMeter: roundNumber(options.bake.texelsPerMeter),
+            atlasSize: roundNumber(options.bake.atlasSize),
+            maxAtlasPages: roundNumber(options.bake.maxAtlasPages),
+            sdfRadiusPx: roundNumber(options.bake.sdfRadiusPx),
+            spatialChunkSize: roundNumber(options.bake.spatialChunkSize),
+        },
+    });
+}
+function createBakeRoots(roots, options) {
+    const result = [];
+    for (const root of roots) {
+        if (root.isDisposed() || !root.isEnabled(false) || isStaticProjectedShadowInternal(root))
+            continue;
+        const meshes = collectStaticProjectedShadowNodeMeshes(root).filter(isBakeMesh);
+        if (meshes.length === 0)
+            continue;
+        const bounds = buildStaticProjectedShadowBounds(meshes, {
+            lightDir: options.lightDir,
+            planeY: options.planeY,
+            padding: options.padding,
+        });
+        if (!bounds)
+            continue;
+        result.push({
+            root,
+            sourceNodeId: readEditorProjectionNodeId(root) ?? root.id ?? root.name,
+            meshes,
+            bounds,
+        });
+    }
+    return result;
+}
+function createBakeChunkPlan(roots, options) {
+    const requestedChunkSize = Math.max(options.chunkSize || DEFAULT_STATIC_PROJECTED_SHADOW_OPTIONS.bake.spatialChunkSize, 1);
+    const targetChunkCount = Math.max(1, Math.floor(options.targetChunkCount || DEFAULT_STATIC_PROJECTED_SHADOW_OPTIONS.bake.targetChunkCount));
+    let effectiveChunkSize = requestedChunkSize;
+    let chunks = createBakeChunksAtSize(roots, {
+        chunkSize: effectiveChunkSize,
+        planeY: options.planeY,
+    });
+    for (let attempt = 0; attempt < 6 && chunks.length > targetChunkCount; attempt += 1) {
+        const scale = Math.sqrt(chunks.length / targetChunkCount) * 1.05;
+        effectiveChunkSize = Math.max(effectiveChunkSize + 1e-6, effectiveChunkSize * scale);
+        chunks = createBakeChunksAtSize(roots, {
+            chunkSize: effectiveChunkSize,
+            planeY: options.planeY,
+        });
+    }
+    return {
+        chunks,
+        requestedChunkSize: roundNumber(requestedChunkSize),
+        effectiveChunkSize: roundNumber(effectiveChunkSize),
+    };
+}
+function createBakeChunksAtSize(roots, options) {
+    const chunkSize = Math.max(options.chunkSize || DEFAULT_STATIC_PROJECTED_SHADOW_OPTIONS.bake.maxSize, 1);
+    const chunks = new Map();
+    for (const root of roots) {
+        const minGridX = Math.floor(root.bounds.minX / chunkSize);
+        const maxGridX = Math.floor((root.bounds.maxX - 1e-6) / chunkSize);
+        const minGridZ = Math.floor(root.bounds.minZ / chunkSize);
+        const maxGridZ = Math.floor((root.bounds.maxZ - 1e-6) / chunkSize);
+        for (let gridX = minGridX; gridX <= maxGridX; gridX += 1) {
+            for (let gridZ = minGridZ; gridZ <= maxGridZ; gridZ += 1) {
+                const id = `chunk_${gridX}_${gridZ}`;
+                let chunk = chunks.get(id);
+                if (!chunk) {
+                    chunk = {
+                        id,
+                        gridX,
+                        gridZ,
+                        bounds: createChunkBounds(gridX, gridZ, chunkSize, options.planeY),
+                        roots: [],
+                    };
+                    chunks.set(id, chunk);
+                }
+                chunk.roots.push(root);
+            }
+        }
+    }
+    for (const chunk of chunks.values()) {
+        chunk.bounds = createTightChunkBounds(chunk.roots, chunk.bounds);
+    }
+    return [...chunks.values()].sort((left, right) => left.gridX - right.gridX || left.gridZ - right.gridZ);
+}
+function createChunkBounds(gridX, gridZ, chunkSize, planeY) {
+    const minX = gridX * chunkSize;
+    const maxX = minX + chunkSize;
+    const minZ = gridZ * chunkSize;
+    const maxZ = minZ + chunkSize;
+    return {
+        center: new Vector3((minX + maxX) * 0.5, planeY, (minZ + maxZ) * 0.5),
+        width: chunkSize,
+        depth: chunkSize,
+        minX,
+        maxX,
+        minZ,
+        maxZ,
+    };
+}
+function createTightChunkBounds(roots, gridBounds) {
+    let minX = Infinity;
+    let maxX = -Infinity;
+    let minZ = Infinity;
+    let maxZ = -Infinity;
+    for (const root of roots) {
+        const clippedMinX = Math.max(root.bounds.minX, gridBounds.minX);
+        const clippedMaxX = Math.min(root.bounds.maxX, gridBounds.maxX);
+        const clippedMinZ = Math.max(root.bounds.minZ, gridBounds.minZ);
+        const clippedMaxZ = Math.min(root.bounds.maxZ, gridBounds.maxZ);
+        if (clippedMaxX <= clippedMinX || clippedMaxZ <= clippedMinZ)
+            continue;
+        minX = Math.min(minX, clippedMinX);
+        maxX = Math.max(maxX, clippedMaxX);
+        minZ = Math.min(minZ, clippedMinZ);
+        maxZ = Math.max(maxZ, clippedMaxZ);
+    }
+    if (![minX, maxX, minZ, maxZ].every(Number.isFinite))
+        return gridBounds;
+    return {
+        center: new Vector3((minX + maxX) * 0.5, gridBounds.center.y, (minZ + maxZ) * 0.5),
+        width: maxX - minX,
+        depth: maxZ - minZ,
+        minX,
+        maxX,
+        minZ,
+        maxZ,
+    };
+}
+function isBakeMesh(mesh) {
+    if (mesh.isDisposed() || !mesh.isEnabled(false))
+        return false;
+    if (!(mesh instanceof Mesh) && !(mesh instanceof InstancedMesh))
+        return false;
+    const geometrySource = mesh instanceof InstancedMesh ? mesh.sourceMesh : mesh;
+    if (!(geometrySource instanceof Mesh) || !geometrySource.geometry)
+        return false;
+    return mesh.isVisible && !isStaticProjectedShadowInternal(mesh);
+}
+function isExplicitStaticProjectedShadowRoot(mesh) {
+    if (mesh.isDisposed() || !mesh.isEnabled(false) || isStaticProjectedShadowInternal(mesh))
+        return false;
+    const projection = readEditorProjectionMetadata(mesh);
+    if (projection?.runtimeKind === 'camera' || projection?.runtimeKind === 'light')
+        return false;
+    return projection?.shadowMode === 'static';
+}
+function hasSelectedAncestor(mesh, selected) {
+    let cursor = mesh.parent;
+    while (cursor) {
+        if (cursor instanceof AbstractMesh && selected.has(cursor))
+            return true;
+        cursor = cursor.parent;
+    }
+    return false;
+}
+function isStaticProjectedShadowInternal(mesh) {
+    const metadata = mesh.metadata;
+    return !!metadata
+        && typeof metadata === 'object'
+        && (metadata.disableStaticProjectedShadow === true
+            || metadata.staticProjectedShadowInternal === true
+            || metadata.disableBlobShadow === true
+            || metadata.blobShadowInternal === true
+            || metadata.disablePlanarShadow === true
+            || metadata.planarShadowInternal === true);
+}
+function readEditorProjectionNodeId(mesh) {
+    const nodeId = readEditorProjectionMetadata(mesh)?.nodeId;
+    return typeof nodeId === 'string' && nodeId.trim() ? nodeId.trim() : null;
+}
+function readEditorProjectionMetadata(mesh) {
+    const metadata = mesh.metadata;
+    if (!metadata || typeof metadata !== 'object')
+        return null;
+    const editorProjection = metadata.editorProjection;
+    return editorProjection && typeof editorProjection === 'object' && !Array.isArray(editorProjection)
+        ? editorProjection
+        : null;
+}
+function resolveBakeLightDirection(light) {
+    const direction = light?.direction;
+    return direction?.lengthSquared?.() && direction.lengthSquared() > 1e-6
+        ? direction.clone().normalize()
+        : DEFAULT_SHADOW_DIRECTION.clone();
+}
+async function defaultReadMaskTexturePixels(input) {
+    const pixels = await input.texture.readPixels();
+    if (!pixels)
+        return null;
+    const size = input.texture.getSize();
+    return {
+        pixels,
+        width: Math.max(1, Math.round(size.width || input.width)),
+        height: Math.max(1, Math.round(size.height || input.height)),
+    };
+}
+async function defaultEncodeAtlasTexture(input) {
+    return encodeRgbaPixelsAsPngDataUrl(input.pixels, input.width, input.height);
+}
+function defaultProcessSdfTile(input) {
+    return createStaticProjectedShadowSdfTileFromMaskPixels(input.pixels, input.width, input.height, input.sdfRadiusPx);
+}
+function encodeRgbaPixelsAsPngDataUrl(pixels, width, height) {
+    const canvas = createCanvas(width, height);
+    const context = canvas?.getContext('2d');
+    if (!canvas || !context)
+        return null;
+    const imageData = context.createImageData(width, height);
+    const source = pixels instanceof Uint8Array || pixels instanceof Uint8ClampedArray
+        ? pixels
+        : new Uint8Array(pixels.buffer, pixels.byteOffset, pixels.byteLength);
+    const target = imageData.data;
+    const length = Math.min(source.length, target.length);
+    for (let index = 0; index < length; index += 4) {
+        const alpha = source[index + 3] ?? 0;
+        target[index] = alpha > 0 ? 255 : 0;
+        target[index + 1] = alpha > 0 ? 255 : 0;
+        target[index + 2] = alpha > 0 ? 255 : 0;
+        target[index + 3] = alpha;
+    }
+    context.putImageData(imageData, 0, 0);
+    return typeof canvas.toDataURL === 'function' ? canvas.toDataURL('image/png') : null;
+}
+function createCanvas(width, height) {
+    const documentRef = typeof document === 'undefined' ? null : document;
+    if (!documentRef?.createElement)
+        return null;
+    const canvas = documentRef.createElement('canvas');
+    canvas.width = width;
+    canvas.height = height;
+    return canvas;
+}
+function createBakeHash(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 serializeMatrix(matrix) {
+    return matrix.asArray().map(roundNumber);
+}
+function serializeVector(vector) {
+    return {
+        x: roundNumber(vector.x),
+        y: roundNumber(vector.y),
+        z: roundNumber(vector.z),
+    };
+}
+function serializeBounds(bounds) {
+    return {
+        minX: roundNumber(bounds.minX),
+        maxX: roundNumber(bounds.maxX),
+        minZ: roundNumber(bounds.minZ),
+        maxZ: roundNumber(bounds.maxZ),
+        y: roundNumber(bounds.center.y),
+    };
+}
+function roundNumber(value) {
+    return Math.round(value * 1000000) / 1000000;
+}
+function nowMs() {
+    return typeof performance !== 'undefined' && typeof performance.now === 'function'
+        ? performance.now()
+        : Date.now();
+}
+function uniqueStrings(values) {
+    return [...new Set(values.map(value => value.trim()).filter(Boolean))];
+}
+function isPngDataUrl(value) {
+    return typeof value === 'string' && /^data:image\/png[;,]/i.test(value);
+}
+//# sourceMappingURL=static-projected-shadow-baker.js.map