@zephyr3d/scene 0.8.0 → 0.8.2

package/dist/render/gpu_picking.js

@@ -0,0 +1,100 @@
+import { Matrix4x4, Vector3, Vector4 } from '@zephyr3d/base';
+import { Camera } from '../camera/camera.js';
+import { ObjectColorPass } from './objectcolorpass.js';
+
+const _pickCamera = new Camera(null);
+const _objectColorPass = new ObjectColorPass();
+function decodeNormalizedFloat(rgba) {
+    const a = rgba[0] / 255;
+    const b = rgba[1] / 255;
+    const c = rgba[2] / 255;
+    const d = rgba[3] / 255;
+    return a / (256 * 256 * 256) + b / (256 * 256) + c / 256 + d;
+}
+/**
+ * Perform GPU-based object picking by rendering object IDs to a 1x1 framebuffer.
+ * @internal
+ */ function renderObjectColors(ctx, pickResolveFunc, renderQueue) {
+    const camera = ctx.camera;
+    const isWebGL1 = ctx.device.type === 'webgl';
+    ctx.renderPass = _objectColorPass;
+    ctx.device.pushDeviceStates();
+    const fb = ctx.device.pool.fetchTemporalFramebuffer(false, 1, 1, isWebGL1 ? [
+        'rgba8unorm',
+        'rgba8unorm'
+    ] : [
+        'rgba8unorm',
+        'rgba32f'
+    ], ctx.depthFormat, false);
+    ctx.device.setViewport(camera.viewport);
+    const vp = ctx.device.getViewport();
+    const windowX = camera.getPickPosX() / vp.width;
+    const windowY = (vp.height - camera.getPickPosY() - 1) / vp.height;
+    const windowW = 1 / vp.width;
+    const windowH = 1 / vp.height;
+    const pickCamera = _pickCamera;
+    camera.worldMatrix.decompose(pickCamera.scale, pickCamera.rotation, pickCamera.position);
+    let left = camera.getProjectionMatrix().getLeftPlane();
+    let right = camera.getProjectionMatrix().getRightPlane();
+    let bottom = camera.getProjectionMatrix().getBottomPlane();
+    let top = camera.getProjectionMatrix().getTopPlane();
+    const near = camera.getProjectionMatrix().getNearPlane();
+    const far = camera.getProjectionMatrix().getFarPlane();
+    const width = right - left;
+    const height = top - bottom;
+    left += width * windowX;
+    bottom += height * windowY;
+    right = left + width * windowW;
+    top = bottom + height * windowH;
+    pickCamera.setProjectionMatrix(camera.isPerspective() ? Matrix4x4.frustum(left, right, bottom, top, near, far) : Matrix4x4.ortho(left, right, bottom, top, near, far));
+    const cameraPos = isWebGL1 ? new Vector3(pickCamera.position) : null;
+    const ray = isWebGL1 ? camera.constructRay(camera.getPickPosX(), camera.getPickPosY()) : null;
+    ctx.device.setFramebuffer(fb);
+    _objectColorPass.clearColor = Vector4.zero();
+    _objectColorPass.clearDepth = 1;
+    const rq = _objectColorPass.cullScene(ctx, pickCamera);
+    _objectColorPass.render(ctx, pickCamera, null, rq);
+    rq.dispose();
+    ctx.device.popDeviceStates();
+    const colorTex = fb.getColorAttachments()[0];
+    const distanceTex = fb.getColorAttachments()[1];
+    const colorPixels = new Uint8Array(4);
+    const distancePixels = isWebGL1 ? new Uint8Array(4) : new Float32Array(4);
+    const device = ctx.device;
+    let fence;
+    if (ctx.device.type === 'webgl') {
+        fence = Promise.all([
+            ctx.device.runNextFrameAsync(()=>colorTex.readPixels(0, 0, 1, 1, 0, 0, colorPixels)),
+            ctx.device.runNextFrameAsync(()=>distanceTex.readPixels(0, 0, 1, 1, 0, 0, distancePixels))
+        ]);
+    } else {
+        fence = Promise.all([
+            colorTex.readPixels(0, 0, 1, 1, 0, 0, colorPixels),
+            distanceTex.readPixels(0, 0, 1, 1, 0, 0, distancePixels)
+        ]);
+    }
+    fence.then(()=>{
+        const drawable = renderQueue.getDrawableByColor(colorPixels);
+        let d = isWebGL1 ? decodeNormalizedFloat(distancePixels) * far : distancePixels[0];
+        const intersectedPoint = new Vector3(distancePixels[0], distancePixels[1], distancePixels[2]);
+        if (isWebGL1) {
+            intersectedPoint.x = cameraPos.x + ray.direction.x * d;
+            intersectedPoint.y = cameraPos.y + ray.direction.y * d;
+            intersectedPoint.z = cameraPos.z + ray.direction.z * d;
+            d = Vector3.distance(intersectedPoint, cameraPos);
+        }
+        pickResolveFunc(drawable ? {
+            distance: d,
+            intersectedPoint,
+            drawable,
+            target: drawable.getPickTarget()
+        } : null);
+        device.pool.releaseFrameBuffer(fb);
+    }).catch((_err)=>{
+        camera.getPickResultResolveFunc()?.(null);
+        device.pool.releaseFrameBuffer(fb);
+    });
+}
+
+export { renderObjectColors };
+//# sourceMappingURL=gpu_picking.js.map

