@fps-games/editor 0.2.0-beta.4 → 0.2.1-beta.2

package/node_modules/@fps-games/editor-babylon/dist/selection-presentation-controller.js

@@ -0,0 +1,1746 @@
+import { BabylonSelectionIdentityPass, } from './selection-identity-pass.js';
+const SELECTION_OCCUPANCY_MASK_SHADER_NAME = 'editorSelectionOccupancyMask';
+const SELECTION_SILHOUETTE_SHADER_NAME = 'editorSelectionSilhouetteComposite';
+const MAX_SELECTION_SOURCE_DENSITY = 2;
+const TEXTURE_TYPE_UNSIGNED_BYTE = 0;
+const TEXTURE_TYPE_FLOAT = 1;
+const TEXTURE_TYPE_HALF_FLOAT = 2;
+const TEXTURE_NEAREST_SAMPLING_MODE = 1;
+const TEXTURE_BILINEAR_SAMPLING_MODE = 2;
+const SELECTION_PRESENTATION_PADDING_PX = 6;
+const SELECTION_PRESENTATION_COLOR = [1, 0.9, 0.22];
+const SELECTION_OCCUPANCY_MASK_FRAGMENT_SHADER = `
+precision highp float;
+varying vec2 vUV;
+uniform sampler2D editorSelectedDepthSampler;
+uniform sampler2D editorSelectionIdentitySampler;
+uniform vec2 editorSelectedDepthTexelSize;
+uniform vec2 editorOutputTexelSize;
+uniform vec2 editorPresentationTexelSize;
+uniform vec4 editorSelectionUvBounds;
+uniform float editorSelectedPackedDepth;
+uniform float editorSelectionIdentityEnabled;
+
+float unpackEditorDepth(vec4 color) {
+  const vec4 bitShift = vec4(
+    1.0 / (255.0 * 255.0 * 255.0),
+    1.0 / (255.0 * 255.0),
+    1.0 / 255.0,
+    1.0
+  );
+  return dot(color, bitShift);
+}
+
+float selectionOccupancyAt(vec2 uv) {
+  vec2 sampleUv = clamp(uv, vec2(0.0), vec2(1.0));
+  vec4 selectedDepthSample = texture2D(editorSelectedDepthSampler, sampleUv);
+  float selectedDepth = mix(
+    selectedDepthSample.r,
+    unpackEditorDepth(selectedDepthSample),
+    editorSelectedPackedDepth
+  );
+  return 1.0 - step(0.999999, selectedDepth);
+}
+
+float selectionIdentityValue(vec4 color) {
+  vec3 bytes = floor(color.rgb * 255.0 + 0.5);
+  return dot(bytes, vec3(65536.0, 256.0, 1.0));
+}
+
+float selectionIdentityBoundaryAgainst(
+  vec2 neighborUv,
+  float centerSelected,
+  float centerValue
+) {
+  vec4 neighborIdentity = texture2D(editorSelectionIdentitySampler, neighborUv);
+  float neighborValue = selectionIdentityValue(neighborIdentity);
+  float identitiesDiffer = step(0.5, abs(centerValue - neighborValue));
+  // The object-ID target already depth-resolves the selected surface. Pick one
+  // deterministic owner for each differing-ID edge to avoid double thickness.
+  float stableIdentityOwner = step(0.5, centerValue - neighborValue);
+  return centerSelected * identitiesDiffer * stableIdentityOwner;
+}
+
+float selectionIdentityBoundarySampleAt(vec2 uv, vec2 identityTexel) {
+  vec4 centerIdentity = texture2D(editorSelectionIdentitySampler, uv);
+  float centerSelected = step(0.001, centerIdentity.a);
+  float centerValue = selectionIdentityValue(centerIdentity);
+  float boundary = 0.0;
+  boundary = max(boundary, selectionIdentityBoundaryAgainst(
+    uv + vec2(-identityTexel.x, 0.0), centerSelected, centerValue
+  ));
+  boundary = max(boundary, selectionIdentityBoundaryAgainst(
+    uv + vec2(identityTexel.x, 0.0), centerSelected, centerValue
+  ));
+  boundary = max(boundary, selectionIdentityBoundaryAgainst(
+    uv + vec2(0.0, -identityTexel.y), centerSelected, centerValue
+  ));
+  boundary = max(boundary, selectionIdentityBoundaryAgainst(
+    uv + vec2(0.0, identityTexel.y), centerSelected, centerValue
+  ));
+  return boundary;
+}
+
+float selectionIdentityBoundaryCoverageAt(
+  vec2 uv,
+  vec2 outputTexel,
+  vec2 boundaryStep
+) {
+  vec2 ringWide = outputTexel * vec2(0.32476, 0.1875);
+  vec2 ringTall = outputTexel * vec2(0.0, 0.375);
+  float coverage = selectionIdentityBoundarySampleAt(uv - ringTall, boundaryStep);
+  coverage += selectionIdentityBoundarySampleAt(
+    uv + vec2(ringWide.x, -ringWide.y), boundaryStep
+  );
+  coverage += selectionIdentityBoundarySampleAt(uv + ringWide, boundaryStep);
+  coverage += selectionIdentityBoundarySampleAt(uv + ringTall, boundaryStep);
+  coverage += selectionIdentityBoundarySampleAt(
+    uv + vec2(-ringWide.x, ringWide.y), boundaryStep
+  );
+  coverage += selectionIdentityBoundarySampleAt(uv - ringWide, boundaryStep);
+  return coverage / 6.0;
+}
+
+void main(void) {
+  if (
+    vUV.x < editorSelectionUvBounds.x
+    || vUV.y < editorSelectionUvBounds.y
+    || vUV.x > editorSelectionUvBounds.z
+    || vUV.y > editorSelectionUvBounds.w
+  ) {
+    gl_FragColor = vec4(0.0);
+    return;
+  }
+  vec2 subpixelOffset = editorSelectedDepthTexelSize * 0.5;
+  float coverage = 0.0;
+  coverage += selectionOccupancyAt(vUV + vec2(-subpixelOffset.x, -subpixelOffset.y));
+  coverage += selectionOccupancyAt(vUV + vec2(subpixelOffset.x, -subpixelOffset.y));
+  coverage += selectionOccupancyAt(vUV + vec2(-subpixelOffset.x, subpixelOffset.y));
+  coverage += selectionOccupancyAt(vUV + vec2(subpixelOffset.x, subpixelOffset.y));
+  float identityBoundary = 0.0;
+  if (editorSelectionIdentityEnabled > 0.5) {
+    identityBoundary = selectionIdentityBoundaryCoverageAt(
+      vUV,
+      editorOutputTexelSize,
+      editorPresentationTexelSize
+    );
+  }
+  gl_FragColor = vec4(identityBoundary, 0.0, 0.0, coverage * 0.25);
+}
+`;
+const SELECTION_SILHOUETTE_FRAGMENT_SHADER = `
+precision highp float;
+varying vec2 vUV;
+uniform sampler2D textureSampler;
+uniform sampler2D editorSceneColorSampler;
+uniform sampler2D editorSceneDepthSampler;
+uniform sampler2D editorSelectedDepthSampler;
+uniform vec2 editorOutputTexelSize;
+uniform vec2 editorPresentationTexelSize;
+uniform vec4 editorSelectionUvBounds;
+uniform vec3 editorSelectionColor;
+uniform float editorScenePackedDepth;
+uniform float editorSelectedPackedDepth;
+uniform float editorSelectionIdentityEnabled;
+uniform float editorSceneBackgroundDepth;
+uniform float editorDepthEpsilon;
+
+float unpackEditorDepth(vec4 color) {
+  const vec4 bitShift = vec4(
+    1.0 / (255.0 * 255.0 * 255.0),
+    1.0 / (255.0 * 255.0),
+    1.0 / 255.0,
+    1.0
+  );
+  return dot(color, bitShift);
+}
+
+float readEditorDepth(sampler2D depthSampler, vec2 uv, float packedDepth) {
+  vec4 sampleValue = texture2D(depthSampler, clamp(uv, vec2(0.0), vec2(1.0)));
+  return mix(sampleValue.r, unpackEditorDepth(sampleValue), packedDepth);
+}
+
+float selectionCoverageAt(vec2 uv) {
+  return texture2D(textureSampler, clamp(uv, vec2(0.0), vec2(1.0))).a;
+}
+
+float resolvedSelectionIdentityBoundaryAt(vec2 uv, vec2 outputTexel) {
+  vec2 halfTexel = outputTexel * 0.5;
+  float coverage = texture2D(
+    textureSampler,
+    uv + vec2(-halfTexel.x, -halfTexel.y)
+  ).r;
+  coverage += texture2D(
+    textureSampler,
+    uv + vec2(halfTexel.x, -halfTexel.y)
+  ).r;
+  coverage += texture2D(
+    textureSampler,
+    uv + vec2(-halfTexel.x, halfTexel.y)
+  ).r;
+  coverage += texture2D(
+    textureSampler,
+    uv + vec2(halfTexel.x, halfTexel.y)
+  ).r;
+  return coverage * 0.25;
+}
+
+void considerStrongestSelectionNeighbor(
+  inout vec3 strongestSample,
+  vec2 uv,
+  vec2 texel,
+  vec2 offset
+) {
+  float coverage = selectionCoverageAt(uv + offset * texel);
+  float isStronger = step(strongestSample.x, coverage);
+  strongestSample = mix(
+    strongestSample,
+    vec3(coverage, offset),
+    isStronger
+  );
+}
+
+vec3 strongestSelectionNeighbor(vec2 uv, vec2 texel) {
+  vec3 strongestSample = vec3(0.0, 0.0, 0.0);
+  for (int y = -1; y <= 1; y++) {
+    for (int x = -1; x <= 1; x++) {
+      if (x != 0 || y != 0) {
+        considerStrongestSelectionNeighbor(
+          strongestSample,
+          uv,
+          texel,
+          vec2(float(x), float(y))
+        );
+      }
+    }
+  }
+  return strongestSample;
+}
+
+float selectionSubpixelVisibilityAt(vec2 uv) {
+  float selectedDepth = readEditorDepth(
+    editorSelectedDepthSampler,
+    uv,
+    editorSelectedPackedDepth
+  );
+  float sceneDepth = readEditorDepth(editorSceneDepthSampler, uv, editorScenePackedDepth);
+  float sceneBackgroundIsZero = 1.0 - step(0.5, editorSceneBackgroundDepth);
+  float emptyZeroDepth = sceneBackgroundIsZero * (1.0 - step(0.000001, sceneDepth));
+  sceneDepth = mix(sceneDepth, 1.0, emptyZeroDepth);
+  float hasSelection = 1.0 - step(0.999999, selectedDepth);
+  float depthDelta = selectedDepth - sceneDepth;
+  float isVisible = 1.0 - smoothstep(
+    editorDepthEpsilon,
+    editorDepthEpsilon * 4.0,
+    depthDelta
+  );
+  return hasSelection * isVisible;
+}
+
+float selectionSurfaceVisibilityAt(vec2 uv, vec2 texel) {
+  vec2 subpixelOffset = texel * 0.25;
+  float visibility = 0.0;
+  visibility = max(
+    visibility,
+    selectionSubpixelVisibilityAt(uv + vec2(-subpixelOffset.x, -subpixelOffset.y))
+  );
+  visibility = max(
+    visibility,
+    selectionSubpixelVisibilityAt(uv + vec2(subpixelOffset.x, -subpixelOffset.y))
+  );
+  visibility = max(
+    visibility,
+    selectionSubpixelVisibilityAt(uv + vec2(-subpixelOffset.x, subpixelOffset.y))
+  );
+  visibility = max(
+    visibility,
+    selectionSubpixelVisibilityAt(uv + vec2(subpixelOffset.x, subpixelOffset.y))
+  );
+  return visibility;
+}
+
+void main(void) {
+  vec4 sceneColor = texture2D(editorSceneColorSampler, vUV);
+  float center = texture2D(textureSampler, vUV).a;
+  if (
+    vUV.x < editorSelectionUvBounds.x
+    || vUV.y < editorSelectionUvBounds.y
+    || vUV.x > editorSelectionUvBounds.z
+    || vUV.y > editorSelectionUvBounds.w
+  ) {
+    gl_FragColor = vec4(sceneColor.rgb, 1.0);
+    return;
+  }
+  float identityAlpha = 0.0;
+  if (editorSelectionIdentityEnabled > 0.5) {
+    float identityBoundary = resolvedSelectionIdentityBoundaryAt(
+      vUV,
+      editorOutputTexelSize
+    );
+    float perceptualIdentityCoverage = pow(
+      clamp(identityBoundary, 0.0, 1.0),
+      0.75
+    );
+    identityAlpha = perceptualIdentityCoverage * selectionSurfaceVisibilityAt(
+      vUV,
+      editorOutputTexelSize
+    );
+  }
+  float unionAlpha = 0.0;
+  if (editorSelectionIdentityEnabled < 0.5 && center < 0.999) {
+    float outsideCoverage = 1.0 - clamp(center, 0.0, 1.0);
+    vec3 strongestSample = strongestSelectionNeighbor(vUV, editorPresentationTexelSize);
+    vec2 strongestSampleUv = vUV + strongestSample.yz * editorPresentationTexelSize;
+    float boundaryVisibility = selectionSurfaceVisibilityAt(
+      strongestSampleUv,
+      editorOutputTexelSize
+    );
+    unionAlpha = smoothstep(
+      0.0,
+      1.0,
+      strongestSample.x * outsideCoverage
+    ) * boundaryVisibility;
+  }
+  float alpha = max(unionAlpha, identityAlpha);
+  gl_FragColor = vec4(mix(sceneColor.rgb, editorSelectionColor, alpha), 1.0);
+}
+`;
+const sceneDepthLeases = new WeakMap();
+const prePassSceneDepthStates = new WeakMap();
+const PREPASS_SELECTION_DEPTH_CONFIGURATION_NAME = 'fpsEditorSelectionSceneDepth';
+const cameraSelectionPostProcessSlots = new WeakMap();
+export function createBabylonEditorSelectionPresentationController(options) {
+    const nodes = new Map();
+    const reportedDiagnosticCodes = new Set();
+    let selection = { selectedIds: [], activeId: null };
+    let backend = null;
+    let failed = false;
+    let disposed = false;
+    let selectedMeshCount = 0;
+    let prewarmed = false;
+    const prewarmedMeshes = new Set();
+    let lastDiagnostic = null;
+    const reportDiagnostic = (diagnostic) => {
+        lastDiagnostic = diagnostic;
+        if (reportedDiagnosticCodes.has(diagnostic.code))
+            return;
+        reportedDiagnosticCodes.add(diagnostic.code);
+        options.logger?.warn(`[selection-presentation:${diagnostic.code}] ${diagnostic.message}`, diagnostic.cause);
+        options.onDiagnostic?.(diagnostic);
+    };
+    const ensureBackend = () => {
+        if (disposed || failed)
+            return null;
+        if (backend)
+            return backend;
+        try {
+            backend = (options.createBackend ?? createDepthAwareSelectionPresentationBackend)(options, reportDiagnostic);
+            return backend;
+        }
+        catch (cause) {
+            failed = true;
+            reportDiagnostic({
+                code: 'backend-initialization-failed',
+                message: 'Selection silhouette resources could not be initialized; visual selection feedback is disabled.',
+                cause,
+            });
+            return null;
+        }
+    };
+    const syncBackendMembership = () => {
+        if (disposed)
+            return;
+        const previousSelectedMeshCount = selectedMeshCount;
+        const groups = selection.selectedIds
+            .map(selectionId => ({
+            selectionId,
+            meshes: collectSelectedPresentationMeshes(nodes, {
+                selectedIds: [selectionId],
+                activeId: selectionId,
+            }),
+        }))
+            .filter(group => group.meshes.length > 0);
+        const meshes = [];
+        const seenMeshes = new Set();
+        for (const group of groups) {
+            for (const mesh of group.meshes)
+                appendPresentationMesh(meshes, seenMeshes, mesh);
+        }
+        selectedMeshCount = meshes.length;
+        if (meshes.length === 0) {
+            // Projection attaches nodes incrementally. Once a cold-start prewarm has
+            // begun, later empty-selection membership updates must not cancel it
+            // before the first warm frame has rendered. A real deselection still
+            // clears the backend because it transitions from a non-empty selection.
+            if (prewarmed && previousSelectedMeshCount === 0)
+                return;
+            backend?.setSelectedMeshes([], groups);
+            backend?.setEnabled(false);
+            return;
+        }
+        const nextBackend = ensureBackend();
+        if (!nextBackend)
+            return;
+        try {
+            nextBackend.setSelectedMeshes(meshes, groups);
+            nextBackend.setEnabled(true);
+            nextBackend.prepareFrame();
+        }
+        catch (cause) {
+            failed = true;
+            safelyDisposeBackend(nextBackend, reportDiagnostic);
+            backend = null;
+            reportDiagnostic({
+                code: 'backend-initialization-failed',
+                message: 'Selection silhouette synchronization failed; visual selection feedback is disabled.',
+                cause,
+            });
+        }
+    };
+    const prewarmBackendIfNeeded = (node) => {
+        if (!options.prewarm || disposed || failed || selection.selectedIds.length > 0)
+            return;
+        const candidates = collectSelectedPresentationMeshes(new Map([[node.nodeId, node]]), { selectedIds: [node.nodeId], activeId: node.nodeId }).filter(mesh => !prewarmedMeshes.has(mesh));
+        if (candidates.length === 0)
+            return;
+        const nextBackend = ensureBackend();
+        if (!nextBackend?.prewarm)
+            return;
+        // Mark the controller before entering the backend because depth/pre-pass
+        // allocation can synchronously re-enter projection membership updates.
+        // Those empty-selection updates must observe the in-flight prewarm.
+        prewarmed = true;
+        for (const candidate of candidates)
+            prewarmedMeshes.add(candidate);
+        try {
+            nextBackend.prewarm(candidates);
+        }
+        catch (cause) {
+            for (const candidate of candidates)
+                prewarmedMeshes.delete(candidate);
+            prewarmed = prewarmedMeshes.size > 0;
+            reportDiagnostic({
+                code: 'backend-initialization-failed',
+                message: 'Selection silhouette prewarm failed; the first selection may compile resources on demand.',
+                cause,
+            });
+        }
+    };
+    return {
+        attachProjectedNode(node) {
+            if (disposed)
+                return;
+            nodes.set(node.nodeId, node);
+            syncBackendMembership();
+            prewarmBackendIfNeeded(node);
+        },
+        updateProjectedNode(node) {
+            if (disposed)
+                return;
+            nodes.set(node.nodeId, node);
+            syncBackendMembership();
+            prewarmBackendIfNeeded(node);
+        },
+        detachProjectedNode(nodeId) {
+            if (disposed)
+                return;
+            nodes.delete(nodeId);
+            syncBackendMembership();
+        },
+        syncSelection(nextSelection) {
+            if (disposed)
+                return;
+            selection = {
+                selectedIds: [...new Set(nextSelection.selectedIds)],
+                activeId: nextSelection.activeId,
+            };
+            syncBackendMembership();
+        },
+        prepareFrame() {
+            if (disposed || failed || selectedMeshCount === 0)
+                return;
+            try {
+                backend?.prepareFrame();
+            }
+            catch (cause) {
+                failed = true;
+                if (backend)
+                    safelyDisposeBackend(backend, reportDiagnostic);
+                backend = null;
+                reportDiagnostic({
+                    code: 'camera-replacement-failed',
+                    message: 'Selection silhouette camera resources could not be refreshed; visual selection feedback is disabled.',
+                    cause,
+                });
+            }
+        },
+        getDiagnostics() {
+            return {
+                status: disposed ? 'disposed' : failed ? 'failed' : selectedMeshCount > 0 ? 'active' : 'idle',
+                projectedNodeCount: nodes.size,
+                selectedNodeCount: selection.selectedIds.length,
+                selectedMeshCount,
+                backendResourceCount: backend?.getResourceCount() ?? 0,
+                sceneDepthSource: backend?.getSceneDepthSourceKind?.() ?? null,
+                cameraId: backend?.getCameraId() ?? null,
+                lastDiagnostic,
+            };
+        },
+        dispose() {
+            if (disposed)
+                return;
+            disposed = true;
+            nodes.clear();
+            selectedMeshCount = 0;
+            if (backend)
+                safelyDisposeBackend(backend, reportDiagnostic);
+            backend = null;
+        },
+    };
+}
+export function collectSelectedPresentationMeshes(nodes, selection) {
+    const selectedIds = new Set(selection.selectedIds);
+    const meshes = [];
+    const seen = new Set();
+    for (const [nodeId, node] of nodes) {
+        const rootSelected = selectedIds.has(nodeId);
+        const mappedSelectionNodeIds = new Set((node.selectionPresentationTargets ?? []).map(target => target.selectionNodeId));
+        const proxyNodeIds = new Set((node.selectionMeshes ?? [])
+            .map(readPresentationMeshSelectionNodeId)
+            .filter((id) => !!id));
+        for (const mesh of node.outlineMeshes) {
+            const meshNodeId = readPresentationMeshSelectionNodeId(mesh) ?? nodeId;
+            if (!rootSelected && (proxyNodeIds.has(meshNodeId) || !selectedIds.has(meshNodeId)))
+                continue;
+            appendPresentationMesh(meshes, seen, mesh);
+        }
+        for (const target of node.selectionPresentationTargets ?? []) {
+            if (!selectedIds.has(target.selectionNodeId))
+                continue;
+            for (const mesh of target.renderMeshes)
+                appendPresentationMesh(meshes, seen, mesh);
+        }
+        for (const mesh of node.selectionMeshes ?? []) {
+            const meshNodeId = readPresentationMeshSelectionNodeId(mesh) ?? nodeId;
+            if (mappedSelectionNodeIds.has(meshNodeId))
+                continue;
+            if (!selectedIds.has(meshNodeId))
+                continue;
+            appendPresentationMesh(meshes, seen, mesh);
+        }
+    }
+    return meshes;
+}
+function appendPresentationMesh(meshes, seen, mesh) {
+    if (!mesh || seen.has(mesh) || mesh.isDisposed?.())
+        return;
+    seen.add(mesh);
+    meshes.push(mesh);
+}
+function readPresentationMeshSelectionNodeId(mesh) {
+    const nodeId = mesh?.metadata?.editorProjection?.nodeId;
+    return typeof nodeId === 'string' && nodeId.length > 0 ? nodeId : null;
+}
+function createDepthAwareSelectionPresentationBackend(options, reportDiagnostic) {
+    const { babylon, scene } = options;
+    const beforeRenderObservable = scene?.onBeforeRenderObservable;
+    let beforeRenderObserver = null;
+    let enabled = false;
+    let disposed = false;
+    let selectedMeshes = [];
+    let selectionGroups = [];
+    let camera = null;
+    let sceneDepthLease = null;
+    let selectedDepthRenderer = null;
+    let selectedDepthMap = null;
+    let selectionIdentityPass = null;
+    const occupancyMaskPass = {
+        resource: null,
+        attached: false,
+        insertIndex: null,
+        slotOwner: {},
+    };
+    const compositePass = {
+        resource: null,
+        attached: false,
+        insertIndex: null,
+        slotOwner: {},
+    };
+    let width = 0;
+    let height = 0;
+    let selectionSourceRatio = MAX_SELECTION_SOURCE_DENSITY;
+    let shaderNotReadyFrames = 0;
+    let prewarming = false;
+    let prewarmCleanupQueued = false;
+    let prewarmReadyFrameCount = 0;
+    let prewarmRenderedFrameCount = 0;
+    let prewarmAfterRenderObserver = null;
+    let resourcesActive = false;
+    let sceneDepthLeaseActive = false;
+    let selectedDepthMapActive = false;
+    let selectionUvBounds = [0, 0, 1, 1];
+    registerSelectionSilhouetteShader(babylon);
+    const requiresSelectionIdentityPass = () => (selectionGroups.length > 1
+        && !!babylon.ShaderMaterial
+        && !!babylon.Effect?.ShadersStore);
+    const detachPostProcessPass = (pass) => {
+        if (!camera || !pass.resource || !pass.attached)
+            return;
+        const topologyBeforeDetach = Array.isArray(camera._postProcesses)
+            ? camera._postProcesses.slice()
+            : null;
+        try {
+            const attachedIndex = findCameraPostProcessIndex(camera, pass.resource);
+            if (attachedIndex >= 0)
+                pass.insertIndex = attachedIndex;
+            camera.detachPostProcess?.(pass.resource);
+            pass.attached = false;
+            reserveOwnedCameraPostProcessSlot(camera, pass.slotOwner, pass.insertIndex, topologyBeforeDetach);
+        }
+        catch (cause) {
+            if (forceDetachCameraPostProcess(camera, pass.resource)) {
+                pass.attached = false;
+                reserveOwnedCameraPostProcessSlot(camera, pass.slotOwner, pass.insertIndex, topologyBeforeDetach);
+            }
+            reportDiagnostic({
+                code: 'resource-dispose-failed',
+                message: 'A selection silhouette post-process could not be detached cleanly.',
+                cause,
+            });
+        }
+    };
+    const deactivateResources = () => {
+        resourcesActive = false;
+        selectionIdentityPass?.setEnabled(false);
+        if (sceneDepthLease && sceneDepthLeaseActive) {
+            try {
+                sceneDepthLease.deactivate();
+                sceneDepthLeaseActive = false;
+            }
+            catch (cause) {
+                reportDiagnostic({
+                    code: 'resource-dispose-failed',
+                    message: 'The shared scene depth lease could not be deactivated cleanly.',
+                    cause,
+                });
+            }
+        }
+        if (selectedDepthMap && selectedDepthMapActive) {
+            try {
+                removeCustomRenderTarget(scene, selectedDepthMap);
+                selectedDepthMapActive = false;
+            }
+            catch (cause) {
+                reportDiagnostic({
+                    code: 'resource-dispose-failed',
+                    message: 'The selected depth target could not be detached cleanly.',
+                    cause,
+                });
+            }
+        }
+        detachPostProcessPass(compositePass);
+        detachPostProcessPass(occupancyMaskPass);
+    };
+    const clearPrewarmAfterRenderObserver = () => {
+        if (prewarmAfterRenderObserver == null)
+            return;
+        scene?.onAfterRenderObservable?.remove?.(prewarmAfterRenderObserver);
+        prewarmAfterRenderObserver = null;
+    };
+    const finishPrewarm = () => {
+        if (!prewarming)
+            return;
+        prewarming = false;
+        clearPrewarmAfterRenderObserver();
+        prewarmReadyFrameCount = 0;
+        prewarmRenderedFrameCount = 0;
+        selectedMeshes = [];
+        selectionGroups = [];
+        if (selectedDepthMap)
+            selectedDepthMap.renderList = selectedMeshes;
+        enabled = false;
+        deactivateResources();
+    };
+    const activateResources = () => {
+        if (!enabled
+            || !sceneDepthLease
+            || !selectedDepthMap
+            || !occupancyMaskPass.resource
+            || !compositePass.resource
+            || requiresSelectionIdentityPass() !== !!selectionIdentityPass
+            || !camera)
+            return;
+        if (resourcesActive)
+            return;
+        if (!occupancyMaskPass.attached) {
+            occupancyMaskPass.insertIndex = attachOwnedCameraPostProcess(camera, occupancyMaskPass.slotOwner, occupancyMaskPass.resource);
+            occupancyMaskPass.attached = true;
+        }
+        if (!compositePass.attached) {
+            compositePass.insertIndex = attachOwnedCameraPostProcess(camera, compositePass.slotOwner, compositePass.resource);
+            compositePass.attached = true;
+        }
+        if (!sceneDepthLeaseActive) {
+            sceneDepthLease.activate();
+            sceneDepthLeaseActive = true;
+        }
+        if (!selectedDepthMapActive) {
+            selectedDepthMapActive = true;
+            addCustomRenderTarget(scene, selectedDepthMap);
+        }
+        selectionIdentityPass?.setEnabled(true);
+        resourcesActive = true;
+    };
+    const disposePostProcessPass = (pass, ownedCamera) => {
+        const resource = pass.resource;
+        if (resource) {
+            try {
+                resource.dispose?.(ownedCamera ?? undefined);
+            }
+            catch (cause) {
+                reportDiagnostic({
+                    code: 'resource-dispose-failed',
+                    message: 'A selection silhouette post-process resource could not be disposed cleanly.',
+                    cause,
+                });
+            }
+            releaseOwnedCameraPostProcessSlot(ownedCamera, pass.slotOwner, pass.insertIndex, resource);
+        }
+        pass.resource = null;
+        pass.attached = false;
+        pass.insertIndex = null;
+    };
+    const disposeCameraResources = (preservePrewarm = false) => {
+        if (!preservePrewarm) {
+            clearPrewarmAfterRenderObserver();
+            prewarming = false;
+        }
+        deactivateResources();
+        const ownedCamera = camera;
+        disposePostProcessPass(compositePass, ownedCamera);
+        disposePostProcessPass(occupancyMaskPass, ownedCamera);
+        const ownedSelectedDepthMap = selectedDepthMap;
+        if (selectedDepthRenderer) {
+            try {
+                selectedDepthRenderer.dispose?.();
+            }
+            catch (cause) {
+                reportDiagnostic({
+                    code: 'resource-dispose-failed',
+                    message: 'A selection silhouette depth resource could not be disposed cleanly.',
+                    cause,
+                });
+            }
+        }
+        if (ownedSelectedDepthMap) {
+            try {
+                ownedSelectedDepthMap.dispose?.();
+            }
+            catch (cause) {
+                reportDiagnostic({
+                    code: 'resource-dispose-failed',
+                    message: 'The owned selected depth target could not be disposed cleanly.',
+                    cause,
+                });
+            }
+        }
+        if (selectionIdentityPass) {
+            try {
+                selectionIdentityPass.dispose();
+            }
+            catch (cause) {
+                reportDiagnostic({
+                    code: 'resource-dispose-failed',
+                    message: 'The selection identity pass could not be disposed cleanly.',
+                    cause,
+                });
+            }
+        }
+        selectedDepthRenderer = null;
+        selectedDepthMap = null;
+        selectedDepthMapActive = false;
+        selectionIdentityPass = null;
+        if (sceneDepthLease) {
+            try {
+                sceneDepthLease.dispose();
+            }
+            catch (cause) {
+                reportDiagnostic({
+                    code: 'resource-dispose-failed',
+                    message: 'The leased scene depth source could not be disposed cleanly.',
+                    cause,
+                });
+            }
+        }
+        sceneDepthLease = null;
+        sceneDepthLeaseActive = false;
+        camera = null;
+        width = 0;
+        height = 0;
+        selectionSourceRatio = MAX_SELECTION_SOURCE_DENSITY;
+        shaderNotReadyFrames = 0;
+        resourcesActive = false;
+    };
+    const createCameraResources = (nextCamera) => {
+        const DepthRenderer = babylon.DepthRenderer;
+        const RenderTargetTexture = babylon.RenderTargetTexture;
+        const PostProcess = babylon.PostProcess;
+        if (!DepthRenderer || !RenderTargetTexture || !PostProcess) {
+            throw new Error('Babylon runtime is missing DepthRenderer, RenderTargetTexture, or PostProcess.');
+        }
+        const engine = scene.getEngine?.();
+        if (!engine)
+            throw new Error('Selection silhouette requires an active Babylon engine.');
+        const nextWidth = Math.max(1, Number(engine.getRenderWidth?.() ?? 1));
+        const nextHeight = Math.max(1, Number(engine.getRenderHeight?.() ?? 1));
+        const nextSelectionSourceRatio = resolveSelectionSourceRatio(engine);
+        const sceneDepthType = resolveDepthTextureType(engine);
+        let nextLease = null;
+        let nextSelectedRenderer = null;
+        let nextSelectedMap = null;
+        let nextSelectionIdentityPass = null;
+        let nextOccupancyMaskPass = null;
+        let nextCompositePass = null;
+        let adopted = false;
+        try {
+            nextSelectedMap = new RenderTargetTexture('editorSelectionSelectedDepth', {
+                width: Math.max(1, Math.ceil(nextWidth * nextSelectionSourceRatio)),
+                height: Math.max(1, Math.ceil(nextHeight * nextSelectionSourceRatio)),
+            }, scene, {
+                generateMipMaps: false,
+                doNotChangeAspectRatio: true,
+                type: sceneDepthType,
+                samplingMode: TEXTURE_NEAREST_SAMPLING_MODE,
+                generateDepthBuffer: true,
+                generateStencilBuffer: false,
+            });
+            nextSelectedRenderer = new DepthRenderer(scene, sceneDepthType, nextCamera, true, TEXTURE_NEAREST_SAMPLING_MODE, false, 'editorSelectionSelectedDepthRenderer', nextSelectedMap);
+            nextSelectedRenderer.forceDepthWriteTransparentMeshes = true;
+            nextSelectedMap.renderList = selectedMeshes;
+            if (requiresSelectionIdentityPass()) {
+                nextSelectionIdentityPass = new BabylonSelectionIdentityPass({
+                    babylon,
+                    scene,
+                    camera: nextCamera,
+                    width: Math.max(1, Math.ceil(nextWidth * nextSelectionSourceRatio)),
+                    height: Math.max(1, Math.ceil(nextHeight * nextSelectionSourceRatio)),
+                });
+                nextSelectionIdentityPass.setSelection(selectionGroups);
+            }
+            nextOccupancyMaskPass = new PostProcess('editorSelectionOccupancyMask', SELECTION_OCCUPANCY_MASK_SHADER_NAME, [
+                'editorSelectedDepthTexelSize',
+                'editorOutputTexelSize',
+                'editorPresentationTexelSize',
+                'editorSelectionUvBounds',
+                'editorSelectedPackedDepth',
+                'editorSelectionIdentityEnabled',
+            ], [
+                'editorSelectedDepthSampler',
+                'editorSelectionIdentitySampler',
+            ], 1, null, TEXTURE_BILINEAR_SAMPLING_MODE, engine, false);
+            nextOccupancyMaskPass.onApply = (effect) => {
+                const outputWidth = Math.max(1, Number(engine.getRenderWidth?.() ?? width ?? nextWidth));
+                const outputHeight = Math.max(1, Number(engine.getRenderHeight?.() ?? height ?? nextHeight));
+                const presentationSize = resolveSelectionPresentationSize(engine, outputWidth, outputHeight);
+                selectionUvBounds = prewarming
+                    ? [1, 1, 0, 0]
+                    : computeSelectionPresentationUvBounds(babylon, scene, nextCamera, selectedMeshes, outputWidth, outputHeight, SELECTION_PRESENTATION_PADDING_PX);
+                effect.setTexture?.('editorSelectedDepthSampler', nextSelectedMap);
+                const selectedSize = nextSelectedMap.getSize?.() ?? {
+                    width: nextWidth * nextSelectionSourceRatio,
+                    height: nextHeight * nextSelectionSourceRatio,
+                };
+                effect.setFloat2?.('editorSelectedDepthTexelSize', 1 / Math.max(1, Number(selectedSize.width)), 1 / Math.max(1, Number(selectedSize.height)));
+                effect.setFloat4?.('editorSelectionUvBounds', ...selectionUvBounds);
+                effect.setFloat?.('editorSelectedPackedDepth', nextSelectedRenderer?.isPacked ? 1 : 0);
+                effect.setTexture?.('editorSelectionIdentitySampler', nextSelectionIdentityPass?.texture ?? nextSelectedMap);
+                effect.setFloat2?.('editorOutputTexelSize', 1 / outputWidth, 1 / outputHeight);
+                effect.setFloat2?.('editorPresentationTexelSize', 1 / presentationSize.width, 1 / presentationSize.height);
+                effect.setFloat?.('editorSelectionIdentityEnabled', nextSelectionIdentityPass ? 1 : 0);
+            };
+            nextCompositePass = new PostProcess('editorSelectionSilhouetteComposite', SELECTION_SILHOUETTE_SHADER_NAME, [
+                'editorOutputTexelSize',
+                'editorPresentationTexelSize',
+                'editorSelectionUvBounds',
+                'editorSelectionColor',
+                'editorScenePackedDepth',
+                'editorSelectedPackedDepth',
+                'editorSelectionIdentityEnabled',
+                'editorSceneBackgroundDepth',
+                'editorDepthEpsilon',
+            ], [
+                'editorSceneColorSampler',
+                'editorSceneDepthSampler',
+                'editorSelectedDepthSampler',
+            ], 1, null, TEXTURE_BILINEAR_SAMPLING_MODE, engine, false);
+            nextLease = (options.sceneDepthSourceProvider ?? defaultSelectionSceneDepthSourceProvider).acquire({
+                babylon,
+                scene,
+                camera: nextCamera,
+                consumerPostProcess: nextCompositePass,
+                textureType: sceneDepthType,
+                width: nextWidth,
+                height: nextHeight,
+                reportDiagnostic,
+            });
+            nextCompositePass.onApply = (effect) => {
+                const outputWidth = Math.max(1, Number(engine.getRenderWidth?.() ?? width ?? nextWidth));
+                const outputHeight = Math.max(1, Number(engine.getRenderHeight?.() ?? height ?? nextHeight));
+                const presentationSize = resolveSelectionPresentationSize(engine, outputWidth, outputHeight);
+                effect.setTextureFromPostProcess?.('editorSceneColorSampler', nextOccupancyMaskPass);
+                effect.setTexture?.('editorSceneDepthSampler', nextLease?.getTexture());
+                effect.setTexture?.('editorSelectedDepthSampler', nextSelectedMap);
+                effect.setFloat2?.('editorOutputTexelSize', 1 / outputWidth, 1 / outputHeight);
+                effect.setFloat2?.('editorPresentationTexelSize', 1 / presentationSize.width, 1 / presentationSize.height);
+                effect.setFloat4?.('editorSelectionUvBounds', ...selectionUvBounds);
+                effect.setFloat3?.('editorSelectionColor', ...SELECTION_PRESENTATION_COLOR);
+                effect.setFloat?.('editorScenePackedDepth', nextLease?.packed ? 1 : 0);
+                effect.setFloat?.('editorSceneBackgroundDepth', nextLease?.backgroundDepth ?? 1);
+                effect.setFloat?.('editorSelectedPackedDepth', nextSelectedRenderer?.isPacked ? 1 : 0);
+                effect.setFloat?.('editorSelectionIdentityEnabled', nextSelectionIdentityPass ? 1 : 0);
+                effect.setFloat?.('editorDepthEpsilon', 0.0015);
+            };
+            camera = nextCamera;
+            sceneDepthLease = nextLease;
+            selectedDepthRenderer = nextSelectedRenderer;
+            selectedDepthMap = nextSelectedMap;
+            selectionIdentityPass = nextSelectionIdentityPass;
+            occupancyMaskPass.resource = nextOccupancyMaskPass;
+            compositePass.resource = nextCompositePass;
+            width = nextWidth;
+            height = nextHeight;
+            selectionSourceRatio = nextSelectionSourceRatio;
+            adopted = true;
+            activateResources();
+        }
+        catch (cause) {
+            if (adopted) {
+                disposeCameraResources();
+            }
+            else {
+                try {
+                    nextCompositePass?.dispose?.(nextCamera);
+                }
+                catch { }
+                try {
+                    nextOccupancyMaskPass?.dispose?.(nextCamera);
+                }
+                catch { }
+                try {
+                    nextSelectedRenderer?.dispose?.();
+                }
+                catch { }
+                try {
+                    nextSelectedMap?.dispose?.();
+                }
+                catch { }
+                try {
+                    nextSelectionIdentityPass?.dispose();
+                }
+                catch { }
+                try {
+                    nextLease?.dispose();
+                }
+                catch { }
+            }
+            throw cause;
+        }
+    };
+    const prepareFrame = () => {
+        if (disposed || !enabled)
+            return;
+        const nextCamera = scene.activeCamera ?? null;
+        if (!nextCamera)
+            return;
+        if (camera !== nextCamera
+            || !sceneDepthLease
+            || !selectedDepthMap
+            || !occupancyMaskPass.resource
+            || !compositePass.resource
+            || requiresSelectionIdentityPass() !== !!selectionIdentityPass) {
+            disposeCameraResources(true);
+            createCameraResources(nextCamera);
+            return;
+        }
+        const engine = scene.getEngine?.();
+        const nextWidth = Math.max(1, Number(engine?.getRenderWidth?.() ?? width));
+        const nextHeight = Math.max(1, Number(engine?.getRenderHeight?.() ?? height));
+        const nextSelectionSourceRatio = resolveSelectionSourceRatio(engine);
+        if (nextWidth !== width
+            || nextHeight !== height
+            || nextSelectionSourceRatio !== selectionSourceRatio) {
+            width = nextWidth;
+            height = nextHeight;
+            selectionSourceRatio = nextSelectionSourceRatio;
+            sceneDepthLease.resize(nextWidth, nextHeight);
+            selectedDepthMap.resize?.({
+                width: Math.max(1, Math.ceil(nextWidth * selectionSourceRatio)),
+                height: Math.max(1, Math.ceil(nextHeight * selectionSourceRatio)),
+            });
+            selectionIdentityPass?.resize(Math.max(1, Math.ceil(nextWidth * selectionSourceRatio)), Math.max(1, Math.ceil(nextHeight * selectionSourceRatio)));
+        }
+        selectedDepthMap.renderList = selectedMeshes;
+        activateResources();
+        if (occupancyMaskPass.resource.isSupported === false || compositePass.resource.isSupported === false) {
+            throw new Error('Selection silhouette post-process is not supported by the active engine.');
+        }
+        if (occupancyMaskPass.resource.isReady?.() && compositePass.resource.isReady?.()) {
+            shaderNotReadyFrames = 0;
+        }
+        else {
+            shaderNotReadyFrames += 1;
+            if (shaderNotReadyFrames > 120) {
+                reportDiagnostic({
+                    code: 'shader-not-ready',
+                    message: 'Selection silhouette shader did not become ready; visual selection feedback is disabled.',
+                });
+                throw new Error('Selection silhouette shader readiness timed out.');
+            }
+        }
+    };
+    if (beforeRenderObservable?.add) {
+        beforeRenderObserver = beforeRenderObservable.add(prepareFrame);
+    }
+    return {
+        setSelectedMeshes(meshes, groups) {
+            if (prewarming) {
+                // Projected nodes can publish empty membership while the scene is
+                // still being assembled. Treat that as prewarm noise; a non-empty
+                // selection is the only state transition that may take ownership of
+                // the warmed resources before cleanup.
+                if (meshes.length === 0)
+                    return;
+                prewarming = false;
+                clearPrewarmAfterRenderObserver();
+                prewarmReadyFrameCount = 0;
+                prewarmRenderedFrameCount = 0;
+            }
+            const requiredBefore = requiresSelectionIdentityPass();
+            selectedMeshes = [...meshes];
+            selectionGroups = groups?.map(group => ({
+                selectionId: group.selectionId,
+                meshes: [...group.meshes],
+            })) ?? [];
+            if (selectedDepthMap)
+                selectedDepthMap.renderList = selectedMeshes;
+            const requiredAfter = requiresSelectionIdentityPass();
+            if (camera && requiredBefore !== requiredAfter) {
+                disposeCameraResources();
+                if (enabled)
+                    prepareFrame();
+                return;
+            }
+            selectionIdentityPass?.setSelection(selectionGroups);
+        },
+        setEnabled(nextEnabled) {
+            if (prewarming && !nextEnabled)
+                return;
+            if (disposed || enabled === nextEnabled)
+                return;
+            enabled = nextEnabled;
+            if (enabled)
+                prepareFrame();
+            else {
+                prewarming = false;
+                clearPrewarmAfterRenderObserver();
+                prewarmReadyFrameCount = 0;
+                prewarmRenderedFrameCount = 0;
+                deactivateResources();
+            }
+        },
+        prewarm(meshes) {
+            if (disposed || meshes.length === 0 || (enabled && !prewarming))
+                return;
+            if (prewarming) {
+                const mergedMeshes = [...selectedMeshes];
+                const seenMeshes = new Set(mergedMeshes);
+                for (const mesh of meshes)
+                    appendPresentationMesh(mergedMeshes, seenMeshes, mesh);
+                selectedMeshes = mergedMeshes;
+                if (selectedDepthMap)
+                    selectedDepthMap.renderList = selectedMeshes;
+                prewarmReadyFrameCount = 0;
+                prewarmRenderedFrameCount = 0;
+                return;
+            }
+            selectedMeshes = [...meshes];
+            selectionGroups = [];
+            prewarming = true;
+            prewarmReadyFrameCount = 0;
+            prewarmRenderedFrameCount = 0;
+            enabled = true;
+            prepareFrame();
+            const afterRenderObservable = scene?.onAfterRenderObservable;
+            if (afterRenderObservable?.add) {
+                prewarmAfterRenderObserver = afterRenderObservable.add(() => {
+                    prewarmRenderedFrameCount += 1;
+                    const selectedDepthReady = selectedDepthMap?.isReadyForRendering?.() ?? true;
+                    const postProcessesReady = (occupancyMaskPass.resource?.isReady?.() ?? true)
+                        && (compositePass.resource?.isReady?.() ?? true);
+                    prewarmReadyFrameCount = selectedDepthReady && postProcessesReady
+                        ? prewarmReadyFrameCount + 1
+                        : 0;
+                    // One readiness probe can itself trigger deferred shader work.
+                    // Require a second rendered frame with all resources ready before
+                    // detaching them from the scene.
+                    if (prewarmReadyFrameCount < 2 && prewarmRenderedFrameCount < 4)
+                        return;
+                    clearPrewarmAfterRenderObserver();
+                    if (prewarmCleanupQueued)
+                        return;
+                    prewarmCleanupQueued = true;
+                    void Promise.resolve().then(() => {
+                        prewarmCleanupQueued = false;
+                        finishPrewarm();
+                    });
+                });
+            }
+            else {
+                finishPrewarm();
+            }
+        },
+        prepareFrame,
+        getResourceCount() {
+            if (!sceneDepthLease
+                && !selectedDepthRenderer
+                && !selectionIdentityPass
+                && !occupancyMaskPass.resource
+                && !compositePass.resource)
+                return 0;
+            return Number(!!sceneDepthLease)
+                + Number(!!selectedDepthRenderer)
+                + Number(!!selectionIdentityPass)
+                + Number(!!occupancyMaskPass.resource)
+                + Number(!!compositePass.resource);
+        },
+        getSceneDepthSourceKind() {
+            return sceneDepthLease?.kind ?? null;
+        },
+        getCameraId() {
+            const id = camera?.id;
+            return typeof id === 'string' ? id : null;
+        },
+        dispose() {
+            if (disposed)
+                return;
+            disposed = true;
+            clearPrewarmAfterRenderObserver();
+            prewarming = false;
+            prewarmCleanupQueued = false;
+            prewarmReadyFrameCount = 0;
+            prewarmRenderedFrameCount = 0;
+            if (beforeRenderObserver != null)
+                beforeRenderObservable?.remove?.(beforeRenderObserver);
+            beforeRenderObserver = null;
+            disposeCameraResources();
+            selectedMeshes = [];
+            selectionGroups = [];
+        },
+    };
+}
+function registerSelectionSilhouetteShader(babylon) {
+    const shadersStore = babylon.Effect?.ShadersStore;
+    if (!shadersStore)
+        throw new Error('Babylon runtime is missing Effect.ShadersStore.');
+    const maskShaderKey = `${SELECTION_OCCUPANCY_MASK_SHADER_NAME}PixelShader`;
+    const compositeShaderKey = `${SELECTION_SILHOUETTE_SHADER_NAME}PixelShader`;
+    if (!shadersStore[maskShaderKey])
+        shadersStore[maskShaderKey] = SELECTION_OCCUPANCY_MASK_FRAGMENT_SHADER;
+    if (!shadersStore[compositeShaderKey]) {
+        shadersStore[compositeShaderKey] = SELECTION_SILHOUETTE_FRAGMENT_SHADER;
+    }
+}
+export function computeSelectionPresentationUvBounds(babylon, scene, camera, meshes, width, height, paddingPx = SELECTION_PRESENTATION_PADDING_PX) {
+    const Vector3 = babylon.Vector3;
+    const Matrix = babylon.Matrix;
+    const transform = scene.getTransformMatrix?.();
+    if (!Vector3?.Project || !Matrix?.Identity || !transform || width <= 0 || height <= 0) {
+        return [0, 0, 1, 1];
+    }
+    const viewport = camera.viewport?.toGlobal?.(width, height)
+        ?? { x: 0, y: 0, width, height };
+    let minU = 1;
+    let minV = 1;
+    let maxU = 0;
+    let maxV = 0;
+    let projectedPointCount = 0;
+    try {
+        for (const mesh of meshes) {
+            if (!mesh || mesh.isDisposed?.())
+                continue;
+            if (hasRuntimeDeformedBounds(mesh))
+                return [0, 0, 1, 1];
+            mesh.computeWorldMatrix?.(true);
+            const vectors = mesh.getBoundingInfo?.()?.boundingBox?.vectorsWorld;
+            if (!Array.isArray(vectors) || vectors.length === 0)
+                return [0, 0, 1, 1];
+            for (const point of vectors) {
+                const projected = Vector3.Project(point, Matrix.Identity(), transform, viewport);
+                if (!Number.isFinite(projected?.x)
+                    || !Number.isFinite(projected?.y)
+                    || !Number.isFinite(projected?.z)
+                    || projected.z < 0
+                    || projected.z > 1)
+                    return [0, 0, 1, 1];
+                const u = projected.x / width;
+                const v = 1 - (projected.y / height);
+                minU = Math.min(minU, u);
+                minV = Math.min(minV, v);
+                maxU = Math.max(maxU, u);
+                maxV = Math.max(maxV, v);
+                projectedPointCount += 1;
+            }
+        }
+    }
+    catch {
+        return [0, 0, 1, 1];
+    }
+    if (projectedPointCount === 0)
+        return [0, 0, 1, 1];
+    const padU = Math.max(0, paddingPx) / width;
+    const padV = Math.max(0, paddingPx) / height;
+    return [
+        clampUnit(minU - padU),
+        clampUnit(minV - padV),
+        clampUnit(maxU + padU),
+        clampUnit(maxV + padV),
+    ];
+}
+function hasRuntimeDeformedBounds(mesh) {
+    const sourceMesh = mesh?.sourceMesh;
+    return !!(mesh?.skeleton
+        || mesh?.morphTargetManager
+        || mesh?.bakedVertexAnimationManager
+        || sourceMesh?.skeleton
+        || sourceMesh?.morphTargetManager
+        || sourceMesh?.bakedVertexAnimationManager);
+}
+function clampUnit(value) {
+    return Math.min(1, Math.max(0, value));
+}
+function resolveSelectionSourceRatio(engine) {
+    const hardwareScalingLevel = Number(engine?.getHardwareScalingLevel?.() ?? 1);
+    if (!Number.isFinite(hardwareScalingLevel) || hardwareScalingLevel <= 0) {
+        return MAX_SELECTION_SOURCE_DENSITY;
+    }
+    return Math.min(MAX_SELECTION_SOURCE_DENSITY, Math.max(1, MAX_SELECTION_SOURCE_DENSITY * hardwareScalingLevel));
+}
+function resolveSelectionPresentationSize(engine, outputWidth, outputHeight) {
+    const canvas = engine?.getRenderingCanvas?.();
+    const hardwareScalingLevel = Number(engine?.getHardwareScalingLevel?.() ?? 1);
+    const fallbackScale = Number.isFinite(hardwareScalingLevel) && hardwareScalingLevel > 0
+        ? hardwareScalingLevel
+        : 1;
+    return {
+        width: Math.max(1, Number(canvas?.clientWidth) || outputWidth * fallbackScale),
+        height: Math.max(1, Number(canvas?.clientHeight) || outputHeight * fallbackScale),
+    };
+}
+export const defaultSelectionSceneDepthSourceProvider = {
+    acquire(request) {
+        return createAdaptiveSelectionSceneDepthSourceLease(request);
+    },
+};
+function createAdaptiveSelectionSceneDepthSourceLease(request) {
+    let width = request.width;
+    let height = request.height;
+    let delegate = canUsePrePassSceneDepth(request)
+        ? createPrePassSelectionSceneDepthSourceLease(request)
+        : createDedicatedSelectionSceneDepthSourceLease(request);
+    let disposed = false;
+    let activated = false;
+    const replaceWithDedicatedSource = () => {
+        try {
+            delegate.dispose();
+        }
+        catch { }
+        delegate = createDedicatedSelectionSceneDepthSourceLease({ ...request, width, height });
+    };
+    return {
+        get kind() { return delegate.kind; },
+        get packed() { return delegate.packed; },
+        get backgroundDepth() { return delegate.backgroundDepth; },
+        getTexture() { return delegate.getTexture(); },
+        activate() {
+            if (disposed || activated)
+                return;
+            try {
+                delegate.activate();
+            }
+            catch (cause) {
+                if (delegate.kind !== 'prepass')
+                    throw cause;
+                replaceWithDedicatedSource();
+                delegate.activate();
+            }
+            activated = true;
+        },
+        deactivate() {
+            if (!activated)
+                return;
+            delegate.deactivate();
+            activated = false;
+        },
+        resize(nextWidth, nextHeight) {
+            width = nextWidth;
+            height = nextHeight;
+            delegate.resize(nextWidth, nextHeight);
+        },
+        dispose() {
+            if (disposed)
+                return;
+            disposed = true;
+            delegate.dispose();
+            activated = false;
+        },
+    };
+}
+function canUsePrePassSceneDepth(request) {
+    return !!(request.scene?.enablePrePassRenderer
+        && request.consumerPostProcess
+        && typeof request.consumerPostProcess.setPrePassRenderer === 'function'
+        && Number.isInteger(request.babylon.Constants?.PREPASS_SCREENSPACE_DEPTH_TEXTURE_TYPE));
+}
+function createPrePassSelectionSceneDepthSourceLease(request) {
+    const depthTextureType = request.babylon.Constants.PREPASS_SCREENSPACE_DEPTH_TEXTURE_TYPE;
+    const consumer = request.consumerPostProcess;
+    const originalSetPrePassRenderer = consumer.setPrePassRenderer;
+    let state = null;
+    let active = false;
+    let disposed = false;
+    const restoreConsumer = () => {
+        if (consumer.setPrePassRenderer === setPrePassRenderer) {
+            consumer.setPrePassRenderer = originalSetPrePassRenderer;
+        }
+    };
+    const setPrePassRenderer = function (prePassRenderer) {
+        const originalNeeded = originalSetPrePassRenderer.call(consumer, prePassRenderer);
+        if (!state || state.prePassRenderer !== prePassRenderer)
+            return originalNeeded;
+        state.configuration = prePassRenderer.addEffectConfiguration(state.configuration);
+        state.configuration.enabled = state.activeLeaseCount > 0;
+        return originalNeeded || state.configuration.enabled;
+    };
+    const deactivate = () => {
+        if (!active)
+            return;
+        active = false;
+        restoreConsumer();
+        if (state) {
+            state.activeLeaseCount = Math.max(0, state.activeLeaseCount - 1);
+            state.configuration.enabled = state.activeLeaseCount > 0;
+            state.prePassRenderer.markAsDirty?.();
+            state.prePassRenderer.update?.();
+        }
+    };
+    const getTexture = () => {
+        const index = state?.prePassRenderer?.getIndex?.(depthTextureType);
+        const texture = Number.isInteger(index) && index >= 0
+            ? state?.prePassRenderer?.defaultRT?.textures?.[index]
+            : null;
+        if (!texture)
+            throw new Error('Babylon pre-pass did not expose a compatible screen-space depth texture.');
+        return texture;
+    };
+    return {
+        kind: 'prepass',
+        packed: false,
+        backgroundDepth: 0,
+        getTexture,
+        activate() {
+            if (disposed || active)
+                return;
+            const prePassRenderer = request.scene.enablePrePassRenderer?.();
+            if (!prePassRenderer?.isSupported) {
+                throw new Error('Babylon pre-pass is unavailable on the active engine.');
+            }
+            state = prePassSceneDepthStates.get(request.scene) ?? {
+                prePassRenderer,
+                configuration: {
+                    name: PREPASS_SELECTION_DEPTH_CONFIGURATION_NAME,
+                    enabled: false,
+                    texturesRequired: [depthTextureType],
+                    needsImageProcessing: false,
+                },
+                activeLeaseCount: 0,
+            };
+            if (state.prePassRenderer !== prePassRenderer) {
+                throw new Error('The scene pre-pass renderer changed while acquiring selection depth.');
+            }
+            prePassSceneDepthStates.set(request.scene, state);
+            state.activeLeaseCount += 1;
+            state.configuration.enabled = true;
+            consumer.setPrePassRenderer = setPrePassRenderer;
+            active = true;
+            try {
+                prePassRenderer.markAsDirty?.();
+                prePassRenderer.update?.();
+                if (!prePassRenderer.enabled)
+                    throw new Error('Babylon pre-pass did not activate.');
+                getTexture();
+            }
+            catch (cause) {
+                deactivate();
+                throw cause;
+            }
+        },
+        deactivate,
+        resize() {
+            // Babylon owns this target and resizes it with the main render surface.
+        },
+        dispose() {
+            if (disposed)
+                return;
+            disposed = true;
+            deactivate();
+            restoreConsumer();
+        },
+    };
+}
+function createDedicatedSelectionSceneDepthSourceLease(request) {
+    const lease = acquireSceneDepthLease(request.babylon, request.scene, request.camera, request.textureType, request.width, request.height);
+    let active = false;
+    let disposed = false;
+    return {
+        kind: 'dedicated',
+        packed: lease.packed,
+        backgroundDepth: 1,
+        getTexture: () => lease.depthMap,
+        activate() {
+            if (disposed || active)
+                return;
+            activateSceneDepthLease(request.scene, lease);
+            active = true;
+        },
+        deactivate() {
+            if (!active)
+                return;
+            deactivateSceneDepthLease(request.scene, lease);
+            active = false;
+        },
+        resize(width, height) {
+            resizeSceneDepthLease(lease, width, height);
+        },
+        dispose() {
+            if (disposed)
+                return;
+            disposed = true;
+            if (active)
+                deactivateSceneDepthLease(request.scene, lease);
+            active = false;
+            releaseSceneDepthLease(request.scene, lease, request.reportDiagnostic);
+        },
+    };
+}
+function resolveDepthTextureType(engine) {
+    const caps = engine.getCaps?.() ?? {};
+    if (caps.textureHalfFloatRender)
+        return TEXTURE_TYPE_HALF_FLOAT;
+    if (caps.textureFloatRender)
+        return TEXTURE_TYPE_FLOAT;
+    return TEXTURE_TYPE_UNSIGNED_BYTE;
+}
+function acquireSceneDepthLease(babylon, scene, camera, type, width, height) {
+    let cameraLeases = sceneDepthLeases.get(scene);
+    if (!cameraLeases) {
+        cameraLeases = new Map();
+        sceneDepthLeases.set(scene, cameraLeases);
+    }
+    const existing = cameraLeases.get(camera);
+    if (existing && existing.type === type) {
+        resizeSceneDepthLease(existing, width, height);
+        existing.refs += 1;
+        return existing;
+    }
+    const DepthRenderer = babylon.DepthRenderer;
+    if (!DepthRenderer)
+        throw new Error('Babylon runtime is missing DepthRenderer.');
+    let renderer = null;
+    let depthMap = null;
+    try {
+        renderer = new DepthRenderer(scene, type, camera, true, TEXTURE_NEAREST_SAMPLING_MODE, false, 'editorSelectionSceneDepthRenderer');
+        renderer.forceDepthWriteTransparentMeshes = true;
+        depthMap = renderer.getDepthMap();
+        depthMap.renderListPredicate = (mesh) => !mesh?.metadata?.editorProjectionSelectionProxy;
+        depthMap.resize?.({ width, height });
+        const lease = {
+            camera,
+            renderer,
+            depthMap,
+            type,
+            packed: !!renderer.isPacked,
+            refs: 1,
+            activeRefs: 0,
+            width,
+            height,
+        };
+        cameraLeases.set(camera, lease);
+        return lease;
+    }
+    catch (cause) {
+        try {
+            renderer?.dispose?.();
+        }
+        catch { }
+        try {
+            depthMap?.dispose?.();
+        }
+        catch { }
+        if (cameraLeases.size === 0)
+            sceneDepthLeases.delete(scene);
+        throw cause;
+    }
+}
+function activateSceneDepthLease(scene, lease) {
+    if (lease.activeRefs === 0)
+        addCustomRenderTarget(scene, lease.depthMap);
+    lease.activeRefs += 1;
+}
+function deactivateSceneDepthLease(scene, lease) {
+    if (lease.activeRefs <= 0)
+        return;
+    if (lease.activeRefs === 1)
+        removeCustomRenderTarget(scene, lease.depthMap);
+    lease.activeRefs -= 1;
+}
+function resizeSceneDepthLease(lease, width, height) {
+    if (lease.width === width && lease.height === height)
+        return;
+    lease.depthMap.resize?.({ width, height });
+    lease.width = width;
+    lease.height = height;
+}
+function releaseSceneDepthLease(scene, lease, reportDiagnostic) {
+    lease.refs = Math.max(0, lease.refs - 1);
+    if (lease.refs > 0)
+        return;
+    lease.activeRefs = 0;
+    try {
+        removeCustomRenderTarget(scene, lease.depthMap);
+    }
+    catch (cause) {
+        reportDiagnostic({
+            code: 'resource-dispose-failed',
+            message: 'The owned scene depth target could not be detached cleanly.',
+            cause,
+        });
+    }
+    const cameraLeases = sceneDepthLeases.get(scene);
+    cameraLeases?.delete(lease.camera);
+    if (cameraLeases?.size === 0)
+        sceneDepthLeases.delete(scene);
+    try {
+        lease.renderer.dispose?.();
+    }
+    catch (cause) {
+        reportDiagnostic({
+            code: 'resource-dispose-failed',
+            message: 'A leased scene depth resource could not be disposed cleanly.',
+            cause,
+        });
+    }
+    try {
+        lease.depthMap.dispose?.();
+    }
+    catch (cause) {
+        reportDiagnostic({
+            code: 'resource-dispose-failed',
+            message: 'The owned scene depth target could not be disposed cleanly.',
+            cause,
+        });
+    }
+}
+function addCustomRenderTarget(scene, target) {
+    if (!target)
+        return;
+    scene.customRenderTargets = Array.isArray(scene.customRenderTargets) ? scene.customRenderTargets : [];
+    if (!scene.customRenderTargets.includes(target))
+        scene.customRenderTargets.push(target);
+}
+function removeCustomRenderTarget(scene, target) {
+    if (!target || !Array.isArray(scene.customRenderTargets))
+        return;
+    const index = scene.customRenderTargets.indexOf(target);
+    if (index >= 0)
+        scene.customRenderTargets.splice(index, 1);
+}
+function findCameraPostProcessIndex(camera, postProcess) {
+    return Array.isArray(camera?._postProcesses)
+        ? camera._postProcesses.indexOf(postProcess)
+        : -1;
+}
+function getCameraSelectionPostProcessSlotRegistry(camera) {
+    let registry = cameraSelectionPostProcessSlots.get(camera);
+    if (!registry) {
+        registry = { owners: new Map(), releasedSlots: new Map() };
+        cameraSelectionPostProcessSlots.set(camera, registry);
+    }
+    return registry;
+}
+function cameraPostProcessTopologyMatches(slots, topology) {
+    return topology != null
+        && slots.length === topology.length
+        && slots.every((slot, index) => slot === topology[index]);
+}
+function reserveOwnedCameraPostProcessSlot(camera, owner, insertIndex, topologyBeforeDetach) {
+    const slots = camera?._postProcesses;
+    const registry = cameraSelectionPostProcessSlots.get(camera);
+    const ownedSlot = registry?.owners.get(owner);
+    if (!Array.isArray(slots) || !registry || !ownedSlot)
+        return;
+    const reservedIndex = insertIndex ?? ownedSlot.index;
+    if (reservedIndex != null && reservedIndex < slots.length && slots[reservedIndex] === null) {
+        ownedSlot.index = reservedIndex;
+        ownedSlot.vacantTopology = slots.slice();
+    }
+    else {
+        ownedSlot.index = null;
+        ownedSlot.vacantTopology = null;
+    }
+    refreshProvenVacantCameraPostProcessTopologies(registry, slots, topologyBeforeDetach, owner);
+}
+function refreshProvenVacantCameraPostProcessTopologies(registry, slots, topologyBeforeMutation, excludedOwner = null) {
+    if (!topologyBeforeMutation)
+        return;
+    const nextTopology = slots.slice();
+    for (const [owner, slot] of registry.owners) {
+        if (owner !== excludedOwner
+            && slot.index != null
+            && slot.index < slots.length
+            && slots[slot.index] === null
+            && cameraPostProcessTopologyMatches(topologyBeforeMutation, slot.vacantTopology)) {
+            slot.vacantTopology = nextTopology;
+        }
+    }
+    for (const [releasedIndex, topology] of registry.releasedSlots) {
+        if (releasedIndex < slots.length
+            && slots[releasedIndex] === null
+            && cameraPostProcessTopologyMatches(topologyBeforeMutation, topology)) {
+            registry.releasedSlots.set(releasedIndex, nextTopology);
+        }
+    }
+}
+function attachOwnedCameraPostProcess(camera, owner, postProcess) {
+    const registry = getCameraSelectionPostProcessSlotRegistry(camera);
+    const slots = camera?._postProcesses;
+    const topologyBeforeAttach = Array.isArray(slots) ? slots.slice() : null;
+    const ownedSlot = registry.owners.get(owner);
+    let reusableIndex = null;
+    if (Array.isArray(slots)
+        && ownedSlot != null
+        && ownedSlot.postProcess === postProcess
+        && ownedSlot.index != null
+        && ownedSlot.index < slots.length
+        && slots[ownedSlot.index] === null
+        && cameraPostProcessTopologyMatches(slots, ownedSlot.vacantTopology)) {
+        reusableIndex = ownedSlot.index;
+    }
+    else if (Array.isArray(slots)) {
+        if (ownedSlot) {
+            ownedSlot.index = null;
+            ownedSlot.vacantTopology = null;
+        }
+        for (const [releasedIndex, topology] of [...registry.releasedSlots.entries()]
+            .sort(([left], [right]) => left - right)) {
+            if (releasedIndex >= slots.length
+                || slots[releasedIndex] !== null
+                || !cameraPostProcessTopologyMatches(slots, topology)) {
+                registry.releasedSlots.delete(releasedIndex);
+                continue;
+            }
+            reusableIndex = releasedIndex;
+            break;
+        }
+    }
+    try {
+        const attachedIndex = camera.attachPostProcess?.(postProcess, reusableIndex);
+        const actualIndex = Number.isInteger(attachedIndex) && attachedIndex >= 0
+            ? attachedIndex
+            : findCameraPostProcessIndex(camera, postProcess);
+        if (actualIndex < 0) {
+            throw new Error('The selection silhouette post-process was not attached to the active camera.');
+        }
+        registry.owners.set(owner, { index: actualIndex, postProcess, vacantTopology: null });
+        registry.releasedSlots.delete(actualIndex);
+        if (Array.isArray(slots)) {
+            refreshProvenVacantCameraPostProcessTopologies(registry, slots, topologyBeforeAttach, owner);
+        }
+        return actualIndex;
+    }
+    catch (cause) {
+        forceDetachCameraPostProcess(camera, postProcess);
+        throw cause;
+    }
+}
+function forceDetachCameraPostProcess(camera, postProcess) {
+    const slots = camera?._postProcesses;
+    if (!Array.isArray(slots))
+        return false;
+    const liveIndex = slots.indexOf(postProcess);
+    if (liveIndex >= 0)
+        slots[liveIndex] = null;
+    return slots.indexOf(postProcess) < 0;
+}
+function releaseOwnedCameraPostProcessSlot(camera, owner, insertIndex, postProcess) {
+    const slots = camera?._postProcesses;
+    if (!camera || !Array.isArray(slots))
+        return;
+    const registry = cameraSelectionPostProcessSlots.get(camera);
+    const ownedSlot = registry?.owners.get(owner);
+    const liveIndex = slots.indexOf(postProcess);
+    let releasedIndex = null;
+    if (liveIndex >= 0) {
+        slots[liveIndex] = null;
+        releasedIndex = liveIndex;
+    }
+    else if (insertIndex != null && slots[insertIndex] === postProcess) {
+        slots[insertIndex] = null;
+        releasedIndex = insertIndex;
+    }
+    else if (ownedSlot?.index != null
+        && ownedSlot.index < slots.length
+        && slots[ownedSlot.index] === null
+        && cameraPostProcessTopologyMatches(slots, ownedSlot.vacantTopology)) {
+        releasedIndex = ownedSlot.index;
+    }
+    registry?.owners.delete(owner);
+    const topologyBeforeTrim = slots.slice();
+    // Babylon uses null placeholders for detached passes. A released selection-owned hole may
+    // be reclaimed by a successor controller; only trailing placeholders are removed here so
+    // live passes never shift. Reserved inactive owners trimmed from the tail append on reattach.
+    while (slots.length > 0 && slots[slots.length - 1] == null)
+        slots.pop();
+    if (!registry)
+        return;
+    refreshProvenVacantCameraPostProcessTopologies(registry, slots, topologyBeforeTrim);
+    for (const slot of registry.owners.values()) {
+        if (slot.index != null && slot.index >= slots.length) {
+            slot.index = null;
+            slot.vacantTopology = null;
+        }
+    }
+    for (const released of [...registry.releasedSlots.keys()]) {
+        if (released >= slots.length) {
+            registry.releasedSlots.delete(released);
+        }
+    }
+    if (releasedIndex != null && releasedIndex < slots.length && slots[releasedIndex] === null) {
+        registry.releasedSlots.set(releasedIndex, slots.slice());
+    }
+    if (registry.owners.size === 0 && registry.releasedSlots.size === 0) {
+        cameraSelectionPostProcessSlots.delete(camera);
+    }
+}
+function safelyDisposeBackend(backend, reportDiagnostic) {
+    try {
+        backend.dispose();
+    }
+    catch (cause) {
+        reportDiagnostic({
+            code: 'resource-dispose-failed',
+            message: 'Selection silhouette resources could not be disposed cleanly.',
+            cause,
+        });
+    }
+}
+//# sourceMappingURL=selection-presentation-controller.js.map