@woosh/meep-engine 3.59.0 → 3.60.1

package/src/shade/renderer/geometry/sdf/cards/shader_mesh_cards_raster_args.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Threads a workgroup of {@link shader_mesh_cards_raster_args}.
+ * @type {number}
+ */
+export const MESH_CARDS_RASTER_ARGS_WORKGROUP_SIZE: number;
+/**
+ * @type {WebGPUStruct}
+ */
+export const MESH_CARDS_RASTER_ARGS_SETTINGS: WebGPUStruct;
+/**
+ * Card capture by raster, step 1: a thread a run, writing its draw. The draw is every card of the
+ * layout times every meshlet of the geometry, as instances, at a meshlet's worth of vertices: the
+ * card count is the device's, so the draw follows it rather than {@link MESH_CARD_MAX}.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_mesh_cards_raster_args: ComputeShader;
+import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
+import { ComputeShader } from "../../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_mesh_cards_raster_args.d.ts.map

package/src/shade/renderer/geometry/sdf/cards/shader_mesh_cards_raster_args.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shader_mesh_cards_raster_args.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/sdf/cards/shader_mesh_cards_raster_args.js"],"names":[],"mappings":"AAcA;;;GAGG;AACH,oDAFU,MAAM,CAEwC;AAExD;;GAEG;AACH,8CAFU,YAAY,CAKY;AAclC;;;;;;GAMG;AACH,4CAFU,aAAa,CAkCpB;6BAzE0B,sCAAsC;8BAJrC,kCAAkC"}

package/src/shade/renderer/geometry/sdf/cards/shader_mesh_cards_raster_args.js

@@ -0,0 +1,80 @@
+import { STRUCT_UNINDEXED_DRAW_COMMAND } from "../../../gpu_primitive/indirect/STRUCT_UNINDEXED_DRAW_COMMAND.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
+import { u32, vec4u } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../../shader/type/WebGPUArray.js";
+import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
+import { GEOMETRY_METADATA_STRUCT } from "../../GEOMETRY_METADATA_STRUCT.js";
+import { GEOMETRY_MESHLET_TRIANGLE_LIMIT } from "../../meshlet/GEOMETRY_MESHLET_TRIANGLE_LIMIT.js";
+import { MESH_SDF_HEADERS_RESOURCE, MESH_SDF_INDIRECTION_RESOURCE } from "../MESH_SDF_RESOURCES.js";
+import { chunk_mesh_cards } from "./chunk_mesh_cards.js";
+import { MESH_CARD_SETS_RESOURCE } from "./MESH_CARD_RESOURCES.js";
+import { MESH_CARD_SET_STRUCT } from "./MESH_CARD_SET_STRUCT.js";
+
+/**
+ * Threads a workgroup of {@link shader_mesh_cards_raster_args}.
+ * @type {number}
+ */
+export const MESH_CARDS_RASTER_ARGS_WORKGROUP_SIZE = 64;
+
+/**
+ * @type {WebGPUStruct}
+ */
+export const MESH_CARDS_RASTER_ARGS_SETTINGS = WebGPUStruct.from({
+    /** raster runs this frame */
+    run_count: u32,
+}, "MeshCardsRasterArgsSettings");
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.setImmediate("settings", MESH_CARDS_RASTER_ARGS_SETTINGS);
+
+resources.createGroup()
+    .add(MESH_SDF_HEADERS_RESOURCE)
+    .add(MESH_SDF_INDIRECTION_RESOURCE)
+    .add(MESH_CARD_SETS_RESOURCE)
+    .addStorageBuffer("mesh_card_raster_runs", WebGPUArray.from(vec4u))
+    .addStorageBuffer("geometries", WebGPUArray.from(GEOMETRY_METADATA_STRUCT))
+    .addStorageBuffer("mesh_card_raster_draws", WebGPUArray.from(STRUCT_UNINDEXED_DRAW_COMMAND), true);
+
+/**
+ * Card capture by raster, step 1: a thread a run, writing its draw. The draw is every card of the
+ * layout times every meshlet of the geometry, as instances, at a meshlet's worth of vertices: the
+ * card count is the device's, so the draw follows it rather than {@link MESH_CARD_MAX}.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_mesh_cards_raster_args = ComputeShader.from({
+    label: "Mesh Cards Raster Args",
+    resources,
+    body: CodeChunk.from(
+        //language=WGSL
+        `
+@compute @workgroup_size(${MESH_CARDS_RASTER_ARGS_WORKGROUP_SIZE})
+fn main(@builtin(global_invocation_id) id: vec3<u32>) {
+    let run = id.x;
+
+    if (run >= settings.run_count) {
+        return;
+    }
+
+    let card_set = mesh_card_sets[mesh_card_raster_runs[run].y];
+    let cards = mesh_sdf_indirection[mesh_sdf_headers[card_set.geometry].cards + MESH_CARD_LAYOUT_CARD_COUNT];
+
+    var draw: ${STRUCT_UNINDEXED_DRAW_COMMAND.wgsl_ref};
+
+    draw.vertexCount = ${GEOMETRY_MESHLET_TRIANGLE_LIMIT * 3}u;
+    draw.instanceCount = min(cards, MESH_CARD_MAX) * geometries[card_set.geometry].meshlets_count;
+    draw.firstVertex = 0u;
+    draw.firstInstance = 0u;
+
+    mesh_card_raster_draws[run] = draw;
+}
+`, [
+            STRUCT_UNINDEXED_DRAW_COMMAND.declaration_chunk,
+            GEOMETRY_METADATA_STRUCT.declaration_chunk,
+            MESH_CARD_SET_STRUCT.declaration_chunk,
+            chunk_mesh_cards,
+        ]),
+});

package/src/shade/renderer/geometry/sdf/cards/shader_mesh_cards_raster_scatter.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @type {WebGPUStruct}
+ */
+export const MESH_CARDS_RASTER_SCATTER_SETTINGS: WebGPUStruct;
+/**
+ * Card capture by raster, step 3: a thread a texel of each page of the frame's raster runs, a whole
+ * card set each, moving the texel from its card's cell of the scratch into the page's atlas tile.
+ * The thread → (run, page, texel) mapping is the trace's: the runs' first threads are ascending.
+ *
+ * Page texel (x, y) of column (u, v) is lattice point (7u + x, 7v + y) of the card, texel
+ * (7u + x, 7v + y) of its cell: a page's last texel and the next column's first are one texel.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_mesh_cards_raster_scatter: ComputeShader;
+import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
+import { ComputeShader } from "../../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_mesh_cards_raster_scatter.d.ts.map

package/src/shade/renderer/geometry/sdf/cards/shader_mesh_cards_raster_scatter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shader_mesh_cards_raster_scatter.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/sdf/cards/shader_mesh_cards_raster_scatter.js"],"names":[],"mappings":"AAcA;;GAEG;AACH,iDAFU,YAAY,CASe;AAgBrC;;;;;;;;;GASG;AACH,+CAFU,aAAa,CAgEpB;6BA1G0B,sCAAsC;8BAJrC,kCAAkC"}

package/src/shade/renderer/geometry/sdf/cards/shader_mesh_cards_raster_scatter.js

@@ -0,0 +1,113 @@
+import { chunk_index_to_grid2d } from "../../../shader/chunk/grid/chunk_index_to_grid2d.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
+import { u32, vec4u } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../../shader/type/WebGPUArray.js";
+import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
+import { MESH_SDF_BAKE_WORKGROUP_SIZE } from "../bake/MESH_SDF_BAKE.js";
+import { MESH_SDF_HEADERS_RESOURCE, MESH_SDF_INDIRECTION_RESOURCE } from "../MESH_SDF_RESOURCES.js";
+import { chunk_mesh_cards } from "./chunk_mesh_cards.js";
+import { MESH_CARD_SETS_RESOURCE } from "./MESH_CARD_RESOURCES.js";
+import { MESH_CARD_SET_STRUCT } from "./MESH_CARD_SET_STRUCT.js";
+import { MESH_CARD_RASTER_CELLS_X } from "./mesh_cards_raster_pass_descriptor.js";
+
+/**
+ * @type {WebGPUStruct}
+ */
+export const MESH_CARDS_RASTER_SCATTER_SETTINGS = WebGPUStruct.from({
+    /** raster runs this frame */
+    run_count: u32,
+    /** texels over every run's pages: the threads that do work */
+    thread_count: u32,
+    /** workgroups along x, the rest folded into y */
+    groups_x: u32,
+}, "MeshCardsRasterScatterSettings");
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.setImmediate("settings", MESH_CARDS_RASTER_SCATTER_SETTINGS);
+
+resources.createGroup()
+    .add(MESH_SDF_HEADERS_RESOURCE)
+    .add(MESH_SDF_INDIRECTION_RESOURCE)
+    .add(MESH_CARD_SETS_RESOURCE)
+    .addStorageBuffer("mesh_card_raster_runs", WebGPUArray.from(vec4u))
+    .addTexture("mesh_card_raster_albedo", "float", "2d")
+    .addTexture("mesh_card_raster_emissive", "float", "2d")
+    .addStorageTexture("mesh_card_albedo", "rgba8unorm", "2d", "write-only")
+    .addStorageTexture("mesh_card_emissive", "rgba8unorm", "2d", "write-only");
+
+/**
+ * Card capture by raster, step 3: a thread a texel of each page of the frame's raster runs, a whole
+ * card set each, moving the texel from its card's cell of the scratch into the page's atlas tile.
+ * The thread → (run, page, texel) mapping is the trace's: the runs' first threads are ascending.
+ *
+ * Page texel (x, y) of column (u, v) is lattice point (7u + x, 7v + y) of the card, texel
+ * (7u + x, 7v + y) of its cell: a page's last texel and the next column's first are one texel.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_mesh_cards_raster_scatter = ComputeShader.from({
+    label: "Mesh Cards Raster Scatter",
+    resources,
+    body: CodeChunk.from(
+        //language=WGSL
+        `
+@compute @workgroup_size(${MESH_SDF_BAKE_WORKGROUP_SIZE})
+fn main(
+    @builtin(workgroup_id) workgroup_id: vec3<u32>,
+    @builtin(local_invocation_index) lane: u32,
+) {
+    let thread = (workgroup_id.y * settings.groups_x + workgroup_id.x) * ${MESH_SDF_BAKE_WORKGROUP_SIZE}u + lane;
+
+    if (thread >= settings.thread_count) {
+        return;
+    }
+
+    // the run the thread falls in: the last whose first thread is at or below it
+    var low = 0u;
+    var high = settings.run_count;
+
+    while (high - low > 1u) {
+        let middle = (low + high) / 2u;
+
+        if (mesh_card_raster_runs[middle].x <= thread) {
+            low = middle;
+        } else {
+            high = middle;
+        }
+    }
+
+    let run = mesh_card_raster_runs[low];
+    let card_set = mesh_card_sets[run.y];
+
+    let page_texels = MESH_CARD_PAGE_TEXELS * MESH_CARD_PAGE_TEXELS;
+    let within = thread - run.x;
+    let page = within / page_texels;
+    let texel = vec2<u32>(within % MESH_CARD_PAGE_TEXELS, (within / MESH_CARD_PAGE_TEXELS) % MESH_CARD_PAGE_TEXELS);
+
+    let header = mesh_sdf_headers[card_set.geometry];
+    let columns = mesh_sdf_indirection[header.cards + MESH_CARD_LAYOUT_COLUMN_COUNT];
+
+    // the page list follows the tables
+    let listed = mesh_sdf_indirection[header.cards + MESH_CARD_LAYOUT_TABLES + columns + page];
+    let card = listed >> 16u;
+    let column = vec2<u32>(listed & 0xffu, (listed >> 8u) & 0xffu);
+
+    let corner = vec2<u32>(run.z & 0xffffu, run.z >> 16u)
+        + vec2<u32>(card % ${MESH_CARD_RASTER_CELLS_X}u, card / ${MESH_CARD_RASTER_CELLS_X}u) * run.w;
+    let drawn = corner + column * MESH_SDF_BRICK_VOXELS + texel;
+
+    let tiles_per_row = textureDimensions(mesh_card_albedo).x / MESH_CARD_PAGE_TEXELS;
+    let stored = index_to_grid2d(card_set.page_base + page, tiles_per_row) * MESH_CARD_PAGE_TEXELS + texel;
+
+    textureStore(mesh_card_albedo, stored, textureLoad(mesh_card_raster_albedo, drawn, 0));
+    textureStore(mesh_card_emissive, stored, textureLoad(mesh_card_raster_emissive, drawn, 0));
+}
+`, [
+            MESH_CARD_SET_STRUCT.declaration_chunk,
+            chunk_mesh_cards,
+            chunk_index_to_grid2d,
+        ]),
+});

package/src/shade/renderer/geometry/virtual/sdf/VGEO_SDF.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Words of the payload's header for `job_count` jobs: their counters, then the cut's own counters from its feedback
+ * slot (`VGEO_CUT_STAT`), which say whether the cut left a subtree undescended.
+ *
+ * @param {number} job_count
+ * @returns {number}
+ */
+export function vgeo_sdf_header_words(job_count: number): number;
+/**
+ * The extraction's settings, an immediate of each of its passes.
+ * @type {WebGPUStruct}
+ */
+export const VGEO_SDF_SETTINGS: WebGPUStruct;
+/**
+ * A job the frame cuts, as the host writes it: the vgeo geometry row it cuts and the projection constant that puts its
+ * error against a τ of 1, `1 / (½ voxel)` in the geometry's own units. A job the frame writes out (`decode` 1) has its
+ * room in the payload: `vertex_count` vertices from `vertex_base` and `triangle_count` triangles from `triangle_base`,
+ * what its last complete cut held.
+ * @type {WebGPUStruct}
+ */
+export const VGEO_SDF_JOB_STRUCT: WebGPUStruct;
+/**
+ * A job's counters, atomics the frame's passes add into: the clusters its cut took, the stand-ins among them (a
+ * cluster taken for a page not resident or a group held), those dropped past the cluster list, the vertices and
+ * triangles of its listed clusters, and of those, what the decode wrote into its room.
+ */
+export const VGEO_SDF_COUNTER: Readonly<{
+    TAKEN: 0;
+    STAND_INS: 1;
+    DROPPED: 2;
+    VERTICES: 3;
+    TRIANGLES: 4;
+    VERTICES_WRITTEN: 5;
+    TRIANGLES_WRITTEN: 6;
+}>;
+/**
+ * Words of a job's counters.
+ * @type {number}
+ */
+export const VGEO_SDF_COUNTER_WORDS: number;
+/**
+ * Words of a cluster list entry: its job, then its meshlet row.
+ * @type {number}
+ */
+export const VGEO_SDF_CLUSTER_WORDS: number;
+import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
+//# sourceMappingURL=VGEO_SDF.d.ts.map