package/dist/render/gpu_picking.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gpu_picking.js","sources":["../../src/render/gpu_picking.ts"],"sourcesContent":["import type { Nullable } from '@zephyr3d/base';\r\nimport { Matrix4x4, Vector3, Vector4 } from '@zephyr3d/base';\r\nimport type { DrawContext } from './drawable';\r\nimport type { RenderQueue } from './render_queue';\r\nimport { type PickResult, Camera } from '../camera';\r\nimport { ObjectColorPass } from './objectcolorpass';\r\n\r\nconst _pickCamera = new Camera(null);\r\nconst _objectColorPass = new ObjectColorPass();\r\n\r\nfunction decodeNormalizedFloat(rgba: Uint8Array<ArrayBuffer>): number {\r\n  const a = rgba[0] / 255;\r\n  const b = rgba[1] / 255;\r\n  const c = rgba[2] / 255;\r\n  const d = rgba[3] / 255;\r\n  return a / (256 * 256 * 256) + b / (256 * 256) + c / 256 + d;\r\n}\r\n\r\n/**\r\n * Perform GPU-based object picking by rendering object IDs to a 1x1 framebuffer.\r\n * @internal\r\n */\r\nexport function renderObjectColors(\r\n  ctx: DrawContext,\r\n  pickResolveFunc: (result: Nullable<PickResult>) => void,\r\n  renderQueue: RenderQueue\r\n): void {\r\n  const camera = ctx.camera;\r\n  const isWebGL1 = ctx.device.type === 'webgl';\r\n  ctx.renderPass = _objectColorPass;\r\n  ctx.device.pushDeviceStates();\r\n  const fb = ctx.device.pool.fetchTemporalFramebuffer(\r\n    false,\r\n    1,\r\n    1,\r\n    isWebGL1 ? ['rgba8unorm', 'rgba8unorm'] : ['rgba8unorm', 'rgba32f'],\r\n    ctx.depthFormat,\r\n    false\r\n  );\r\n  ctx.device.setViewport(camera.viewport);\r\n  const vp = ctx.device.getViewport();\r\n  const windowX = camera.getPickPosX() / vp.width;\r\n  const windowY = (vp.height - camera.getPickPosY() - 1) / vp.height;\r\n  const windowW = 1 / vp.width;\r\n  const windowH = 1 / vp.height;\r\n  const pickCamera = _pickCamera;\r\n  camera.worldMatrix.decompose(pickCamera.scale, pickCamera.rotation, pickCamera.position);\r\n  let left = camera.getProjectionMatrix().getLeftPlane();\r\n  let right = camera.getProjectionMatrix().getRightPlane();\r\n  let bottom = camera.getProjectionMatrix().getBottomPlane();\r\n  let top = camera.getProjectionMatrix().getTopPlane();\r\n  const near = camera.getProjectionMatrix().getNearPlane();\r\n  const far = camera.getProjectionMatrix().getFarPlane();\r\n  const width = right - left;\r\n  const height = top - bottom;\r\n  left += width * windowX;\r\n  bottom += height * windowY;\r\n  right = left + width * windowW;\r\n  top = bottom + height * windowH;\r\n  pickCamera.setProjectionMatrix(\r\n    camera.isPerspective()\r\n      ? Matrix4x4.frustum(left, right, bottom, top, near, far)\r\n      : Matrix4x4.ortho(left, right, bottom, top, near, far)\r\n  );\r\n  const cameraPos = isWebGL1 ? new Vector3(pickCamera.position) : null;\r\n  const ray = isWebGL1 ? camera.constructRay(camera.getPickPosX(), camera.getPickPosY()) : null;\r\n  ctx.device.setFramebuffer(fb);\r\n  _objectColorPass.clearColor = Vector4.zero();\r\n  _objectColorPass.clearDepth = 1;\r\n  const rq = _objectColorPass.cullScene(ctx, pickCamera);\r\n  _objectColorPass.render(ctx, pickCamera, null, rq);\r\n  rq.dispose();\r\n  ctx.device.popDeviceStates();\r\n  const colorTex = fb.getColorAttachments()[0];\r\n  const distanceTex = fb.getColorAttachments()[1];\r\n  const colorPixels = new Uint8Array(4);\r\n  const distancePixels = isWebGL1 ? new Uint8Array(4) : new Float32Array(4);\r\n  const device = ctx.device;\r\n  let fence: Promise<void[]>;\r\n  if (ctx.device.type === 'webgl') {\r\n    fence = Promise.all([\r\n      ctx.device.runNextFrameAsync(() => colorTex.readPixels(0, 0, 1, 1, 0, 0, colorPixels)),\r\n      ctx.device.runNextFrameAsync(() => distanceTex.readPixels(0, 0, 1, 1, 0, 0, distancePixels))\r\n    ]);\r\n  } else {\r\n    fence = Promise.all([\r\n      colorTex.readPixels(0, 0, 1, 1, 0, 0, colorPixels),\r\n      distanceTex.readPixels(0, 0, 1, 1, 0, 0, distancePixels)\r\n    ]);\r\n  }\r\n  fence\r\n    .then(() => {\r\n      const drawable = renderQueue.getDrawableByColor(colorPixels);\r\n      let d = isWebGL1\r\n        ? decodeNormalizedFloat(distancePixels as Uint8Array<ArrayBuffer>) * far\r\n        : distancePixels[0];\r\n      const intersectedPoint = new Vector3(distancePixels[0], distancePixels[1], distancePixels[2]);\r\n      if (isWebGL1) {\r\n        intersectedPoint.x = cameraPos!.x + ray!.direction.x * d;\r\n        intersectedPoint.y = cameraPos!.y + ray!.direction.y * d;\r\n        intersectedPoint.z = cameraPos!.z + ray!.direction.z * d;\r\n        d = Vector3.distance(intersectedPoint, cameraPos!);\r\n      }\r\n      pickResolveFunc(\r\n        drawable\r\n          ? {\r\n              distance: d,\r\n              intersectedPoint,\r\n              drawable,\r\n              target: drawable.getPickTarget()\r\n            }\r\n          : null\r\n      );\r\n      device.pool.releaseFrameBuffer(fb);\r\n    })\r\n    .catch((_err) => {\r\n      camera.getPickResultResolveFunc()?.(null);\r\n      device.pool.releaseFrameBuffer(fb);\r\n    });\r\n}\r\n"],"names":["_pickCamera","Camera","_objectColorPass","ObjectColorPass","decodeNormalizedFloat","rgba","a","b","c","d","renderObjectColors","ctx","pickResolveFunc","renderQueue","camera","isWebGL1","device","type","renderPass","pushDeviceStates","fb","pool","fetchTemporalFramebuffer","depthFormat","setViewport","viewport","vp","getViewport","windowX","getPickPosX","width","windowY","height","getPickPosY","windowW","windowH","pickCamera","worldMatrix","decompose","scale","rotation","position","left","getProjectionMatrix","getLeftPlane","right","getRightPlane","bottom","getBottomPlane","top","getTopPlane","near","getNearPlane","far","getFarPlane","setProjectionMatrix","isPerspective","Matrix4x4","frustum","ortho","cameraPos","Vector3","ray","constructRay","setFramebuffer","clearColor","Vector4","zero","clearDepth","rq","cullScene","render","dispose","popDeviceStates","colorTex","getColorAttachments","distanceTex","colorPixels","Uint8Array","distancePixels","Float32Array","fence","Promise","all","runNextFrameAsync","readPixels","then","drawable","getDrawableByColor","intersectedPoint","x","direction","y","z","distance","target","getPickTarget","releaseFrameBuffer","catch","_err","getPickResultResolveFunc"],"mappings":"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"}

