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

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

@@ -0,0 +1,1395 @@
+import { isEditorTransformTrsSnapshot, } from '@fps-games/editor-core';
+const UNIT_BOX_LINES = [
+    [{ x: -0.5, y: -0.5, z: -0.5 }, { x: 0.5, y: -0.5, z: -0.5 }],
+    [{ x: 0.5, y: -0.5, z: -0.5 }, { x: 0.5, y: 0.5, z: -0.5 }],
+    [{ x: 0.5, y: 0.5, z: -0.5 }, { x: -0.5, y: 0.5, z: -0.5 }],
+    [{ x: -0.5, y: 0.5, z: -0.5 }, { x: -0.5, y: -0.5, z: -0.5 }],
+    [{ x: -0.5, y: -0.5, z: 0.5 }, { x: 0.5, y: -0.5, z: 0.5 }],
+    [{ x: 0.5, y: -0.5, z: 0.5 }, { x: 0.5, y: 0.5, z: 0.5 }],
+    [{ x: 0.5, y: 0.5, z: 0.5 }, { x: -0.5, y: 0.5, z: 0.5 }],
+    [{ x: -0.5, y: 0.5, z: 0.5 }, { x: -0.5, y: -0.5, z: 0.5 }],
+    [{ x: -0.5, y: -0.5, z: -0.5 }, { x: -0.5, y: -0.5, z: 0.5 }],
+    [{ x: 0.5, y: -0.5, z: -0.5 }, { x: 0.5, y: -0.5, z: 0.5 }],
+    [{ x: 0.5, y: 0.5, z: -0.5 }, { x: 0.5, y: 0.5, z: 0.5 }],
+    [{ x: -0.5, y: 0.5, z: -0.5 }, { x: -0.5, y: 0.5, z: 0.5 }],
+];
+const MARKER_FRAME_LINES = [
+    [{ x: -0.08, y: 0, z: 0 }, { x: 0.08, y: 0, z: 0 }],
+    [{ x: 0, y: -0.08, z: 0 }, { x: 0, y: 0.08, z: 0 }],
+    [{ x: 0, y: 0, z: -0.08 }, { x: 0, y: 0, z: 0.08 }],
+    [{ x: 0, y: 0, z: 0 }, { x: 0, y: 0, z: 0.72 }],
+    [{ x: 0, y: 0, z: 0.72 }, { x: -0.08, y: 0, z: 0.58 }],
+    [{ x: 0, y: 0, z: 0.72 }, { x: 0.08, y: 0, z: 0.58 }],
+    [{ x: 0, y: 0, z: 0.72 }, { x: 0, y: 0.08, z: 0.58 }],
+    [{ x: 0, y: 0, z: 0.72 }, { x: 0, y: -0.08, z: 0.58 }],
+];
+const RELATION_DASH_MAX_COUNT = 64;
+const RELATION_DASH_MIN_SEGMENT_LENGTH = 0.04;
+const RELATION_ACTIVE_PULSE_PERIOD_MS = 1100;
+const MARKER_LABEL_WORLD_SCALE = 1.55;
+export function createBabylonEditorMarkerOverlayController(options) {
+    const overlays = new Map();
+    const relationOverlays = new Map();
+    let relationAnimationObserver = null;
+    let relationAnimationTimeMs = 0;
+    let disposed = false;
+    function disposeOverlay(markerRowId) {
+        const overlay = overlays.get(markerRowId);
+        if (!overlay)
+            return false;
+        disposeActiveMarkerOverlay(overlay);
+        overlays.delete(markerRowId);
+        return true;
+    }
+    function disposeRelationOverlay(relationId) {
+        const overlay = relationOverlays.get(relationId);
+        if (!overlay)
+            return false;
+        disposeActiveMarkerRelationOverlay(overlay);
+        relationOverlays.delete(relationId);
+        syncRelationAnimationObserver();
+        return true;
+    }
+    function sync(input) {
+        if (disposed)
+            return false;
+        let changed = false;
+        const nextRowIds = new Set();
+        const selectedMarkerRowIds = new Set(input.selectedMarkerRowIds ?? []);
+        for (const entry of input.markers) {
+            if (!entry.markerRowId)
+                continue;
+            const presentation = resolveMarkerOverlayPresentation(entry.marker);
+            nextRowIds.add(entry.markerRowId);
+            let overlay = overlays.get(entry.markerRowId) ?? null;
+            if (!overlay || overlay.markerId !== entry.marker.id || overlay.presentation !== presentation) {
+                if (overlay)
+                    disposeOverlay(entry.markerRowId);
+                overlay = createActiveMarkerOverlay(options, entry.markerRowId, entry.marker.id, presentation);
+                if (!overlay)
+                    continue;
+                overlays.set(entry.markerRowId, overlay);
+                changed = true;
+            }
+            const selected = entry.selected === true || selectedMarkerRowIds.has(entry.markerRowId);
+            const active = entry.active === true || input.activeMarkerRowId === entry.markerRowId;
+            const color = readMarkerOverlayColor(entry.marker);
+            const labelText = createMarkerOverlayLabelText(entry.marker, entry.markerTypeLabel);
+            if (overlay.selected !== selected
+                || overlay.active !== active
+                || !markerOverlayColorsEqual(overlay.color, color)
+                || overlay.labelText !== labelText)
+                changed = true;
+            overlay.selected = selected;
+            overlay.active = active;
+            overlay.color = color;
+            overlay.labelText = labelText;
+            applyMarkerGeometryToOverlay(options, overlay, entry.marker);
+            applyMarkerVisualState(options, overlay);
+            applyMarkerLabelVisualState(options, overlay);
+            changed = true;
+        }
+        for (const markerRowId of [...overlays.keys()]) {
+            if (!nextRowIds.has(markerRowId))
+                changed = disposeOverlay(markerRowId) || changed;
+        }
+        changed = syncRelationOverlays(input.relations ?? []) || changed;
+        return changed;
+    }
+    function getAttachableRoot(markerRowId) {
+        if (disposed)
+            return null;
+        return overlays.get(markerRowId)?.root ?? null;
+    }
+    function readMarkerTransform(markerRowId) {
+        if (disposed)
+            return null;
+        return readRootTransform(overlays.get(markerRowId)?.root ?? null);
+    }
+    function readMarkerTransforms(markerRowIds) {
+        const transforms = {};
+        for (const markerRowId of markerRowIds) {
+            const transform = readMarkerTransform(markerRowId);
+            if (transform)
+                transforms[markerRowId] = transform;
+        }
+        return transforms;
+    }
+    function setMarkerTransformPreview(markerRowId, transform) {
+        if (disposed)
+            return false;
+        const overlay = overlays.get(markerRowId);
+        if (!overlay)
+            return false;
+        if (!isEditorTransformTrsSnapshot(transform))
+            return false;
+        applyTransformToOverlay(options, overlay, transform);
+        return true;
+    }
+    function setMarkerTransformsPreview(transforms) {
+        const applied = [];
+        for (const [markerRowId, transform] of Object.entries(transforms)) {
+            if (setMarkerTransformPreview(markerRowId, transform))
+                applied.push(markerRowId);
+        }
+        return applied;
+    }
+    function getSelectionPivot(markerRowIds) {
+        const transforms = Object.values(readMarkerTransforms(markerRowIds));
+        if (transforms.length === 0)
+            return null;
+        return {
+            mode: 'selection-center',
+            position: averagePositions(transforms),
+        };
+    }
+    function getSelectionBounds(markerRowIds) {
+        const transforms = Object.values(readMarkerTransforms(markerRowIds));
+        if (transforms.length === 0)
+            return null;
+        return combineTransformBounds(transforms);
+    }
+    function resolvePickSelectionNodeId(target) {
+        if (disposed)
+            return null;
+        let current = target;
+        while (current) {
+            const markerRowId = current.metadata?.editorMarkerRowId;
+            if (typeof markerRowId === 'string' && overlays.has(markerRowId))
+                return markerRowId;
+            current = current.parent ?? null;
+        }
+        return null;
+    }
+    function pickMarkerRowIdAt(clientX, clientY) {
+        if (disposed)
+            return null;
+        const scene = options.scene;
+        const canvas = scene.getEngine?.().getRenderingCanvas?.() ?? null;
+        if (!canvas || typeof scene.pick !== 'function')
+            return null;
+        const rect = typeof canvas.getBoundingClientRect === 'function'
+            ? canvas.getBoundingClientRect()
+            : { left: 0, top: 0 };
+        const pickResult = scene.pick(clientX - (rect.left ?? 0), clientY - (rect.top ?? 0), (mesh) => resolvePickSelectionNodeId(mesh) != null);
+        return resolvePickSelectionNodeId(pickResult?.pickedMesh ?? null);
+    }
+    return {
+        sync,
+        getAttachableRoot,
+        readMarkerTransform,
+        readMarkerTransforms,
+        setMarkerTransformPreview,
+        setMarkerTransformsPreview,
+        getSelectionPivot,
+        getSelectionBounds,
+        resolvePickSelectionNodeId,
+        pickMarkerRowIdAt,
+        dispose() {
+            if (disposed)
+                return;
+            for (const markerRowId of [...overlays.keys()])
+                disposeOverlay(markerRowId);
+            for (const relationId of [...relationOverlays.keys()])
+                disposeRelationOverlay(relationId);
+            removeRelationAnimationObserver();
+            disposed = true;
+        },
+    };
+    function syncRelationOverlays(relations) {
+        let changed = false;
+        const nextRelationIds = new Set();
+        for (const entry of relations) {
+            if (!entry.id)
+                continue;
+            nextRelationIds.add(entry.id);
+            let overlay = relationOverlays.get(entry.id) ?? null;
+            if (!overlay) {
+                overlay = createActiveMarkerRelationOverlay(options, entry);
+                if (!overlay)
+                    continue;
+                relationOverlays.set(entry.id, overlay);
+                changed = true;
+            }
+            const color = entry.color ?? createMarkerRelationOverlayColor(entry.type);
+            const directed = entry.directed !== false;
+            const active = entry.active === true;
+            if (!markerOverlayColorsEqual(overlay.color, color)
+                || overlay.directed !== directed
+                || overlay.active !== active)
+                changed = true;
+            overlay.color = color;
+            overlay.directed = directed;
+            overlay.active = active;
+            applyMarkerRelationOverlayState(options, overlay, entry);
+            changed = true;
+        }
+        for (const relationId of [...relationOverlays.keys()]) {
+            if (!nextRelationIds.has(relationId))
+                changed = disposeRelationOverlay(relationId) || changed;
+        }
+        syncRelationAnimationObserver();
+        return changed;
+    }
+    function syncRelationAnimationObserver() {
+        if (disposed)
+            return;
+        const shouldAnimate = [...relationOverlays.values()].some(overlay => overlay.active);
+        const observable = options.scene.onBeforeRenderObservable;
+        if (shouldAnimate && !relationAnimationObserver && typeof observable?.add === 'function') {
+            relationAnimationObserver = observable.add(() => updateActiveRelationAnimations());
+            updateActiveRelationAnimations(0);
+            return;
+        }
+        if (!shouldAnimate)
+            removeRelationAnimationObserver();
+    }
+    function removeRelationAnimationObserver() {
+        if (!relationAnimationObserver)
+            return;
+        try {
+            options.scene.onBeforeRenderObservable?.remove?.(relationAnimationObserver);
+        }
+        catch { }
+        relationAnimationObserver = null;
+    }
+    function updateActiveRelationAnimations(deltaOverrideMs) {
+        const rawDelta = deltaOverrideMs ?? Number(options.scene.getEngine?.()?.getDeltaTime?.() ?? 16.67);
+        const deltaMs = Number.isFinite(rawDelta) ? Math.max(0, Math.min(80, rawDelta)) : 16.67;
+        relationAnimationTimeMs = (relationAnimationTimeMs + deltaMs) % RELATION_ACTIVE_PULSE_PERIOD_MS;
+        for (const overlay of relationOverlays.values()) {
+            if (overlay.active)
+                applyMarkerRelationPulseFrame(options, overlay, relationAnimationTimeMs);
+        }
+    }
+}
+export function createBabylonMarkerOverlayProjectionAdapter(projection, markerOverlay) {
+    return {
+        ...projection,
+        getAttachableRoot(nodeId) {
+            return markerOverlay.getAttachableRoot(nodeId) ?? projection.getAttachableRoot(nodeId);
+        },
+        readNodeTransform(nodeId) {
+            return markerOverlay.readMarkerTransform(nodeId) ?? projection.readNodeTransform(nodeId);
+        },
+        readNodeTransforms(nodeIds) {
+            return {
+                ...projection.readNodeTransforms(nodeIds),
+                ...markerOverlay.readMarkerTransforms(nodeIds),
+            };
+        },
+        setNodeTransformPreview(nodeId, transform) {
+            if (markerOverlay.setMarkerTransformPreview(nodeId, transform))
+                return;
+            projection.setNodeTransformPreview(nodeId, transform);
+        },
+        setNodeTransformsPreview(transforms) {
+            const markerIds = new Set(markerOverlay.setMarkerTransformsPreview(transforms));
+            const projectionTransforms = {};
+            for (const [nodeId, transform] of Object.entries(transforms)) {
+                if (!markerIds.has(nodeId))
+                    projectionTransforms[nodeId] = transform;
+            }
+            projection.setNodeTransformsPreview(projectionTransforms);
+        },
+        syncNodeMetadata(node) {
+            projection.syncNodeMetadata(node);
+        },
+        getSelectionPivot(nodeIds) {
+            const markerPivot = markerOverlay.getSelectionPivot(nodeIds);
+            if (!markerPivot)
+                return projection.getSelectionPivot(nodeIds);
+            const transforms = {
+                ...projection.readNodeTransforms(nodeIds),
+                ...markerOverlay.readMarkerTransforms(nodeIds),
+            };
+            const values = Object.values(transforms).filter(isEditorTransformTrsSnapshot);
+            return values.length > 0
+                ? { mode: 'selection-center', position: averagePositions(values) }
+                : markerPivot;
+        },
+        getSelectionBounds(nodeIds) {
+            const markerBounds = markerOverlay.getSelectionBounds(nodeIds);
+            const projectionBounds = projection.getSelectionBounds(nodeIds);
+            return combineBounds(projectionBounds, markerBounds);
+        },
+        resolvePickSelectionNodeId(target) {
+            return markerOverlay.resolvePickSelectionNodeId(target) ?? projection.resolvePickSelectionNodeId(target);
+        },
+        pickNodeIdAt(clientX, clientY) {
+            return markerOverlay.pickMarkerRowIdAt(clientX, clientY) ?? projection.pickNodeIdAt(clientX, clientY);
+        },
+    };
+}
+function createActiveMarkerOverlay(options, markerRowId, markerId, presentation) {
+    const TransformNode = options.babylon.TransformNode;
+    if (!TransformNode)
+        return null;
+    const root = new TransformNode(`editor.markerGraph.${presentation}.${markerId}`, options.scene);
+    root.metadata = {
+        ...(root.metadata ?? {}),
+        editorProjectionHelper: true,
+        editorMarkerOverlay: true,
+        editorMarkerPresentation: presentation,
+        editorMarkerId: markerId,
+        editorMarkerRowId: markerRowId,
+    };
+    root.isPickable = false;
+    const lines = presentation === 'region' || presentation === 'object'
+        ? createBoxLineHelper(options, root, markerId, markerRowId)
+        : null;
+    const frameHelper = createMarkerFrameHelper(options, markerId, markerRowId);
+    const { pickMesh, pickMaterial } = presentation === 'region' || presentation === 'object'
+        ? createBoxPickHelper(options, root, markerId, markerRowId)
+        : createPointPickHelper(options, root, markerId, markerRowId, presentation);
+    const { labelRoot, labelPlane, labelMaterial, labelTexture } = createMarkerLabelHelper(options, markerId, markerRowId);
+    return {
+        markerRowId,
+        markerId,
+        presentation,
+        root,
+        lines,
+        ...frameHelper,
+        pickMesh,
+        pickMaterial,
+        labelRoot,
+        labelPlane,
+        labelMaterial,
+        labelTexture,
+        labelText: '',
+        selected: false,
+        active: false,
+        color: createMarkerOverlayColor(0.1, 0.85, 1),
+    };
+}
+function disposeActiveMarkerOverlay(overlay) {
+    try {
+        overlay.lines?.dispose?.();
+    }
+    catch { }
+    try {
+        overlay.anchorMesh?.dispose?.();
+    }
+    catch { }
+    try {
+        overlay.forwardShaft?.dispose?.();
+    }
+    catch { }
+    try {
+        overlay.forwardHead?.dispose?.();
+    }
+    catch { }
+    try {
+        overlay.frameLines?.dispose?.();
+    }
+    catch { }
+    try {
+        overlay.frameMaterial?.dispose?.();
+    }
+    catch { }
+    try {
+        overlay.frameRoot?.dispose?.();
+    }
+    catch { }
+    try {
+        overlay.pickMesh?.dispose?.();
+    }
+    catch { }
+    try {
+        overlay.pickMaterial?.dispose?.();
+    }
+    catch { }
+    try {
+        overlay.labelPlane?.dispose?.();
+    }
+    catch { }
+    try {
+        overlay.labelTexture?.dispose?.();
+    }
+    catch { }
+    try {
+        overlay.labelMaterial?.dispose?.();
+    }
+    catch { }
+    try {
+        overlay.labelRoot?.dispose?.();
+    }
+    catch { }
+    try {
+        overlay.root?.dispose?.();
+    }
+    catch { }
+}
+function createActiveMarkerRelationOverlay(options, entry) {
+    const TransformNode = options.babylon.TransformNode;
+    const MeshBuilder = options.babylon.MeshBuilder;
+    const StandardMaterial = options.babylon.StandardMaterial;
+    const Color3 = options.babylon.Color3;
+    if (!TransformNode || !MeshBuilder?.CreateCylinder)
+        return null;
+    const root = new TransformNode(`editor.markerGraph.relation.${entry.id}`, options.scene);
+    root.metadata = createMarkerRelationMetadata(root.metadata, entry);
+    root.isPickable = false;
+    const material = StandardMaterial
+        ? new StandardMaterial(`editor.markerGraph.relation.${entry.id}.material`, options.scene)
+        : null;
+    if (material) {
+        material.backFaceCulling = false;
+        material.disableLighting = true;
+        material.disableDepthWrite = true;
+        material.alpha = 0.96;
+        material.zOffset = -3;
+    }
+    if (Color3 && material) {
+        const color = entry.color ?? createMarkerRelationOverlayColor(entry.type);
+        material.diffuseColor = new Color3(color.r, color.g, color.b);
+        material.emissiveColor = new Color3(color.r, color.g, color.b);
+    }
+    const arrowHead = MeshBuilder.CreateCylinder
+        ? MeshBuilder.CreateCylinder(`editor.markerGraph.relation.${entry.id}.arrow`, { height: 1, diameterTop: 0, diameterBottom: 1, tessellation: 24 }, options.scene)
+        : null;
+    if (arrowHead) {
+        arrowHead.parent = root;
+        arrowHead.isPickable = false;
+        arrowHead.metadata = createMarkerRelationMetadata(arrowHead.metadata, entry, {
+            editorMarkerRelationArrow: true,
+        });
+        arrowHead.renderingGroupId = 2;
+        arrowHead.material = material;
+    }
+    return {
+        id: entry.id,
+        root,
+        dashMeshes: [],
+        dashGeometryKey: '',
+        arrowHead,
+        material,
+        color: entry.color ?? createMarkerRelationOverlayColor(entry.type),
+        directed: entry.directed !== false,
+        active: entry.active === true,
+    };
+}
+function disposeActiveMarkerRelationOverlay(overlay) {
+    disposeMarkerRelationDashMeshes(overlay);
+    try {
+        overlay.arrowHead?.dispose?.();
+    }
+    catch { }
+    try {
+        overlay.material?.dispose?.();
+    }
+    catch { }
+    try {
+        overlay.root?.dispose?.();
+    }
+    catch { }
+}
+function createMarkerRelationMetadata(metadata, entry, extras) {
+    return {
+        ...(metadata ?? {}),
+        editorProjectionHelper: true,
+        editorMarkerOverlay: true,
+        editorMarkerRelationOverlay: true,
+        editorMarkerRelationId: entry.id,
+        editorMarkerRelationType: entry.type,
+        ...(extras ?? {}),
+    };
+}
+function createMarkerFrameHelper(options, markerId, markerRowId) {
+    const TransformNode = options.babylon.TransformNode;
+    const MeshBuilder = options.babylon.MeshBuilder;
+    const StandardMaterial = options.babylon.StandardMaterial;
+    const Color3 = options.babylon.Color3;
+    const Vector3 = options.babylon.Vector3;
+    if (!TransformNode || !Vector3) {
+        return {
+            frameRoot: null,
+            frameLines: null,
+            anchorMesh: null,
+            forwardShaft: null,
+            forwardHead: null,
+            frameMaterial: null,
+        };
+    }
+    const frameRoot = new TransformNode(`editor.markerGraph.box.${markerId}.frameRoot`, options.scene);
+    frameRoot.metadata = createMarkerFrameMetadata(frameRoot.metadata, markerId, markerRowId);
+    frameRoot.isPickable = false;
+    let frameMaterial = null;
+    if (StandardMaterial) {
+        frameMaterial = new StandardMaterial(`editor.markerGraph.box.${markerId}.frameMaterial`, options.scene);
+        if (Color3) {
+            frameMaterial.diffuseColor = new Color3(1, 0.9, 0.08);
+            frameMaterial.emissiveColor = new Color3(1, 0.72, 0.05);
+        }
+        frameMaterial.alpha = 0.98;
+        frameMaterial.backFaceCulling = false;
+        frameMaterial.disableLighting = true;
+        frameMaterial.disableDepthWrite = true;
+        frameMaterial.zOffset = -2;
+    }
+    const anchorMesh = MeshBuilder?.CreateSphere
+        ? MeshBuilder.CreateSphere(`editor.markerGraph.box.${markerId}.anchor`, { diameter: 1, segments: 16 }, options.scene)
+        : null;
+    if (anchorMesh)
+        configureMarkerFrameMesh(anchorMesh, frameRoot, frameMaterial, markerId, markerRowId);
+    const forwardShaft = MeshBuilder?.CreateCylinder
+        ? MeshBuilder.CreateCylinder(`editor.markerGraph.box.${markerId}.forwardShaft`, { height: 1, diameter: 1, tessellation: 16 }, options.scene)
+        : null;
+    if (forwardShaft) {
+        configureMarkerFrameMesh(forwardShaft, frameRoot, frameMaterial, markerId, markerRowId);
+        forwardShaft.rotation = new Vector3(Math.PI / 2, 0, 0);
+    }
+    const forwardHead = MeshBuilder?.CreateCylinder
+        ? MeshBuilder.CreateCylinder(`editor.markerGraph.box.${markerId}.forwardHead`, { height: 1, diameterTop: 0, diameterBottom: 1, tessellation: 24 }, options.scene)
+        : null;
+    if (forwardHead) {
+        configureMarkerFrameMesh(forwardHead, frameRoot, frameMaterial, markerId, markerRowId);
+        forwardHead.rotation = new Vector3(Math.PI / 2, 0, 0);
+    }
+    const frameLines = !anchorMesh && !forwardShaft && !forwardHead && MeshBuilder?.CreateLineSystem
+        ? MeshBuilder.CreateLineSystem(`editor.markerGraph.box.${markerId}.frame`, {
+            lines: MARKER_FRAME_LINES.map(line => line.map(point => new Vector3(point.x, point.y, point.z))),
+            updatable: false,
+        }, options.scene)
+        : null;
+    if (frameLines) {
+        frameLines.parent = frameRoot;
+        frameLines.isPickable = true;
+        frameLines.metadata = createMarkerFrameMetadata(frameLines.metadata, markerId, markerRowId);
+        frameLines.renderingGroupId = 2;
+        if (Color3)
+            frameLines.color = new Color3(1, 0.9, 0.08);
+    }
+    return {
+        frameRoot,
+        frameLines,
+        anchorMesh,
+        forwardShaft,
+        forwardHead,
+        frameMaterial,
+    };
+}
+function configureMarkerFrameMesh(mesh, frameRoot, material, markerId, markerRowId) {
+    mesh.parent = frameRoot;
+    mesh.isPickable = true;
+    mesh.material = material;
+    mesh.metadata = createMarkerFrameMetadata(mesh.metadata, markerId, markerRowId);
+    mesh.renderingGroupId = 2;
+}
+function createMarkerFrameMetadata(metadata, markerId, markerRowId) {
+    return {
+        ...(metadata ?? {}),
+        editorProjectionHelper: true,
+        editorMarkerOverlay: true,
+        editorMarkerFrame: true,
+        editorMarkerId: markerId,
+        editorMarkerRowId: markerRowId,
+    };
+}
+function createBoxLineHelper(options, root, markerId, markerRowId) {
+    const MeshBuilder = options.babylon.MeshBuilder;
+    const Color3 = options.babylon.Color3;
+    const Vector3 = options.babylon.Vector3;
+    if (!MeshBuilder?.CreateLineSystem || !Vector3)
+        return null;
+    const lines = MeshBuilder.CreateLineSystem(`editor.markerGraph.box.${markerId}.lines`, {
+        lines: UNIT_BOX_LINES.map(line => line.map(point => new Vector3(point.x, point.y, point.z))),
+        updatable: false,
+    }, options.scene);
+    lines.parent = root;
+    lines.isPickable = true;
+    lines.metadata = {
+        ...(lines.metadata ?? {}),
+        editorProjectionHelper: true,
+        editorMarkerOverlay: true,
+        editorMarkerId: markerId,
+        editorMarkerRowId: markerRowId,
+    };
+    if (Color3)
+        lines.color = new Color3(0.1, 0.85, 1);
+    return lines;
+}
+function createBoxPickHelper(options, root, markerId, markerRowId) {
+    const MeshBuilder = options.babylon.MeshBuilder;
+    const StandardMaterial = options.babylon.StandardMaterial;
+    const Color3 = options.babylon.Color3;
+    if (!MeshBuilder?.CreateBox)
+        return { pickMesh: null, pickMaterial: null };
+    const pickMesh = MeshBuilder.CreateBox(`editor.markerGraph.box.${markerId}.pick`, { size: 1 }, options.scene);
+    pickMesh.parent = root;
+    pickMesh.isPickable = true;
+    pickMesh.metadata = {
+        ...(pickMesh.metadata ?? {}),
+        editorProjectionHelper: true,
+        editorMarkerOverlay: true,
+        editorMarkerOverlayPickTarget: true,
+        editorMarkerId: markerId,
+        editorMarkerRowId: markerRowId,
+    };
+    let pickMaterial = null;
+    if (StandardMaterial) {
+        pickMaterial = new StandardMaterial(`editor.markerGraph.box.${markerId}.material`, options.scene);
+        if (Color3) {
+            pickMaterial.diffuseColor = new Color3(0.1, 0.85, 1);
+            pickMaterial.emissiveColor = new Color3(0.02, 0.18, 0.22);
+        }
+        pickMaterial.alpha = 0.065;
+        pickMaterial.backFaceCulling = false;
+        pickMesh.material = pickMaterial;
+    }
+    else {
+        pickMesh.visibility = 0.065;
+    }
+    return { pickMesh, pickMaterial };
+}
+function createPointPickHelper(options, root, markerId, markerRowId, presentation) {
+    const MeshBuilder = options.babylon.MeshBuilder;
+    const StandardMaterial = options.babylon.StandardMaterial;
+    const Color3 = options.babylon.Color3;
+    if (!MeshBuilder?.CreateSphere)
+        return { pickMesh: null, pickMaterial: null };
+    const diameter = presentation === 'anchor' ? 0.82 : presentation === 'object' ? 0.72 : 0.62;
+    const pickMesh = MeshBuilder.CreateSphere(`editor.markerGraph.${presentation}.${markerId}.pick`, { diameter, segments: 24 }, options.scene);
+    pickMesh.parent = root;
+    pickMesh.isPickable = true;
+    pickMesh.metadata = {
+        ...(pickMesh.metadata ?? {}),
+        editorProjectionHelper: true,
+        editorMarkerOverlay: true,
+        editorMarkerOverlayPickTarget: true,
+        editorMarkerPresentation: presentation,
+        editorMarkerId: markerId,
+        editorMarkerRowId: markerRowId,
+    };
+    let pickMaterial = null;
+    if (StandardMaterial) {
+        pickMaterial = new StandardMaterial(`editor.markerGraph.${presentation}.${markerId}.material`, options.scene);
+        if (Color3) {
+            pickMaterial.diffuseColor = new Color3(0.1, 0.85, 1);
+            pickMaterial.emissiveColor = new Color3(0.04, 0.35, 0.42);
+        }
+        pickMaterial.alpha = 0.38;
+        pickMaterial.backFaceCulling = false;
+        pickMaterial.disableLighting = true;
+        pickMesh.material = pickMaterial;
+    }
+    else {
+        pickMesh.visibility = 0.38;
+    }
+    return { pickMesh, pickMaterial };
+}
+function createMarkerLabelHelper(options, markerId, markerRowId) {
+    const TransformNode = options.babylon.TransformNode;
+    const MeshBuilder = options.babylon.MeshBuilder;
+    const StandardMaterial = options.babylon.StandardMaterial;
+    const DynamicTexture = options.babylon.DynamicTexture;
+    const Color3 = options.babylon.Color3;
+    const Mesh = options.babylon.Mesh;
+    if (!TransformNode)
+        return { labelRoot: null, labelPlane: null, labelMaterial: null, labelTexture: null };
+    const labelRoot = new TransformNode(`editor.markerGraph.box.${markerId}.labelRoot`, options.scene);
+    labelRoot.metadata = {
+        ...(labelRoot.metadata ?? {}),
+        editorProjectionHelper: true,
+        editorMarkerOverlay: true,
+        editorMarkerLabel: true,
+        editorMarkerId: markerId,
+        editorMarkerRowId: markerRowId,
+    };
+    labelRoot.isPickable = false;
+    if (!MeshBuilder?.CreatePlane)
+        return { labelRoot, labelPlane: null, labelMaterial: null, labelTexture: null };
+    const labelPlane = MeshBuilder.CreatePlane(`editor.markerGraph.box.${markerId}.label`, { size: 1 }, options.scene);
+    labelPlane.parent = labelRoot;
+    labelPlane.isPickable = false;
+    labelPlane.billboardMode = Mesh?.BILLBOARDMODE_ALL ?? 7;
+    labelPlane.metadata = {
+        ...(labelPlane.metadata ?? {}),
+        editorProjectionHelper: true,
+        editorMarkerOverlay: true,
+        editorMarkerLabel: true,
+        editorMarkerId: markerId,
+        editorMarkerRowId: markerRowId,
+    };
+    let labelTexture = null;
+    let labelMaterial = null;
+    if (DynamicTexture) {
+        labelTexture = new DynamicTexture(`editor.markerGraph.box.${markerId}.labelTexture`, { width: 512, height: 192 }, options.scene, false);
+        labelTexture.hasAlpha = true;
+    }
+    if (StandardMaterial) {
+        labelMaterial = new StandardMaterial(`editor.markerGraph.box.${markerId}.labelMaterial`, options.scene);
+        if (Color3) {
+            labelMaterial.emissiveColor = new Color3(1, 1, 1);
+            labelMaterial.diffuseColor = new Color3(1, 1, 1);
+        }
+        labelMaterial.backFaceCulling = false;
+        labelMaterial.disableLighting = true;
+        labelMaterial.alpha = 0.94;
+        if (labelTexture) {
+            labelMaterial.diffuseTexture = labelTexture;
+            labelMaterial.emissiveTexture = labelTexture;
+            labelMaterial.useAlphaFromDiffuseTexture = true;
+        }
+        labelPlane.material = labelMaterial;
+    }
+    return { labelRoot, labelPlane, labelMaterial, labelTexture };
+}
+function applyMarkerVisualState(options, overlay) {
+    const Color3 = options.babylon.Color3;
+    const selected = overlay.selected || overlay.active;
+    if (Color3 && overlay.lines) {
+        const lineColor = selected ? brightenMarkerOverlayColor(overlay.color, 0.28) : overlay.color;
+        overlay.lines.color = new Color3(lineColor.r, lineColor.g, lineColor.b);
+    }
+    if (Color3 && overlay.frameLines) {
+        const frameColor = selected ? createMarkerOverlayColor(1, 0.96, 0.22) : createMarkerOverlayColor(1, 0.78, 0.08);
+        overlay.frameLines.color = new Color3(frameColor.r, frameColor.g, frameColor.b);
+    }
+    if (Color3 && overlay.frameMaterial) {
+        const frameColor = selected ? createMarkerOverlayColor(1, 0.96, 0.22) : createMarkerOverlayColor(1, 0.78, 0.08);
+        overlay.frameMaterial.diffuseColor = new Color3(frameColor.r, frameColor.g, frameColor.b);
+        overlay.frameMaterial.emissiveColor = new Color3(frameColor.r, Math.max(0.45, frameColor.g * 0.82), 0.04);
+        overlay.frameMaterial.alpha = selected ? 1 : 0.96;
+    }
+    const alpha = overlay.presentation === 'region'
+        ? (overlay.active ? 0.18 : overlay.selected ? 0.13 : 0.065)
+        : overlay.presentation === 'object'
+            ? (overlay.active ? 0.16 : overlay.selected ? 0.1 : 0.055)
+            : (overlay.active ? 0.84 : overlay.selected ? 0.68 : 0.46);
+    if (overlay.pickMaterial) {
+        overlay.pickMaterial.alpha = alpha;
+        if (Color3) {
+            const fillColor = selected ? brightenMarkerOverlayColor(overlay.color, 0.18) : overlay.color;
+            overlay.pickMaterial.diffuseColor = new Color3(fillColor.r, fillColor.g, fillColor.b);
+            overlay.pickMaterial.emissiveColor = new Color3(Math.min(0.28, fillColor.r * 0.18), Math.min(0.28, fillColor.g * 0.18), Math.min(0.28, fillColor.b * 0.18));
+        }
+    }
+    else if (overlay.pickMesh) {
+        overlay.pickMesh.visibility = alpha;
+    }
+}
+function applyMarkerRelationOverlayState(options, overlay, entry) {
+    const Color3 = options.babylon.Color3;
+    const active = entry.active === true;
+    const visualColor = active ? createMarkerOverlayColor(1, 0.86, 0.1) : overlay.color;
+    if (Color3 && overlay.material) {
+        overlay.material.diffuseColor = new Color3(visualColor.r, visualColor.g, visualColor.b);
+        overlay.material.emissiveColor = new Color3(visualColor.r, visualColor.g, visualColor.b);
+        overlay.material.alpha = active ? 1 : 0.96;
+        overlay.material.zOffset = active ? -5 : -3;
+    }
+    const directed = entry.directed !== false;
+    updateMarkerRelationDashes(options, overlay, entry, directed, active);
+    updateMarkerRelationArrow(options, overlay, entry.from, entry.to, directed, active);
+    if (active)
+        applyMarkerRelationPulseFrame(options, overlay, 0);
+    else
+        resetMarkerRelationPulseState(options, overlay);
+}
+function applyMarkerRelationPulseFrame(options, overlay, timeMs) {
+    const Color3 = options.babylon.Color3;
+    const Vector3 = options.babylon.Vector3;
+    const phase = (timeMs % RELATION_ACTIVE_PULSE_PERIOD_MS) / RELATION_ACTIVE_PULSE_PERIOD_MS;
+    const pulse = 0.5 + 0.5 * Math.sin(phase * Math.PI * 2);
+    const color = brightenMarkerOverlayColor(createMarkerOverlayColor(1, 0.86, 0.08), 0.38 * pulse);
+    if (Color3 && overlay.material) {
+        overlay.material.diffuseColor = new Color3(color.r, color.g, color.b);
+        overlay.material.emissiveColor = new Color3(color.r, color.g, color.b);
+        overlay.material.alpha = 0.72 + 0.28 * pulse;
+        overlay.material.zOffset = -6;
+    }
+    if (Vector3) {
+        const pulseScale = 1.0 + 0.55 * pulse;
+        for (const dash of overlay.dashMeshes) {
+            dash.scaling = new Vector3(pulseScale, 1, pulseScale);
+        }
+    }
+}
+function resetMarkerRelationPulseState(options, overlay) {
+    const Vector3 = options.babylon.Vector3;
+    if (!Vector3)
+        return;
+    for (const dash of overlay.dashMeshes) {
+        dash.scaling = new Vector3(1, 1, 1);
+    }
+}
+function updateMarkerRelationDashes(options, overlay, entry, directed, active) {
+    const MeshBuilder = options.babylon.MeshBuilder;
+    const Vector3 = options.babylon.Vector3;
+    if (!MeshBuilder?.CreateCylinder || !Vector3)
+        return;
+    const nextDashGeometryKey = createMarkerRelationDashGeometryKey(entry.from, entry.to, directed, active);
+    if (overlay.dashGeometryKey === nextDashGeometryKey)
+        return;
+    overlay.dashGeometryKey = nextDashGeometryKey;
+    disposeMarkerRelationDashMeshes(overlay);
+    const direction = subtractVec3(entry.to, entry.from);
+    const length = vec3Length(direction);
+    if (length < 0.000001)
+        return;
+    const unit = scaleVec3(direction, 1 / length);
+    const arrowClearance = directed ? Math.max(0.28, Math.min(0.56, length * 0.14)) : 0;
+    const usableLength = Math.max(0, length - arrowClearance);
+    if (usableLength < RELATION_DASH_MIN_SEGMENT_LENGTH)
+        return;
+    const dashLength = Math.max(0.3, Math.min(0.74, length * 0.12));
+    const gapLength = Math.max(0.18, Math.min(0.44, dashLength * 0.62));
+    const baseDashDiameter = Math.max(0.0375, Math.min(0.065, length * 0.009));
+    const dashDiameter = active ? baseDashDiameter * 2.6 : baseDashDiameter;
+    let cursor = 0;
+    let dashIndex = 0;
+    while (cursor < usableLength && dashIndex < RELATION_DASH_MAX_COUNT) {
+        const dashEnd = Math.min(cursor + dashLength, usableLength);
+        const segmentLength = dashEnd - cursor;
+        if (segmentLength >= RELATION_DASH_MIN_SEGMENT_LENGTH) {
+            const segmentCenterDistance = cursor + segmentLength / 2;
+            const center = addVec3(entry.from, scaleVec3(unit, segmentCenterDistance));
+            const dash = MeshBuilder.CreateCylinder(`editor.markerGraph.relation.${entry.id}.dash.${dashIndex}`, {
+                height: segmentLength,
+                diameter: dashDiameter,
+                tessellation: 12,
+            }, options.scene);
+            if (dash) {
+                dash.parent = overlay.root;
+                dash.isPickable = false;
+                dash.metadata = createMarkerRelationMetadata(dash.metadata, entry, {
+                    editorMarkerRelationDash: true,
+                    editorMarkerRelationDashIndex: dashIndex,
+                });
+                dash.renderingGroupId = 2;
+                dash.material = overlay.material;
+                dash.position = new Vector3(center.x, center.y, center.z);
+                dash.rotationQuaternion = null;
+                dash.rotation = createCylinderRotationTowardDirection(options, unit);
+                overlay.dashMeshes.push(dash);
+            }
+        }
+        cursor += dashLength + gapLength;
+        dashIndex += 1;
+    }
+}
+function disposeMarkerRelationDashMeshes(overlay) {
+    for (const dash of overlay.dashMeshes) {
+        try {
+            dash?.dispose?.();
+        }
+        catch { }
+    }
+    overlay.dashMeshes = [];
+}
+function createMarkerRelationDashGeometryKey(from, to, directed, active) {
+    return [
+        from.x,
+        from.y,
+        from.z,
+        to.x,
+        to.y,
+        to.z,
+    ].map(value => value.toFixed(4)).join(':') + `:${directed ? 1 : 0}:${active ? 1 : 0}`;
+}
+function updateMarkerRelationArrow(options, overlay, from, to, directed, active) {
+    const Vector3 = options.babylon.Vector3;
+    if (!overlay.arrowHead || !Vector3)
+        return;
+    overlay.arrowHead.setEnabled?.(directed);
+    overlay.arrowHead.isVisible = directed;
+    if (!directed)
+        return;
+    const direction = subtractVec3(to, from);
+    const length = vec3Length(direction);
+    if (length < 0.000001) {
+        overlay.arrowHead.isVisible = false;
+        return;
+    }
+    const unit = scaleVec3(direction, 1 / length);
+    const arrowLength = Math.max(0.18, Math.min(0.42, length * 0.12));
+    const baseArrowDiameter = Math.max(0.12, Math.min(0.28, arrowLength * 0.72));
+    const arrowDiameter = active ? baseArrowDiameter * 1.35 : baseArrowDiameter;
+    const center = addVec3(to, scaleVec3(unit, -arrowLength / 2));
+    overlay.arrowHead.position = new Vector3(center.x, center.y, center.z);
+    overlay.arrowHead.scaling = new Vector3(arrowDiameter, arrowLength, arrowDiameter);
+    overlay.arrowHead.rotationQuaternion = null;
+    overlay.arrowHead.rotation = createCylinderRotationTowardDirection(options, unit);
+}
+function createCylinderRotationTowardDirection(options, direction) {
+    const Vector3 = options.babylon.Vector3;
+    const yaw = Math.atan2(direction.x, direction.z);
+    const horizontal = Math.sqrt(direction.x * direction.x + direction.z * direction.z);
+    const pitch = Math.atan2(direction.y, horizontal);
+    return Vector3 ? new Vector3(Math.PI / 2 - pitch, yaw, 0) : { x: Math.PI / 2 - pitch, y: yaw, z: 0 };
+}
+function applyMarkerLabelTransform(options, overlay, transform) {
+    if (!isEditorTransformTrsSnapshot(transform))
+        return;
+    const Vector3 = options.babylon.Vector3;
+    if (!overlay.labelRoot || !Vector3)
+        return;
+    overlay.labelRoot.position = new Vector3(transform.position.x, transform.position.y + Math.abs(transform.scale.y) / 2 + 0.78, transform.position.z);
+    overlay.labelRoot.rotationQuaternion = null;
+    overlay.labelRoot.rotation = new Vector3(0, 0, 0);
+    overlay.labelRoot.scaling = new Vector3(1, 1, 1);
+}
+function applyMarkerLabelVisualState(options, overlay) {
+    if (!overlay.labelPlane)
+        return;
+    const Vector3 = options.babylon.Vector3;
+    const lines = normalizeMarkerOverlayLabelLines(overlay.labelText);
+    const maxChars = Math.max(...lines.map(line => line.length), 8);
+    const width = Math.max(0.85, Math.min(1.85, 0.045 * maxChars + 0.35)) * MARKER_LABEL_WORLD_SCALE;
+    const height = Math.max(0.3, Math.min(0.54, 0.11 * lines.length + 0.16)) * MARKER_LABEL_WORLD_SCALE;
+    if (Vector3)
+        overlay.labelPlane.scaling = new Vector3(width, height, 1);
+    updateMarkerLabelTexture(options, overlay, lines);
+    if (overlay.labelMaterial)
+        overlay.labelMaterial.alpha = overlay.active || overlay.selected ? 0.98 : 0.86;
+}
+function updateMarkerLabelTexture(_options, overlay, lines) {
+    const texture = overlay.labelTexture;
+    if (!texture)
+        return;
+    const context = texture.getContext?.();
+    if (!context) {
+        texture.drawText?.(lines.join(' / '), 18, 76, 'bold 42px sans-serif', 'rgba(255, 255, 255, 0.94)', 'rgba(12, 18, 24, 0.86)', true);
+        return;
+    }
+    const width = 512;
+    const height = 192;
+    context.save?.();
+    context.clearRect?.(0, 0, width, height);
+    context.fillStyle = 'rgba(12, 18, 24, 0.78)';
+    context.fillRect?.(0, 0, width, height);
+    context.fillStyle = markerOverlayColorToCss(overlay.color);
+    context.fillRect?.(0, 0, 10, height);
+    context.fillStyle = 'rgba(255, 255, 255, 0.94)';
+    context.font = '700 42px system-ui, -apple-system, BlinkMacSystemFont, sans-serif';
+    context.textBaseline = 'top';
+    context.fillText?.(truncateMarkerLabelLine(lines[0] ?? '', 26), 28, 22);
+    context.font = '600 30px system-ui, -apple-system, BlinkMacSystemFont, sans-serif';
+    context.fillStyle = 'rgba(225, 235, 245, 0.86)';
+    if (lines[1])
+        context.fillText?.(truncateMarkerLabelLine(lines[1], 34), 28, 78);
+    if (lines[2])
+        context.fillText?.(truncateMarkerLabelLine(lines[2], 40), 28, 120);
+    context.restore?.();
+    texture.update?.();
+}
+function createMarkerOverlayLabelText(marker, markerTypeLabel) {
+    const tags = marker.tags?.filter(tag => !!tag.trim()).join(', ') ?? '';
+    return [
+        marker.label,
+        `Type: ${markerTypeLabel || marker.markerType}`,
+        tags ? `Tags: ${tags}` : '',
+    ].filter(Boolean).join('\n');
+}
+function normalizeMarkerOverlayLabelLines(text) {
+    const lines = text.split('\n').map(line => line.trim()).filter(Boolean);
+    return lines.length > 0 ? lines.slice(0, 3) : ['Marker'];
+}
+function truncateMarkerLabelLine(line, maxLength) {
+    return line.length > maxLength ? `${line.slice(0, Math.max(0, maxLength - 1))}...` : line;
+}
+function markerOverlayColorToCss(color) {
+    const r = Math.round(Math.min(1, Math.max(0, color.r)) * 255);
+    const g = Math.round(Math.min(1, Math.max(0, color.g)) * 255);
+    const b = Math.round(Math.min(1, Math.max(0, color.b)) * 255);
+    return `rgb(${r}, ${g}, ${b})`;
+}
+function readMarkerOverlayColor(marker) {
+    const raw = marker.metadata?.color;
+    if (!raw || typeof raw !== 'object')
+        return createMarkerOverlayColor(0.1, 0.85, 1);
+    const candidate = raw;
+    const r = readMarkerOverlayColorChannel(candidate.r);
+    const g = readMarkerOverlayColorChannel(candidate.g);
+    const b = readMarkerOverlayColorChannel(candidate.b);
+    return r == null || g == null || b == null
+        ? createMarkerOverlayColor(0.1, 0.85, 1)
+        : createMarkerOverlayColor(r, g, b);
+}
+function readMarkerOverlayColorChannel(value) {
+    const channel = Number(value);
+    if (!Number.isFinite(channel))
+        return null;
+    return Math.min(1, Math.max(0, channel));
+}
+function createMarkerOverlayColor(r, g, b) {
+    return { r, g, b };
+}
+function createMarkerRelationOverlayColor(type) {
+    let hash = 2166136261;
+    for (const char of type) {
+        hash ^= char.charCodeAt(0);
+        hash = Math.imul(hash, 16777619);
+    }
+    const hue = Math.abs(hash % 360);
+    return hslToMarkerOverlayColor(hue / 360, 0.72, 0.58);
+}
+function hslToMarkerOverlayColor(h, s, l) {
+    const hueToRgb = (p, q, tInput) => {
+        let t = tInput;
+        if (t < 0)
+            t += 1;
+        if (t > 1)
+            t -= 1;
+        if (t < 1 / 6)
+            return p + (q - p) * 6 * t;
+        if (t < 1 / 2)
+            return q;
+        if (t < 2 / 3)
+            return p + (q - p) * (2 / 3 - t) * 6;
+        return p;
+    };
+    const q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+    const p = 2 * l - q;
+    return {
+        r: hueToRgb(p, q, h + 1 / 3),
+        g: hueToRgb(p, q, h),
+        b: hueToRgb(p, q, h - 1 / 3),
+    };
+}
+function brightenMarkerOverlayColor(color, amount) {
+    return {
+        r: color.r + (1 - color.r) * amount,
+        g: color.g + (1 - color.g) * amount,
+        b: color.b + (1 - color.b) * amount,
+    };
+}
+function markerOverlayColorsEqual(left, right) {
+    return Math.abs(left.r - right.r) < 0.000001
+        && Math.abs(left.g - right.g) < 0.000001
+        && Math.abs(left.b - right.b) < 0.000001;
+}
+function resolveMarkerOverlayPresentation(marker) {
+    const kind = marker.kind?.trim().toLowerCase();
+    if (kind === 'region')
+        return 'region';
+    if (kind === 'anchor')
+        return 'anchor';
+    if (isObjectBoundMarkerPresentation(kind, marker.geometry.kind))
+        return 'object';
+    if (marker.geometry.kind === 'box' && !kind)
+        return 'region';
+    return 'point';
+}
+function isObjectBoundMarkerPresentation(kind, geometryKind) {
+    return kind === 'object'
+        || kind === 'object-bound'
+        || kind === 'object-bounds'
+        || geometryKind === 'object-bounds';
+}
+function applyMarkerGeometryToOverlay(options, overlay, marker) {
+    applyTransformToOverlay(options, overlay, createMarkerOverlayTransform(marker, overlay.presentation));
+}
+function applyBoxGeometryToOverlay(options, overlay, geometry) {
+    applyTransformToOverlay(options, overlay, {
+        position: geometry.center,
+        rotation: geometry.rotation ?? { x: 0, y: 0, z: 0 },
+        scale: geometry.size,
+    });
+}
+function createMarkerOverlayTransform(marker, presentation) {
+    const origin = getMarkerOverlayOrigin(marker.geometry, marker, presentation);
+    return {
+        position: origin,
+        rotation: getMarkerOverlayRotation(marker),
+        scale: getMarkerOverlayScale(marker, presentation),
+    };
+}
+function getMarkerOverlayOrigin(geometry, marker, presentation) {
+    if (presentation === 'object') {
+        if (marker.spatial?.bounds?.center)
+            return { ...marker.spatial.bounds.center };
+        if (marker.spatial?.origin)
+            return { ...marker.spatial.origin };
+    }
+    switch (geometry.kind) {
+        case 'box':
+            return { ...geometry.center };
+        case 'point':
+            if (geometry.coordinateSpace === 'world')
+                return { ...geometry.position };
+            return marker.semanticFrame?.origin
+                ? { ...marker.semanticFrame.origin }
+                : marker.spatial?.origin
+                    ? { ...marker.spatial.origin }
+                    : { ...geometry.position };
+        case 'object-bounds':
+            if (marker.spatial?.bounds?.center)
+                return { ...marker.spatial.bounds.center };
+            if (marker.spatial?.origin)
+                return { ...marker.spatial.origin };
+            if (marker.semanticFrame?.origin)
+                return { ...marker.semanticFrame.origin };
+            return { x: 0, y: 0, z: 0 };
+        case 'polyhedron':
+            return marker.semanticFrame?.origin
+                ? { ...marker.semanticFrame.origin }
+                : geometry.vertices.length > 0
+                    ? averageVec3(geometry.vertices)
+                    : { x: 0, y: 0, z: 0 };
+    }
+}
+function getMarkerOverlayRotation(marker) {
+    if (marker.geometry.kind === 'box')
+        return marker.geometry.rotation ? { ...marker.geometry.rotation } : { x: 0, y: 0, z: 0 };
+    const forward = marker.semanticFrame?.forward ?? marker.spatial?.localFrame?.forward;
+    return forward ? createEulerFromForward(forward) : { x: 0, y: 0, z: 0 };
+}
+function getMarkerOverlayScale(marker, presentation) {
+    if (presentation === 'region' && marker.geometry.kind === 'box')
+        return { ...marker.geometry.size };
+    if (presentation === 'object' && marker.spatial?.bounds?.size)
+        return { ...marker.spatial.bounds.size };
+    if (presentation === 'anchor')
+        return { x: 0.66, y: 0.66, z: 0.66 };
+    if (presentation === 'object')
+        return { x: 0.58, y: 0.58, z: 0.58 };
+    return { x: 0.5, y: 0.5, z: 0.5 };
+}
+function averageVec3(points) {
+    return {
+        x: points.reduce((sum, point) => sum + point.x, 0) / points.length,
+        y: points.reduce((sum, point) => sum + point.y, 0) / points.length,
+        z: points.reduce((sum, point) => sum + point.z, 0) / points.length,
+    };
+}
+function createEulerFromForward(forward) {
+    const length = vec3Length(forward);
+    if (length < 0.000001)
+        return { x: 0, y: 0, z: 0 };
+    const unit = scaleVec3(forward, 1 / length);
+    const yaw = Math.atan2(unit.x, unit.z);
+    const horizontal = Math.sqrt(unit.x * unit.x + unit.z * unit.z);
+    const pitch = -Math.atan2(unit.y, horizontal);
+    return { x: pitch, y: yaw, z: 0 };
+}
+function applyTransformToOverlay(options, overlay, transform) {
+    applyTransformToRoot(options, overlay.root, transform);
+    applyMarkerFocusFrameToRoot(overlay.root, transform);
+    applyMarkerFrameTransform(options, overlay, transform);
+    applyMarkerLabelTransform(options, overlay, transform);
+}
+function applyMarkerFocusFrameToRoot(root, transform) {
+    if (!root)
+        return;
+    const bounds = createTransformBounds(transform);
+    const radius = Math.max(1, Math.hypot(bounds.size.x, bounds.size.y, bounds.size.z) / 2);
+    root.metadata = {
+        ...(root.metadata ?? {}),
+        editorFocusFrame: {
+            center: { ...bounds.center },
+            radius,
+        },
+    };
+}
+function applyMarkerFrameTransform(options, overlay, transform) {
+    const Vector3 = options.babylon.Vector3;
+    if (!Vector3 || !overlay.frameRoot)
+        return;
+    overlay.frameRoot.position = new Vector3(transform.position.x, transform.position.y, transform.position.z);
+    overlay.frameRoot.rotationQuaternion = null;
+    overlay.frameRoot.rotation = new Vector3(transform.rotation.x, transform.rotation.y, transform.rotation.z);
+    overlay.frameRoot.scaling = new Vector3(1, 1, 1);
+    applyMarkerFrameDimensions(options, overlay, transform.scale);
+}
+function applyMarkerFrameDimensions(options, overlay, markerSize) {
+    const Vector3 = options.babylon.Vector3;
+    if (!Vector3)
+        return;
+    const maxSize = Math.max(Math.abs(markerSize.x), Math.abs(markerSize.y), Math.abs(markerSize.z));
+    const presentationScale = overlay.presentation === 'anchor' ? 1.55 : overlay.presentation === 'point' ? 1.18 : 1;
+    const shaftLength = Math.max(0.75, Math.min(2.2, maxSize * 0.45 * presentationScale));
+    const headLength = Math.max(0.2, Math.min(0.34, shaftLength * 0.28));
+    const shaftDiameter = Math.max(0.055, Math.min(0.12, shaftLength * 0.075 * presentationScale));
+    const headDiameter = Math.max(0.18, Math.min(0.3, shaftLength * 0.22));
+    const anchorDiameter = Math.max(0.18, Math.min(0.34, shaftLength * 0.2 * presentationScale));
+    if (overlay.anchorMesh) {
+        overlay.anchorMesh.position = new Vector3(0, 0, 0);
+        overlay.anchorMesh.scaling = new Vector3(anchorDiameter, anchorDiameter, anchorDiameter);
+    }
+    if (overlay.forwardShaft) {
+        overlay.forwardShaft.position = new Vector3(0, 0, shaftLength / 2);
+        overlay.forwardShaft.scaling = new Vector3(shaftDiameter, shaftLength, shaftDiameter);
+    }
+    if (overlay.forwardHead) {
+        overlay.forwardHead.position = new Vector3(0, 0, shaftLength + headLength / 2);
+        overlay.forwardHead.scaling = new Vector3(headDiameter, headLength, headDiameter);
+    }
+    if (overlay.frameLines) {
+        const lineScale = Math.max(1, Math.min(3, shaftLength / 0.72));
+        overlay.frameLines.scaling = new Vector3(lineScale, lineScale, lineScale);
+    }
+}
+function applyTransformToRoot(options, root, transform) {
+    const Vector3 = options.babylon.Vector3;
+    if (!root || !Vector3)
+        return;
+    root.position = new Vector3(transform.position.x, transform.position.y, transform.position.z);
+    root.rotationQuaternion = null;
+    root.rotation = new Vector3(transform.rotation.x, transform.rotation.y, transform.rotation.z);
+    root.scaling = new Vector3(transform.scale.x, transform.scale.y, transform.scale.z);
+}
+function readRootTransform(root) {
+    if (!root)
+        return null;
+    const rotation = root.rotationQuaternion?.toEulerAngles?.() ?? root.rotation;
+    const transform = {
+        position: readVec3(root.position),
+        rotation: readVec3(rotation),
+        scale: readVec3(root.scaling),
+    };
+    if (!transform.position || !transform.rotation || !transform.scale)
+        return null;
+    return transform;
+}
+function readVec3(value) {
+    if (!Number.isFinite(value?.x) || !Number.isFinite(value?.y) || !Number.isFinite(value?.z))
+        return null;
+    return {
+        x: Number(value.x),
+        y: Number(value.y),
+        z: Number(value.z),
+    };
+}
+function averagePositions(transforms) {
+    return {
+        x: transforms.reduce((sum, transform) => sum + transform.position.x, 0) / transforms.length,
+        y: transforms.reduce((sum, transform) => sum + transform.position.y, 0) / transforms.length,
+        z: transforms.reduce((sum, transform) => sum + transform.position.z, 0) / transforms.length,
+    };
+}
+function addVec3(left, right) {
+    return {
+        x: left.x + right.x,
+        y: left.y + right.y,
+        z: left.z + right.z,
+    };
+}
+function subtractVec3(left, right) {
+    return {
+        x: left.x - right.x,
+        y: left.y - right.y,
+        z: left.z - right.z,
+    };
+}
+function scaleVec3(value, scalar) {
+    return {
+        x: value.x * scalar,
+        y: value.y * scalar,
+        z: value.z * scalar,
+    };
+}
+function vec3Length(value) {
+    return Math.sqrt(value.x * value.x + value.y * value.y + value.z * value.z);
+}
+function combineTransformBounds(transforms) {
+    let combined = null;
+    for (const transform of transforms) {
+        combined = combineBounds(combined, createTransformBounds(transform));
+    }
+    return combined;
+}
+function createTransformBounds(transform) {
+    const half = {
+        x: Math.abs(transform.scale.x) / 2,
+        y: Math.abs(transform.scale.y) / 2,
+        z: Math.abs(transform.scale.z) / 2,
+    };
+    const corners = [
+        { x: -half.x, y: -half.y, z: -half.z },
+        { x: half.x, y: -half.y, z: -half.z },
+        { x: -half.x, y: half.y, z: -half.z },
+        { x: half.x, y: half.y, z: -half.z },
+        { x: -half.x, y: -half.y, z: half.z },
+        { x: half.x, y: -half.y, z: half.z },
+        { x: -half.x, y: half.y, z: half.z },
+        { x: half.x, y: half.y, z: half.z },
+    ].map(corner => addVec3(rotateVec3ByEuler(corner, transform.rotation), transform.position));
+    const min = {
+        x: Math.min(...corners.map(corner => corner.x)),
+        y: Math.min(...corners.map(corner => corner.y)),
+        z: Math.min(...corners.map(corner => corner.z)),
+    };
+    const max = {
+        x: Math.max(...corners.map(corner => corner.x)),
+        y: Math.max(...corners.map(corner => corner.y)),
+        z: Math.max(...corners.map(corner => corner.z)),
+    };
+    return {
+        min,
+        max,
+        center: {
+            x: (min.x + max.x) / 2,
+            y: (min.y + max.y) / 2,
+            z: (min.z + max.z) / 2,
+        },
+        size: {
+            x: max.x - min.x,
+            y: max.y - min.y,
+            z: max.z - min.z,
+        },
+    };
+}
+function rotateVec3ByEuler(value, rotation) {
+    const cx = Math.cos(rotation.x);
+    const sx = Math.sin(rotation.x);
+    const cy = Math.cos(rotation.y);
+    const sy = Math.sin(rotation.y);
+    const cz = Math.cos(rotation.z);
+    const sz = Math.sin(rotation.z);
+    const afterX = {
+        x: value.x,
+        y: value.y * cx - value.z * sx,
+        z: value.y * sx + value.z * cx,
+    };
+    const afterY = {
+        x: afterX.x * cy + afterX.z * sy,
+        y: afterX.y,
+        z: -afterX.x * sy + afterX.z * cy,
+    };
+    return {
+        x: afterY.x * cz - afterY.y * sz,
+        y: afterY.x * sz + afterY.y * cz,
+        z: afterY.z,
+    };
+}
+function combineBounds(left, right) {
+    if (!left)
+        return right ? cloneBounds(right) : null;
+    if (!right)
+        return cloneBounds(left);
+    const min = {
+        x: Math.min(left.min.x, right.min.x),
+        y: Math.min(left.min.y, right.min.y),
+        z: Math.min(left.min.z, right.min.z),
+    };
+    const max = {
+        x: Math.max(left.max.x, right.max.x),
+        y: Math.max(left.max.y, right.max.y),
+        z: Math.max(left.max.z, right.max.z),
+    };
+    return {
+        min,
+        max,
+        center: {
+            x: (min.x + max.x) / 2,
+            y: (min.y + max.y) / 2,
+            z: (min.z + max.z) / 2,
+        },
+        size: {
+            x: max.x - min.x,
+            y: max.y - min.y,
+            z: max.z - min.z,
+        },
+    };
+}
+function cloneBounds(bounds) {
+    return {
+        min: { ...bounds.min },
+        max: { ...bounds.max },
+        center: { ...bounds.center },
+        size: { ...bounds.size },
+    };
+}
+//# sourceMappingURL=marker-overlay.js.map