package/src/shade/renderer/geometry/virtual/sdf/VGEO_SDF.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VGEO_SDF.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/sdf/VGEO_SDF.js"],"names":[],"mappings":"AAsEA;;;;;;GAMG;AACH,iDAHW,MAAM,GACJ,MAAM,CAIlB;AArED;;;GAGG;AACH,gCAFU,YAAY,CAWA;AAEtB;;;;;;GAMG;AACH,kCAFU,YAAY,CAWL;AAEjB;;;;GAIG;AACH;;;;;;;;GAQG;AAEH;;;GAGG;AACH,qCAFU,MAAM,CAEwB;AAExC;;;GAGG;AACH,qCAFU,MAAM,CAEwB;6BAnEX,sCAAsC"}

package/src/shade/renderer/geometry/virtual/sdf/VGEO_SDF.js

@@ -0,0 +1,80 @@
+import { f32, u32 } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
+import { VGEO_CUT_STAT_COUNT } from "../runtime/layout/VGEO_CUT_STAT_COUNT.js";
+
+/*
+ The layouts of a vgeo geometry's proxy extraction (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §7.8, as S8 built it): each geometry
+ whose cache is asked for is cut whole at half its cache's level-0 voxel, its cut's clusters listed, and, once a cut
+ stands nothing in, its vertices and triangles written out and read back for the proxy the mesh bake bakes.
+*/
+
+/**
+ * The extraction's settings, an immediate of each of its passes.
+ * @type {WebGPUStruct}
+ */
+export const VGEO_SDF_SETTINGS = WebGPUStruct.from({
+    /** jobs the frame cuts */
+    job_count: u32,
+    /** entries the cluster list holds */
+    cluster_capacity: u32,
+    /** the word of the payload its vertices start at, 3 floats a vertex */
+    vertex_offset: u32,
+    /** the word of the payload its triangles start at, 3 indices a triangle */
+    index_offset: u32,
+}, "VGeoSDFSettings");
+
+/**
+ * A job the frame cuts, as the host writes it: the vgeo geometry row it cuts and the projection constant that puts its
+ * error against a τ of 1, `1 / (½ voxel)` in the geometry's own units. A job the frame writes out (`decode` 1) has its
+ * room in the payload: `vertex_count` vertices from `vertex_base` and `triangle_count` triangles from `triangle_base`,
+ * what its last complete cut held.
+ * @type {WebGPUStruct}
+ */
+export const VGEO_SDF_JOB_STRUCT = WebGPUStruct.from({
+    vg_row: u32,
+    projection_k: f32,
+    decode: u32,
+    vertex_base: u32,
+    triangle_base: u32,
+    vertex_count: u32,
+    triangle_count: u32,
+    pad: u32,
+}, "VGeoSDFJob");
+
+/**
+ * A job's counters, atomics the frame's passes add into: the clusters its cut took, the stand-ins among them (a
+ * cluster taken for a page not resident or a group held), those dropped past the cluster list, the vertices and
+ * triangles of its listed clusters, and of those, what the decode wrote into its room.
+ */
+export const VGEO_SDF_COUNTER = Object.freeze({
+    TAKEN: 0,
+    STAND_INS: 1,
+    DROPPED: 2,
+    VERTICES: 3,
+    TRIANGLES: 4,
+    VERTICES_WRITTEN: 5,
+    TRIANGLES_WRITTEN: 6,
+});
+
+/**
+ * Words of a job's counters.
+ * @type {number}
+ */
+export const VGEO_SDF_COUNTER_WORDS = 8;
+
+/**
+ * Words of a cluster list entry: its job, then its meshlet row.
+ * @type {number}
+ */
+export const VGEO_SDF_CLUSTER_WORDS = 2;
+
+/**
+ * Words of the payload's header for `job_count` jobs: their counters, then the cut's own counters from its feedback
+ * slot (`VGEO_CUT_STAT`), which say whether the cut left a subtree undescended.
+ *
+ * @param {number} job_count
+ * @returns {number}
+ */
+export function vgeo_sdf_header_words(job_count) {
+    return job_count * VGEO_SDF_COUNTER_WORDS + VGEO_CUT_STAT_COUNT;
+}