package/dist/render/rendergraph/device_pool_allocator.js

@@ -0,0 +1,41 @@
+import { getDevice } from '../../app/api.js';
+
+/**
+ * Bridges the render graph's {@link RGTextureAllocator} interface to the
+ * engine's device resource pool (`device.pool`).
+ *
+ * Transient textures are fetched from the pool on {@link allocate} and
+ * returned to the pool on {@link release}, enabling automatic reuse
+ * across frames without manual lifecycle management.
+ *
+ * Usage:
+ * ```ts
+ * const allocator = new DevicePoolAllocator();
+ * const executor = new RenderGraphExecutor(allocator, width, height);
+ * ```
+ *
+ * @public
+ */ class DevicePoolAllocator {
+    /**
+   * Allocate a transient texture from the device pool.
+   *
+   * @param desc - Texture descriptor from the render graph pass.
+   * @param size - Resolved pixel dimensions.
+   * @returns A pooled Texture2D instance.
+   */ allocate(desc, size) {
+        const device = getDevice();
+        const mipmapping = (desc.mipLevels ?? 1) > 1;
+        return device.pool.fetchTemporalTexture2D(false, desc.format, size.width, size.height, mipmapping);
+    }
+    /**
+   * Release a transient texture back to the device pool.
+   *
+   * @param texture - The texture to release.
+   */ release(texture) {
+        const device = getDevice();
+        device.pool.releaseTexture(texture);
+    }
+}
+
+export { DevicePoolAllocator };
+//# sourceMappingURL=device_pool_allocator.js.map

