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

package/node_modules/@fps-games/editor-babylon/dist/projection.js

@@ -15,6 +15,9 @@ function requireBabylonCtor(value, name) {
 export function createBabylonEditorProjection(options) {
     const projections = new Map();
     const projectionParentIds = new Map();
+    const projectionAuthoredActive = new Map();
+    const previewVisibilityOverrides = new Map();
+    const shadowDebugOverlayObjects = [];
     const selectionEdgesPrewarm = options.selectionEdgesPrewarm ?? 'eager';
     const activeBatches = new Set();
     const idleWaiters = new Set();
@@ -115,6 +118,7 @@ export function createBabylonEditorProjection(options) {
             batch.settledNodeIds.add(node.id);
             if (projections.get(node.id) === projection && !projection.root.isDisposed?.()) {
                 delete projection.loadPromise;
+                applyProjectionPreviewVisibility(node.id);
                 applyProjectionOutline(node, projection);
                 scheduleProjectionSelectionEdgesPrewarm(projection);
                 options.onProjectionReady?.({ nodeId: node.id, async: true });
@@ -137,11 +141,42 @@ export function createBabylonEditorProjection(options) {
     const disposeAll = () => {
         markActiveBatchesStale();
         projectionGeneration += 1;
+        clearShadowDebugOverlayObjects();
         for (const projection of projections.values()) {
             disposeProjectedNode(projection);
         }
         projections.clear();
         projectionParentIds.clear();
+        projectionAuthoredActive.clear();
+        previewVisibilityOverrides.clear();
+    };
+    const createPreviewVisibilityEntry = (nodeId, visible) => {
+        const authoredActive = projectionAuthoredActive.get(nodeId) !== false;
+        return {
+            nodeId,
+            visible,
+            authoredActive,
+            effectiveVisible: authoredActive && visible !== false,
+        };
+    };
+    const applyProjectionPreviewVisibility = (nodeId) => {
+        const projection = projections.get(nodeId);
+        if (!projection)
+            return;
+        const authoredActive = projectionAuthoredActive.get(nodeId) !== false;
+        const override = previewVisibilityOverrides.get(nodeId);
+        const effectiveVisible = authoredActive && override !== false;
+        projection.root?.setEnabled?.(effectiveVisible);
+        for (const runtimeObject of projection.runtimeObjects) {
+            runtimeObject.setEnabled?.(effectiveVisible);
+        }
+    };
+    const clearShadowDebugOverlayObjects = () => {
+        const hadObjects = shadowDebugOverlayObjects.length > 0;
+        for (const object of shadowDebugOverlayObjects.splice(0)) {
+            object.dispose?.();
+        }
+        return hadObjects;
     };
     const scheduleProjectionSelectionEdgesPrewarm = (projection) => {
         projection.selectionEdgesPrewarmCancel?.();
@@ -179,7 +214,8 @@ export function createBabylonEditorProjection(options) {
         };
         projections.set(node.id, projection);
         projectionParentIds.set(node.id, node.parentId ?? null);
-        root.setEnabled?.(node.active !== false);
+        projectionAuthoredActive.set(node.id, node.active !== false);
+        applyProjectionPreviewVisibility(node.id);
         if (node.transform)
             applyProjectionTransform(options.babylon, root, node.transform);
         if (node.helperKind !== 'root' && !attachRuntimeProjection(options.babylon, options.scene, node, projection)) {
@@ -214,6 +250,8 @@ export function createBabylonEditorProjection(options) {
             return;
         projections.delete(nodeId);
         projectionParentIds.delete(nodeId);
+        projectionAuthoredActive.delete(nodeId);
+        previewVisibilityOverrides.delete(nodeId);
         syncProjectionHierarchy();
         disposeProjectedNode(existing);
     };
@@ -308,16 +346,29 @@ export function createBabylonEditorProjection(options) {
             const projection = projections.get(node.id);
             if (!projection)
                 return;
-            projection.root?.setEnabled?.(node.active !== false);
-            for (const runtimeObject of projection.runtimeObjects) {
-                runtimeObject.setEnabled?.(node.active !== false);
-            }
+            projectionAuthoredActive.set(node.id, node.active !== false);
+            applyProjectionPreviewVisibility(node.id);
             projectionParentIds.set(node.id, node.parentId ?? null);
             syncProjectionHierarchy();
             if (node.transform)
                 applyProjectionTransform(options.babylon, projection.root, node.transform);
             scheduleProjectionSelectionEdgesPrewarm(projection);
         },
+        syncRuntimeNode(node) {
+            const projection = projections.get(node.id);
+            if (!projection || node.runtimeKind !== 'light')
+                return false;
+            projectionAuthoredActive.set(node.id, node.active !== false);
+            applyProjectionPreviewVisibility(node.id);
+            projectionParentIds.set(node.id, node.parentId ?? null);
+            syncProjectionHierarchy();
+            if (node.transform)
+                applyProjectionTransform(options.babylon, projection.root, node.transform);
+            if (!syncRuntimeLightProjection(options.babylon, options.scene, node, projection))
+                return false;
+            scheduleProjectionSelectionEdgesPrewarm(projection);
+            return true;
+        },
         syncNodeMetadata(node) {
             const projection = projections.get(node.id);
             if (!projection)
@@ -342,6 +393,55 @@ export function createBabylonEditorProjection(options) {
         getProjectedNode(nodeId) {
             return projections.get(nodeId) ?? null;
         },
+        getProjectedNodeIds() {
+            return [...projections.keys()];
+        },
+        getProjectionParentIds(nodeId) {
+            const parentIds = [];
+            const seen = new Set([nodeId]);
+            let currentId = nodeId;
+            while (currentId) {
+                const parentId = projectionParentIds.get(currentId) ?? null;
+                if (!parentId || parentId === currentId || seen.has(parentId))
+                    break;
+                seen.add(parentId);
+                parentIds.push(parentId);
+                currentId = parentId;
+            }
+            return parentIds;
+        },
+        getPreviewVisibilityOverrides() {
+            return [...previewVisibilityOverrides.entries()]
+                .map(([nodeId, visible]) => createPreviewVisibilityEntry(nodeId, visible));
+        },
+        setPreviewVisibilityOverrides(overrides) {
+            for (const [nodeId, visible] of Object.entries(overrides)) {
+                if (!projections.has(nodeId))
+                    continue;
+                previewVisibilityOverrides.set(nodeId, visible !== false);
+                applyProjectionPreviewVisibility(nodeId);
+            }
+            return this.getPreviewVisibilityOverrides();
+        },
+        clearPreviewVisibilityOverrides() {
+            const changedNodeIds = [...previewVisibilityOverrides.keys()];
+            previewVisibilityOverrides.clear();
+            for (const nodeId of changedNodeIds)
+                applyProjectionPreviewVisibility(nodeId);
+            return [];
+        },
+        setShadowDebugOverlay(items) {
+            clearShadowDebugOverlayObjects();
+            for (const item of items) {
+                const object = createShadowDebugOverlayObject(options.babylon, options.scene, item);
+                if (object)
+                    shadowDebugOverlayObjects.push(object);
+            }
+            return items.map(item => item.id);
+        },
+        clearShadowDebugOverlay() {
+            return clearShadowDebugOverlayObjects();
+        },
         dispose() {
             disposeAll();
         },
@@ -354,6 +454,156 @@ function readVector3(value, fallback) {
         z: Number.isFinite(value?.z) ? Number(value.z) : fallback.z,
     };
 }
+function createShadowDebugOverlayObject(babylon, scene, item) {
+    if (item.kind === 'light-direction')
+        return createShadowDebugDirectionOverlay(babylon, scene, item);
+    const bounds = item.bounds ?? createBoundsFromCenterSize(item.center, item.size);
+    if (!bounds)
+        return null;
+    const MeshBuilder = babylon.MeshBuilder;
+    const StandardMaterial = babylon.StandardMaterial;
+    if (!MeshBuilder?.CreateBox || !StandardMaterial)
+        return null;
+    const size = {
+        x: Math.max(Math.abs(bounds.size.x), 0.01),
+        y: Math.max(Math.abs(bounds.size.y), item.kind === 'footprint' ? 0.015 : 0.01),
+        z: Math.max(Math.abs(bounds.size.z), 0.01),
+    };
+    const mesh = MeshBuilder.CreateBox(`${item.id}.shadowDebugOverlay`, {
+        width: size.x,
+        height: size.y,
+        depth: size.z,
+    }, scene);
+    if (!mesh)
+        return null;
+    mesh.id = item.id;
+    mesh.name = item.id;
+    mesh.isPickable = false;
+    mesh.renderingGroupId = 3;
+    mesh.metadata = createShadowDebugOverlayMetadata();
+    mesh.position = createBabylonVector3(babylon, bounds.center);
+    const material = new StandardMaterial(`${item.id}.shadowDebugOverlay.material`, scene);
+    const color = readShadowDebugOverlayColor(babylon, item.kind);
+    if (color) {
+        material.diffuseColor = color;
+        material.emissiveColor = color;
+    }
+    material.alpha = item.kind === 'receiver-surface' ? 0.14 : item.kind === 'footprint' ? 0.32 : 0.5;
+    material.wireframe = item.kind !== 'footprint' && item.kind !== 'receiver-surface';
+    material.disableLighting = true;
+    mesh.material = material;
+    const disposeMaterial = material.dispose?.bind(material);
+    const disposeMesh = mesh.dispose?.bind(mesh);
+    mesh.dispose = (...args) => {
+        disposeMaterial?.();
+        return disposeMesh?.(...args);
+    };
+    return mesh;
+}
+function createShadowDebugDirectionOverlay(babylon, scene, item) {
+    const MeshBuilder = babylon.MeshBuilder;
+    if (!MeshBuilder?.CreateLineSystem)
+        return null;
+    const center = item.center ?? item.bounds?.center;
+    const direction = normalizeDebugVec3(item.direction ?? { x: -0.3, y: -1, z: -0.2 });
+    if (!center || !direction)
+        return null;
+    const length = Math.max(item.size?.x ?? item.bounds?.size.x ?? 2, item.size?.y ?? item.bounds?.size.y ?? 2, item.size?.z ?? item.bounds?.size.z ?? 2, 2);
+    const start = createBabylonVector3(babylon, {
+        x: center.x - direction.x * length * 0.5,
+        y: center.y - direction.y * length * 0.5,
+        z: center.z - direction.z * length * 0.5,
+    });
+    const end = createBabylonVector3(babylon, {
+        x: center.x + direction.x * length * 0.5,
+        y: center.y + direction.y * length * 0.5,
+        z: center.z + direction.z * length * 0.5,
+    });
+    const arrowLeft = createBabylonVector3(babylon, {
+        x: end.x - direction.x * length * 0.18 + direction.z * length * 0.08,
+        y: end.y - direction.y * length * 0.18,
+        z: end.z - direction.z * length * 0.18 - direction.x * length * 0.08,
+    });
+    const arrowRight = createBabylonVector3(babylon, {
+        x: end.x - direction.x * length * 0.18 - direction.z * length * 0.08,
+        y: end.y - direction.y * length * 0.18,
+        z: end.z - direction.z * length * 0.18 + direction.x * length * 0.08,
+    });
+    const line = MeshBuilder.CreateLineSystem(`${item.id}.shadowDebugOverlay`, {
+        lines: [
+            [start, end],
+            [end, arrowLeft],
+            [end, arrowRight],
+        ],
+    }, scene);
+    if (!line)
+        return null;
+    line.id = item.id;
+    line.name = item.id;
+    line.isPickable = false;
+    line.renderingGroupId = 3;
+    line.metadata = createShadowDebugOverlayMetadata();
+    const color = readShadowDebugOverlayColor(babylon, item.kind);
+    if (color)
+        line.color = color;
+    return line;
+}
+function createShadowDebugOverlayMetadata() {
+    return {
+        shadowDebugOverlayInternal: true,
+        disablePlanarShadow: true,
+        disableBlobShadow: true,
+        disableStaticProjectedShadow: true,
+    };
+}
+function createBoundsFromCenterSize(center, size) {
+    if (!center || !size)
+        return null;
+    return {
+        center,
+        size,
+        min: {
+            x: center.x - size.x / 2,
+            y: center.y - size.y / 2,
+            z: center.z - size.z / 2,
+        },
+        max: {
+            x: center.x + size.x / 2,
+            y: center.y + size.y / 2,
+            z: center.z + size.z / 2,
+        },
+    };
+}
+function createBabylonVector3(babylon, value) {
+    const Vector3 = babylon.Vector3;
+    return Vector3 ? new Vector3(value.x, value.y, value.z) : { x: value.x, y: value.y, z: value.z };
+}
+function normalizeDebugVec3(value) {
+    const length = Math.hypot(value.x, value.y, value.z);
+    if (!Number.isFinite(length) || length <= 0.0001)
+        return null;
+    return {
+        x: value.x / length,
+        y: value.y / length,
+        z: value.z / length,
+    };
+}
+function readShadowDebugOverlayColor(babylon, kind) {
+    const Color3 = babylon.Color3;
+    if (!Color3)
+        return null;
+    if (kind === 'caster-bounds')
+        return new Color3(1, 0.78, 0.1);
+    if (kind === 'receiver-bounds')
+        return new Color3(0.1, 0.75, 1);
+    if (kind === 'receiver-surface')
+        return new Color3(0.05, 0.55, 1);
+    if (kind === 'light-direction')
+        return new Color3(1, 0.95, 0.2);
+    if (kind === 'footprint')
+        return new Color3(0.1, 1, 0.42);
+    return new Color3(1, 0.25, 0.25);
+}
 function addVec3(left, right) {
     return {
         x: left.x + right.x,
@@ -483,7 +733,7 @@ function createProjectionRoot(babylon, scene, node) {
         editorProjection: {
             nodeId: node.id,
             ...(node.runtimeKind ? { runtimeKind: node.runtimeKind } : {}),
-            ...(node.shadowMode ? { shadowMode: node.shadowMode } : {}),
+            ...createProjectionShadowMetadata(node),
         },
     };
     return root;
@@ -536,7 +786,7 @@ function attachImportedProjectionResult(options, node, asset, projection, result
             editorProjection: {
                 nodeId: node.id,
                 sourceId: asset.sourceId,
-                ...(node.shadowMode ? { shadowMode: node.shadowMode } : {}),
+                ...createProjectionShadowMetadata(node),
             },
         };
         applyAssetDefaultsTransform(babylon, modelRoot, asset.transform);
@@ -556,7 +806,7 @@ function attachImportedProjectionResult(options, node, asset, projection, result
                 editorProjection: {
                     nodeId: node.id,
                     sourceId: asset.sourceId,
-                    ...(node.shadowMode ? { shadowMode: node.shadowMode } : {}),
+                    ...createProjectionShadowMetadata(node),
                 },
             };
         }
@@ -575,7 +825,7 @@ function attachImportedProjectionResult(options, node, asset, projection, result
                         ownerNodePath,
                         ...(selectionKey !== ownerNodePath ? { slotSelectionKey: selectionKey } : {}),
                         runtimeKind: 'assetMesh',
-                        ...(node.shadowMode ? { shadowMode: node.shadowMode } : {}),
+                        ...createProjectionShadowMetadata(node),
                     },
                 };
             }
@@ -965,7 +1215,7 @@ function createPrimitiveProjectionMesh(babylon, scene, node, options) {
     mesh.metadata = createProjectionMetadata(node.id, {
         runtimeKind: 'primitive',
         primitiveShape: shape,
-        ...(node.shadowMode ? { shadowMode: node.shadowMode } : {}),
+        ...createProjectionShadowMetadata(node),
     });
     return mesh;
 }
@@ -1242,7 +1492,7 @@ function createFallbackProjectionMesh(babylon, scene, node, rendererFallback) {
         editorProjection: {
             nodeId: node.id,
             fallback: true,
-            ...(node.shadowMode ? { shadowMode: node.shadowMode } : {}),
+            ...createProjectionShadowMetadata(node),
         },
     };
     return mesh;
@@ -1386,6 +1636,76 @@ function attachHemisphericLightProjection(babylon, scene, node, projection) {
     projection.runtimeObjects.push(material);
     projection.outlineMeshes = [helper];
 }
+function syncRuntimeLightProjection(babylon, scene, node, projection) {
+    if (node.light?.type === 'hemispheric') {
+        return syncRuntimeHemisphericLightProjection(babylon, scene, node, projection);
+    }
+    return syncRuntimeDirectionalLightProjection(babylon, scene, node, projection);
+}
+function syncRuntimeDirectionalLightProjection(babylon, scene, node, projection) {
+    const settings = readProjectionDirectionalLightSettings(node.light?.type === 'directional' ? node.light : undefined);
+    const light = findProjectionRuntimeLight(projection, node.id, 'directional');
+    if (!light)
+        return false;
+    const hasHelper = !!scene.getMeshByName?.(`${node.id}.lightHelper`);
+    if (settings.helperVisible !== hasHelper)
+        return false;
+    const Vector3 = requireBabylonCtor(babylon.Vector3, 'Vector3');
+    const Color3 = requireBabylonCtor(babylon.Color3, 'Color3');
+    copyOrAssignBabylonVec3(light, 'direction', new Vector3(settings.direction.x, settings.direction.y, settings.direction.z));
+    light.intensity = settings.intensity;
+    copyOrAssignBabylonColor(light, 'diffuse', new Color3(settings.diffuseColor?.r ?? 1, settings.diffuseColor?.g ?? 1, settings.diffuseColor?.b ?? 1));
+    light.setEnabled?.(node.active !== false);
+    if (settings.helperVisible)
+        refreshLightDirectionLines(babylon, scene, node, projection, settings.direction);
+    return true;
+}
+function syncRuntimeHemisphericLightProjection(babylon, scene, node, projection) {
+    const settings = readProjectionHemisphericLightSettings(node.light?.type === 'hemispheric' ? node.light : undefined);
+    const light = findProjectionRuntimeLight(projection, node.id, 'hemispheric');
+    if (!light)
+        return false;
+    const hasHelper = !!scene.getMeshByName?.(`${node.id}.hemisphericLightHelper`);
+    if (settings.helperVisible !== hasHelper)
+        return false;
+    const Color3 = requireBabylonCtor(babylon.Color3, 'Color3');
+    light.intensity = settings.intensity;
+    copyOrAssignBabylonColor(light, 'diffuse', new Color3(settings.diffuseColor?.r ?? 1, settings.diffuseColor?.g ?? 1, settings.diffuseColor?.b ?? 1));
+    copyOrAssignBabylonColor(light, 'groundColor', new Color3(settings.groundColor?.r ?? 0.48, settings.groundColor?.g ?? 0.52, settings.groundColor?.b ?? 0.62));
+    light.setEnabled?.(node.active !== false);
+    return true;
+}
+function findProjectionRuntimeLight(projection, nodeId, lightType) {
+    return projection.runtimeObjects.find(runtimeObject => {
+        const metadata = runtimeObject?.metadata?.editorProjection;
+        return metadata?.nodeId === nodeId
+            && metadata?.runtimeKind === 'light'
+            && metadata?.lightType === lightType;
+    }) ?? null;
+}
+function refreshLightDirectionLines(babylon, scene, node, projection, direction) {
+    const existing = scene.getMeshByName?.(`${node.id}.lightDirection`);
+    existing?.dispose?.();
+    const arrow = createLightDirectionLines(babylon, scene, node, direction);
+    if (!arrow)
+        return;
+    arrow.parent = projection.root;
+    arrow.isPickable = false;
+}
+function copyOrAssignBabylonVec3(target, key, value) {
+    if (target?.[key]?.copyFrom) {
+        target[key].copyFrom(value);
+        return;
+    }
+    target[key] = value;
+}
+function copyOrAssignBabylonColor(target, key, value) {
+    if (target?.[key]?.copyFrom) {
+        target[key].copyFrom(value);
+        return;
+    }
+    target[key] = value;
+}
 export function normalizeBabylonEditorProjectionCameraSettings(settings) {
     const targetOffset = readOptionalProjectionVec3(settings?.targetOffset);
     const targetScreenOffset = readOptionalProjectionVec2(settings?.targetScreenOffset);
@@ -1558,6 +1878,13 @@ function createProjectionMetadata(nodeId, extra = {}) {
         },
     };
 }
+function createProjectionShadowMetadata(node) {
+    return {
+        ...(node.shadowMode ? { shadowMode: node.shadowMode } : {}),
+        ...(node.shadow ? { shadow: structuredClone(node.shadow) } : {}),
+        ...(node.shadowPlan ? { shadowPlan: structuredClone(node.shadowPlan) } : {}),
+    };
+}
 function syncProjectionNodeMetadata(projection, node) {
     walkProjectionRuntimeNodes(projection.root, (runtimeNode) => {
         syncProjectionRuntimeNodeMetadata(runtimeNode, node);
@@ -1586,6 +1913,14 @@ function syncProjectionRuntimeNodeMetadata(runtimeNode, node) {
         nextEditorProjection.shadowMode = node.shadowMode;
     else
         delete nextEditorProjection.shadowMode;
+    if (node.shadow)
+        nextEditorProjection.shadow = structuredClone(node.shadow);
+    else
+        delete nextEditorProjection.shadow;
+    if (node.shadowPlan)
+        nextEditorProjection.shadowPlan = structuredClone(node.shadowPlan);
+    else
+        delete nextEditorProjection.shadowPlan;
     runtimeNode.metadata = {
         ...(metadata ?? {}),
         editorProjection: nextEditorProjection,