package/src/shade/renderer/geometry/virtual/sdf/VGeoSDFProxies.d.ts

@@ -0,0 +1,91 @@
+/**
+ * The geometry caches of virtual geometry (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §7.8, as S8 built it): a
+ * {@link MeshSDFSource} of {@link GPUGeometrySDFManager}, which bakes a geometry's field from its tree, and a virtual
+ * geometry has none. Each virtual geometry whose cache is asked for gets a proxy, the triangles of a cut of it, baked by
+ * the mesh path as any geometry is, and its resident cache adopted into the geometry. Its instances are then composed
+ * from it as a mesh's are.
+ *
+ * **The cut.** A geometry is cut whole by the camera cut's own descent (`shader_vgeo_sdf_traverse`), at an error under
+ * half its cache's level-0 voxel, in its own space, under a feedback slot of the extraction's own: a cluster's page not
+ * resident is wanted there, as a view's are, and since a want lasts one reading the job is cut again each frame until
+ * its cut stands nothing in. Its counters are read back each frame.
+ *
+ * **The mesh.** The frame after a cut that stood nothing in, the job's clusters are written out too, its vertices as
+ * stored and its triangles as indices into them (`shader_vgeo_sdf_decode`), in room the last cut's counts made, and
+ * read back with that frame's counters. A frame that cut it otherwise (a page evicted since, the cut grown) is not
+ * taken, and the job is cut again.
+ *
+ * **The proxy.** One a frame, on the host: an ordinary geometry built from the mesh
+ * (`meshlet_geometry_build_from_geometry`, which costs 2.2 to 4.1 µs a triangle, measured), added to the geometry
+ * manager, its cache held with the side the geometry's holders draw. When its bake turns resident the next update gives
+ * it to the geometry ({@link GPUGeometrySDFManager#adopt}) and removes the proxy.
+ *
+ * A geometry no longer asked for when its turn comes is let go, and one whose holders ask again is extracted again.
+ * Settings that change the caches' voxel restart every job.
+ */
+export class VGeoSDFProxies {
+    /**
+     * @param {Object} options
+     * @param {GPUDevice} options.device
+     * @param {GPUVirtualGeometryRuntime} options.runtime whose geometries' caches this makes
+     * @param {GPUGeometryManager} options.geometries the scene's, whose caches the virtual geometries' are
+     * @param {number} [options.job_capacity] geometries extracted at once
+     */
+    constructor({ device, runtime, geometries, job_capacity }: {
+        device: GPUDevice;
+        runtime: GPUVirtualGeometryRuntime;
+        geometries: GPUGeometryManager;
+        job_capacity?: number;
+    });
+    /**
+     * The extraction's cut, whose `stats` say what the last reading of its slot counted.
+     * @returns {VGeoViewCut}
+     */
+    get cut(): VGeoViewCut;
+    /**
+     * Geometries being extracted.
+     * @returns {number}
+     */
+    get job_count(): number;
+    /**
+     * Geometries asked for that wait for a job, those let go since included.
+     * @returns {number}
+     */
+    get requested_count(): number;
+    /**
+     * Proxies built so far.
+     * @returns {number}
+     */
+    get extracted_count(): number;
+    /**
+     * Caches given to their geometries so far.
+     * @returns {number}
+     */
+    get adopted_count(): number;
+    /**
+     * Triangles of the proxies built so far.
+     * @returns {number}
+     */
+    get triangles_extracted(): number;
+    /**
+     * Entries the cluster list holds.
+     * @returns {number}
+     */
+    get cluster_capacity(): number;
+    /**
+     * The frame's work, ahead of the caches' bake: the caches baked given to their geometries, a proxy built, jobs
+     * started, and the jobs' cut recorded into `graph` while the runtime's frame is open.
+     *
+     * @param {FrameGraph} graph
+     */
+    graph_update(graph: FrameGraph): void;
+    destroy(): void;
+    #private;
+}
+export type FrameGraph = import("../../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
+export type GPUGeometryManager = import("../../GPUGeometryManager.js").GPUGeometryManager;
+export type GPUGeometryMetadata = import("../../GPUGeometryMetadata.js").GPUGeometryMetadata;
+export type MeshletGeometry = import("../../MeshletGeometry.js").MeshletGeometry;
+export type GPUVirtualGeometryRuntime = import("../runtime/GPUVirtualGeometryRuntime.js").GPUVirtualGeometryRuntime;
+import { VGeoViewCut } from "../runtime/VGeoViewCut.js";
+//# sourceMappingURL=VGeoSDFProxies.d.ts.map

package/src/shade/renderer/geometry/virtual/sdf/VGeoSDFProxies.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VGeoSDFProxies.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/sdf/VGeoSDFProxies.js"],"names":[],"mappings":"AAiJA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH;IAmEI;;;;;;OAMG;IACH;QAL8B,MAAM;QACU,OAAO,EAA1C,yBAAyB;QACG,UAAU,EAAtC,kBAAkB;QACD,YAAY,GAA7B,MAAM;OA8ChB;IAED;;;OAGG;IACH,uBAEC;IAED;;;OAGG;IACH,wBAUC;IAED;;;OAGG;IACH,8BAEC;IAED;;;OAGG;IACH,8BAEC;IAED;;;OAGG;IACH,4BAEC;IAED;;;OAGG;IACH,kCAEC;IAED;;;OAGG;IACH,+BAEC;IAsBD;;;;;OAKG;IACH,oBAFW,UAAU,QAsBpB;IA+dD,gBAqBC;;CACJ;yBAj2BY,OAAO,iEAAiE,EAAE,UAAU;iCACpF,OAAO,6BAA6B,EAAE,kBAAkB;kCACxD,OAAO,8BAA8B,EAAE,mBAAmB;8BAC1D,OAAO,0BAA0B,EAAE,eAAe;wCAClD,OAAO,yCAAyC,EAAE,yBAAyB;4BAjB5D,2BAA2B"}