package/dist/render/rendergraph/device_pool_allocator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"device_pool_allocator.js","sources":["../../../src/render/rendergraph/device_pool_allocator.ts"],"sourcesContent":["import type { Texture2D } from '@zephyr3d/device';\r\nimport type { RGTextureAllocator, RGTextureDesc, RGResolvedSize } from './types';\r\nimport { getDevice } from '../../app/api';\r\n\r\n/**\r\n * Bridges the render graph's {@link RGTextureAllocator} interface to the\r\n * engine's device resource pool (`device.pool`).\r\n *\r\n * Transient textures are fetched from the pool on {@link allocate} and\r\n * returned to the pool on {@link release}, enabling automatic reuse\r\n * across frames without manual lifecycle management.\r\n *\r\n * Usage:\r\n * ```ts\r\n * const allocator = new DevicePoolAllocator();\r\n * const executor = new RenderGraphExecutor(allocator, width, height);\r\n * ```\r\n *\r\n * @public\r\n */\r\nexport class DevicePoolAllocator implements RGTextureAllocator<Texture2D> {\r\n  /**\r\n   * Allocate a transient texture from the device pool.\r\n   *\r\n   * @param desc - Texture descriptor from the render graph pass.\r\n   * @param size - Resolved pixel dimensions.\r\n   * @returns A pooled Texture2D instance.\r\n   */\r\n  allocate(desc: RGTextureDesc, size: RGResolvedSize): Texture2D {\r\n    const device = getDevice();\r\n    const mipmapping = (desc.mipLevels ?? 1) > 1;\r\n    return device.pool.fetchTemporalTexture2D(false, desc.format, size.width, size.height, mipmapping);\r\n  }\r\n\r\n  /**\r\n   * Release a transient texture back to the device pool.\r\n   *\r\n   * @param texture - The texture to release.\r\n   */\r\n  release(texture: Texture2D): void {\r\n    const device = getDevice();\r\n    device.pool.releaseTexture(texture);\r\n  }\r\n}\r\n"],"names":["DevicePoolAllocator","allocate","desc","size","device","getDevice","mipmapping","mipLevels","pool","fetchTemporalTexture2D","format","width","height","release","texture","releaseTexture"],"mappings":";;AAIA;;;;;;;;;;;;;;;AAeC,IACM,MAAMA,mBAAAA,CAAAA;AACX;;;;;;AAMC,MACDC,QAASC,CAAAA,IAAmB,EAAEC,IAAoB,EAAa;AAC7D,QAAA,MAAMC,MAASC,GAAAA,SAAAA,EAAAA;AACf,QAAA,MAAMC,aAAa,CAACJ,KAAKK,SAAS,IAAI,CAAA,IAAK,CAAA;AAC3C,QAAA,OAAOH,MAAOI,CAAAA,IAAI,CAACC,sBAAsB,CAAC,KAAOP,EAAAA,IAAAA,CAAKQ,MAAM,EAAEP,IAAKQ,CAAAA,KAAK,EAAER,IAAAA,CAAKS,MAAM,EAAEN,UAAAA,CAAAA;AACzF;AAEA;;;;MAKAO,OAAAA,CAAQC,OAAkB,EAAQ;AAChC,QAAA,MAAMV,MAASC,GAAAA,SAAAA,EAAAA;QACfD,MAAOI,CAAAA,IAAI,CAACO,cAAc,CAACD,OAAAA,CAAAA;AAC7B;AACF;;;;"}

package/dist/render/rendergraph/executor.js

@@ -0,0 +1,146 @@
+/**
+ * Executes a compiled render graph with automatic resource lifecycle management.
+ *
+ * The executor allocates transient textures before their first use and releases
+ * them after their last use, using the provided {@link RGTextureAllocator}.
+ *
+ * Usage:
+ * ```ts
+ * const executor = new RenderGraphExecutor(myAllocator, backbufferWidth, backbufferHeight);
+ * executor.setImportedTexture(backbufferHandle, actualBackbufferTexture);
+ * executor.execute(compiledGraph);
+ * ```
+ *
+ * @typeParam TTexture - The concrete texture type (e.g. `Texture2D`).
+ * @public
+ */ class RenderGraphExecutor {
+    /** @internal */ _allocator;
+    /** @internal */ _backbufferWidth;
+    /** @internal */ _backbufferHeight;
+    /** @internal */ _importedTextures = new Map();
+    /** @internal */ _allocatedTextures = new Map();
+    constructor(allocator, backbufferWidth, backbufferHeight){
+        this._allocator = allocator;
+        this._backbufferWidth = backbufferWidth;
+        this._backbufferHeight = backbufferHeight;
+    }
+    /**
+   * Update the backbuffer dimensions used for 'backbuffer-relative' sizing.
+   */ setBackbufferSize(width, height) {
+        this._backbufferWidth = width;
+        this._backbufferHeight = height;
+    }
+    /**
+   * Register an imported (external) texture so it can be resolved during execution.
+   *
+   * @param handle - The handle returned from {@link RenderGraph.importTexture}.
+   * @param texture - The actual GPU texture object.
+   */ setImportedTexture(handle, texture) {
+        this._importedTextures.set(handle._id, texture);
+    }
+    /**
+   * Execute the compiled graph with full resource lifecycle management.
+   *
+   * For each pass in topological order:
+   * 1. Allocate any transient resources whose lifetime begins at this pass
+   * 2. Invoke the pass's execute callback with a context that resolves handles
+   * 3. Release any transient resources whose lifetime ends at this pass
+   *
+   * @param compiled - The compiled graph from {@link RenderGraph.compile}.
+   */ execute(compiled) {
+        // Build per-pass allocation and release schedules
+        const allocateAt = new Map(); // passIndex -> resourceIds to allocate
+        const releaseAt = new Map(); // passIndex -> resourceIds to release
+        for (const [resId, lifetime] of compiled.lifetimes){
+            if (lifetime.resource.kind === 'transient') {
+                if (!allocateAt.has(lifetime.firstUse)) {
+                    allocateAt.set(lifetime.firstUse, []);
+                }
+                allocateAt.get(lifetime.firstUse).push(resId);
+                if (!releaseAt.has(lifetime.lastUse)) {
+                    releaseAt.set(lifetime.lastUse, []);
+                }
+                releaseAt.get(lifetime.lastUse).push(resId);
+            }
+        }
+        const ctx = this._createContext();
+        for(let i = 0; i < compiled.orderedPasses.length; i++){
+            const pass = compiled.orderedPasses[i];
+            // Allocate resources that start at this pass
+            const toAllocate = allocateAt.get(i);
+            if (toAllocate) {
+                for (const resId of toAllocate){
+                    const lifetime = compiled.lifetimes.get(resId);
+                    const desc = lifetime.resource.desc;
+                    const size = this._resolveSize(desc);
+                    const texture = this._allocator.allocate(desc, size);
+                    this._allocatedTextures.set(resId, texture);
+                }
+            }
+            // Execute the pass
+            if (pass.executeFn) {
+                pass.executeFn(ctx, pass.data);
+            }
+            // Release resources that end at this pass
+            const toRelease = releaseAt.get(i);
+            if (toRelease) {
+                for (const resId of toRelease){
+                    const texture = this._allocatedTextures.get(resId);
+                    if (texture !== undefined) {
+                        this._allocator.release(texture);
+                        this._allocatedTextures.delete(resId);
+                    }
+                }
+            }
+        }
+    }
+    /**
+   * Clear imported texture registrations and any leftover allocated textures.
+   * Call this after execution or when resetting for a new frame.
+   */ reset() {
+        // Release any textures that weren't released (shouldn't happen in normal flow)
+        for (const texture of this._allocatedTextures.values()){
+            this._allocator.release(texture);
+        }
+        this._allocatedTextures.clear();
+        this._importedTextures.clear();
+    }
+    // ─── Private ────────────────────────────────────────────────────────
+    /** @internal */ _resolveSize(desc) {
+        const mode = desc.sizeMode ?? 'backbuffer-relative';
+        if (mode === 'absolute') {
+            return {
+                width: desc.width ?? 1,
+                height: desc.height ?? 1
+            };
+        }
+        // backbuffer-relative: width/height are scale factors (default 1.0)
+        const scaleX = desc.width ?? 1.0;
+        const scaleY = desc.height ?? 1.0;
+        return {
+            width: Math.max(1, Math.floor(this._backbufferWidth * scaleX)),
+            height: Math.max(1, Math.floor(this._backbufferHeight * scaleY))
+        };
+    }
+    /** @internal */ _createContext() {
+        const self = this;
+        return {
+            getTexture (handle) {
+                // Check imported first
+                const imported = self._importedTextures.get(handle._id);
+                if (imported !== undefined) {
+                    return imported;
+                }
+                // Check allocated transient
+                const allocated = self._allocatedTextures.get(handle._id);
+                if (allocated !== undefined) {
+                    return allocated;
+                }
+                throw new Error(`RenderGraphExecutor: cannot resolve resource "${handle.name}" (id=${handle._id}). ` + `It may not have been allocated yet or was already released.`);
+            }
+        };
+    }
+}
+
+export { RenderGraphExecutor };
+//# sourceMappingURL=executor.js.map

package/dist/render/rendergraph/executor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"executor.js","sources":["../../../src/render/rendergraph/executor.ts"],"sourcesContent":["import type {\r\n  CompiledRenderGraph,\r\n  RGTextureAllocator,\r\n  RGTextureDesc,\r\n  RGResolvedSize,\r\n  RGExecuteContext,\r\n  RGExecuteFn\r\n} from './types';\r\nimport type { RGHandle } from './types';\r\n\r\n/**\r\n * Executes a compiled render graph with automatic resource lifecycle management.\r\n *\r\n * The executor allocates transient textures before their first use and releases\r\n * them after their last use, using the provided {@link RGTextureAllocator}.\r\n *\r\n * Usage:\r\n * ```ts\r\n * const executor = new RenderGraphExecutor(myAllocator, backbufferWidth, backbufferHeight);\r\n * executor.setImportedTexture(backbufferHandle, actualBackbufferTexture);\r\n * executor.execute(compiledGraph);\r\n * ```\r\n *\r\n * @typeParam TTexture - The concrete texture type (e.g. `Texture2D`).\r\n * @public\r\n */\r\nexport class RenderGraphExecutor<TTexture = unknown> {\r\n  /** @internal */\r\n  private _allocator: RGTextureAllocator<TTexture>;\r\n  /** @internal */\r\n  private _backbufferWidth: number;\r\n  /** @internal */\r\n  private _backbufferHeight: number;\r\n  /** @internal */\r\n  private _importedTextures: Map<number, TTexture> = new Map();\r\n  /** @internal */\r\n  private _allocatedTextures: Map<number, TTexture> = new Map();\r\n\r\n  constructor(allocator: RGTextureAllocator<TTexture>, backbufferWidth: number, backbufferHeight: number) {\r\n    this._allocator = allocator;\r\n    this._backbufferWidth = backbufferWidth;\r\n    this._backbufferHeight = backbufferHeight;\r\n  }\r\n\r\n  /**\r\n   * Update the backbuffer dimensions used for 'backbuffer-relative' sizing.\r\n   */\r\n  setBackbufferSize(width: number, height: number): void {\r\n    this._backbufferWidth = width;\r\n    this._backbufferHeight = height;\r\n  }\r\n\r\n  /**\r\n   * Register an imported (external) texture so it can be resolved during execution.\r\n   *\r\n   * @param handle - The handle returned from {@link RenderGraph.importTexture}.\r\n   * @param texture - The actual GPU texture object.\r\n   */\r\n  setImportedTexture(handle: RGHandle, texture: TTexture): void {\r\n    this._importedTextures.set(handle._id, texture);\r\n  }\r\n\r\n  /**\r\n   * Execute the compiled graph with full resource lifecycle management.\r\n   *\r\n   * For each pass in topological order:\r\n   * 1. Allocate any transient resources whose lifetime begins at this pass\r\n   * 2. Invoke the pass's execute callback with a context that resolves handles\r\n   * 3. Release any transient resources whose lifetime ends at this pass\r\n   *\r\n   * @param compiled - The compiled graph from {@link RenderGraph.compile}.\r\n   */\r\n  execute(compiled: CompiledRenderGraph): void {\r\n    // Build per-pass allocation and release schedules\r\n    const allocateAt = new Map<number, number[]>(); // passIndex -> resourceIds to allocate\r\n    const releaseAt = new Map<number, number[]>(); // passIndex -> resourceIds to release\r\n\r\n    for (const [resId, lifetime] of compiled.lifetimes) {\r\n      if (lifetime.resource.kind === 'transient') {\r\n        if (!allocateAt.has(lifetime.firstUse)) {\r\n          allocateAt.set(lifetime.firstUse, []);\r\n        }\r\n        allocateAt.get(lifetime.firstUse)!.push(resId);\r\n\r\n        if (!releaseAt.has(lifetime.lastUse)) {\r\n          releaseAt.set(lifetime.lastUse, []);\r\n        }\r\n        releaseAt.get(lifetime.lastUse)!.push(resId);\r\n      }\r\n    }\r\n\r\n    const ctx = this._createContext();\r\n\r\n    for (let i = 0; i < compiled.orderedPasses.length; i++) {\r\n      const pass = compiled.orderedPasses[i];\r\n\r\n      // Allocate resources that start at this pass\r\n      const toAllocate = allocateAt.get(i);\r\n      if (toAllocate) {\r\n        for (const resId of toAllocate) {\r\n          const lifetime = compiled.lifetimes.get(resId)!;\r\n          const desc = lifetime.resource.desc!;\r\n          const size = this._resolveSize(desc);\r\n          const texture = this._allocator.allocate(desc, size);\r\n          this._allocatedTextures.set(resId, texture);\r\n        }\r\n      }\r\n\r\n      // Execute the pass\r\n      if (pass.executeFn) {\r\n        (pass.executeFn as RGExecuteFn<unknown>)(ctx, pass.data);\r\n      }\r\n\r\n      // Release resources that end at this pass\r\n      const toRelease = releaseAt.get(i);\r\n      if (toRelease) {\r\n        for (const resId of toRelease) {\r\n          const texture = this._allocatedTextures.get(resId);\r\n          if (texture !== undefined) {\r\n            this._allocator.release(texture);\r\n            this._allocatedTextures.delete(resId);\r\n          }\r\n        }\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Clear imported texture registrations and any leftover allocated textures.\r\n   * Call this after execution or when resetting for a new frame.\r\n   */\r\n  reset(): void {\r\n    // Release any textures that weren't released (shouldn't happen in normal flow)\r\n    for (const texture of this._allocatedTextures.values()) {\r\n      this._allocator.release(texture);\r\n    }\r\n    this._allocatedTextures.clear();\r\n    this._importedTextures.clear();\r\n  }\r\n\r\n  // ─── Private ────────────────────────────────────────────────────────\r\n\r\n  /** @internal */\r\n  private _resolveSize(desc: RGTextureDesc): RGResolvedSize {\r\n    const mode = desc.sizeMode ?? 'backbuffer-relative';\r\n    if (mode === 'absolute') {\r\n      return {\r\n        width: desc.width ?? 1,\r\n        height: desc.height ?? 1\r\n      };\r\n    }\r\n    // backbuffer-relative: width/height are scale factors (default 1.0)\r\n    const scaleX = desc.width ?? 1.0;\r\n    const scaleY = desc.height ?? 1.0;\r\n    return {\r\n      width: Math.max(1, Math.floor(this._backbufferWidth * scaleX)),\r\n      height: Math.max(1, Math.floor(this._backbufferHeight * scaleY))\r\n    };\r\n  }\r\n\r\n  /** @internal */\r\n  private _createContext(): RGExecuteContext {\r\n    const self = this;\r\n    return {\r\n      getTexture<T>(handle: RGHandle): T {\r\n        // Check imported first\r\n        const imported = self._importedTextures.get(handle._id);\r\n        if (imported !== undefined) {\r\n          return imported as unknown as T;\r\n        }\r\n        // Check allocated transient\r\n        const allocated = self._allocatedTextures.get(handle._id);\r\n        if (allocated !== undefined) {\r\n          return allocated as unknown as T;\r\n        }\r\n        throw new Error(\r\n          `RenderGraphExecutor: cannot resolve resource \"${handle.name}\" (id=${handle._id}). ` +\r\n            `It may not have been allocated yet or was already released.`\r\n        );\r\n      }\r\n    };\r\n  }\r\n}\r\n"],"names":["RenderGraphExecutor","_importedTextures","Map","_allocatedTextures","allocator","backbufferWidth","backbufferHeight","_allocator","_backbufferWidth","_backbufferHeight","setBackbufferSize","width","height","setImportedTexture","handle","texture","set","_id","execute","compiled","allocateAt","releaseAt","resId","lifetime","lifetimes","resource","kind","has","firstUse","get","push","lastUse","ctx","_createContext","i","orderedPasses","length","pass","toAllocate","desc","size","_resolveSize","allocate","executeFn","data","toRelease","undefined","release","delete","reset","values","clear","mode","sizeMode","scaleX","scaleY","Math","max","floor","self","getTexture","imported","allocated","Error","name"],"mappings":"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"}