@woosh/meep-engine 3.21.0 → 3.22.0

package/src/shade/renderer/geometry/virtual/format/prototypeVGEOFormatViewer.d.ts

@@ -1,395 +0,0 @@
-/**
- * Read a whole `.vgeo` file.
- *
- * Eager and complete, which is the opposite of what the runtime will do and exactly right for a
- * tool whose job is to look at every part of it.
- *
- * @param {ArrayBuffer} array_buffer the complete file
- * @returns {VGeoContainer}
- * @throws {Error} when the bytes are not a `.vgeo` at all, or a page uses a codec this reader has no
- *     decoder for — everything softer than that lands in {@link VGeoContainer.defects}
- */
-export function vgeo_read_container(array_buffer: ArrayBuffer): VGeoContainer;
-/**
- * Select the cut for a view, by descending the page graph.
- *
- * A traversal rather than a flat pass over every cluster, per design §4 — and it gets the cut rule's
- * first half for free. The rule is `project(parent) > τ AND project(self) ≤ τ`; a group is only ever
- * reached by descending *through* the cluster whose step consumed it, and that descent happened
- * precisely because the step projected above τ. Every cluster of a group shares that step's sphere
- * and error, so the parent test is satisfied by the act of arriving.
- *
- * The residency clamp degenerates here: the whole file is in memory, so nothing is ever
- * non-selectable and a leaf is the only reason to stop early.
- *
- * @param {VGeoContainer} container
- * @param {VGeoCutView} view
- * @returns {VGeoCut}
- */
-export function vgeo_select_cut(container: VGeoContainer, view: VGeoCutView): VGeoCut;
-/**
- * Decode the selected clusters into one geometry.
- *
- * Payloads are `SHADE_MESHLET_V1`'s (format §8): the index section first, three 8-bit local indices
- * per triangle, then the attribute sections. Position is always read — it is raw float32, never
- * constant-compressed — and the stored normal section only when a normal display asks for it,
- * because the direct path carries position and colour per vertex and nowhere to put the rest.
- *
- * @param {VGeoContainer} container
- * @param {VGeoCut} cut
- * @param {VGEO_COLOR_MODE} color_mode
- * @returns {VGeoCutGeometry}
- */
-export function vgeo_build_cut_geometry(container: VGeoContainer, cut: VGeoCut, color_mode: VGEO_COLOR_MODE): VGeoCutGeometry;
-/**
- * One page, decoded far enough to traverse.
- */
-export class VGeoPageView {
-    /**
-     * Page index, which is also the frame ordinal.
-     * @type {number}
-     */
-    index: number;
-    /**
-     * Byte offset of the decoded page's first byte in {@link VGeoContainer.page_bytes}.
-     * @type {number}
-     */
-    base: number;
-    /**
-     * The codec its frame stored it under. Informational here — the page is decoded before anything
-     * reads it — and worth showing, because it is per page and a file can carry both.
-     * @type {number}
-     */
-    codec: number;
-    /**
-     * Bytes the frame stores, before decoding.
-     * @type {number}
-     */
-    stored_size: number;
-    /**
-     * Bytes the page occupies decoded.
-     * @type {number}
-     */
-    decoded_size: number;
-    /**
-     * @type {number}
-     */
-    min_level: number;
-    /**
-     * @type {number}
-     */
-    max_level: number;
-    /**
-     * Absolute byte offset of this page's payload section.
-     * @type {number}
-     */
-    payload_base: number;
-    /**
-     * Id of this page's first cluster in the reader's own flat numbering, which is page order and
-     * then cluster-table order. The format has no global cluster id; this exists so the arrays on
-     * {@link VGeoContainer} can be indexed by one.
-     * @type {number}
-     */
-    cluster_base: number;
-    /**
-     * @type {number}
-     */
-    cluster_count: number;
-    /**
-     * `child_ref -> page index`, read out of the frame's child table.
-     * @type {Uint32Array}
-     */
-    child_pages: Uint32Array;
-    /**
-     * Per group: index of its first cluster within this page.
-     * @type {Uint16Array}
-     */
-    group_cluster_first: Uint16Array;
-    /**
-     * @type {Uint16Array}
-     */
-    group_cluster_count: Uint16Array;
-    /**
-     * How many clusters name this group as their child. Zero is what makes a group selectable with
-     * nothing above it — the root page's topmost groups, and only those.
-     * @type {Uint16Array}
-     */
-    group_parent_count: Uint16Array;
-    /**
-     * @type {number}
-     */
-    node_count: number;
-}
-/**
- * A whole `.vgeo` file, read into the flat form the traversal wants.
- *
- * Clusters are a structure of arrays rather than objects: an asset of any size has hundreds of
- * thousands of them, a cut reads a handful of fields from the ones it visits and nothing at all
- * from the ones it skips, and an object per cluster would cost more than the file does.
- */
-export class VGeoContainer {
-    /**
-     * Every page decoded, back to back in page order. Each page's {@link VGeoPageView.base} is an
-     * offset into this, and so — through it — is every payload offset a cluster record carries.
-     *
-     * It is not the file. Under a compressing codec the file does not hold a page's bytes at all,
-     * and even under the raw codec the two differ by the frame headers and child tables the decoded
-     * image leaves out.
-     *
-     * @type {Uint8Array}
-     */
-    page_bytes: Uint8Array;
-    /**
-     * What the frames store between them, before decoding — the part of the file that is pages.
-     * @type {number}
-     */
-    stored_page_bytes: number;
-    /**
-     * `page_bytes.length`, named so a caller does not have to know that.
-     * @type {number}
-     */
-    decoded_page_bytes: number;
-    /**
-     * @type {number}
-     */
-    format_version: number;
-    /**
-     * @type {number}
-     */
-    payload_encoding: number;
-    /**
-     * Hex, as the 16 asset-id bytes stand in the file.
-     * @type {string}
-     */
-    asset_id: string;
-    /**
-     * @type {number}
-     */
-    source_vertex_count: number;
-    /**
-     * @type {number}
-     */
-    source_face_count: number;
-    /**
-     * Object-space bounding sphere of the whole geometry: centre xyz then radius.
-     * @type {Float32Array}
-     */
-    object_sphere: Float32Array;
-    /**
-     * @type {Float32Array}
-     */
-    object_bounds: Float32Array;
-    /**
-     * @type {VGeoPageView[]}
-     */
-    pages: VGeoPageView[];
-    /**
-     * @type {{min_error:number, max_error:number, clusters:number, groups:number, triangles:number}[]}
-     */
-    levels: {
-        min_error: number;
-        max_error: number;
-        clusters: number;
-        groups: number;
-        triangles: number;
-    }[];
-    /**
-     * @type {number}
-     */
-    cluster_count: number;
-    /**
-     * `4 * cluster_count` — the LOD-metric sphere of the step that created each cluster.
-     * @type {Float32Array}
-     */
-    self_sphere: Float32Array;
-    /**
-     * @type {Float32Array}
-     */
-    self_error: Float32Array;
-    /**
-     * @type {Float32Array}
-     */
-    parent_error: Float32Array;
-    /**
-     * `4 * cluster_count` — each cluster's own tight sphere, for culling and never for the cut test.
-     * @type {Float32Array}
-     */
-    bounds_sphere: Float32Array;
-    /**
-     * @type {Uint16Array}
-     */
-    child_ref: Uint16Array;
-    /**
-     * @type {Uint16Array}
-     */
-    child_group: Uint16Array;
-    /**
-     * @type {Uint32Array}
-     */
-    encoding_flags: Uint32Array;
-    /**
-     * Offset into the owning page's payload section.
-     * @type {Uint32Array}
-     */
-    payload_offset: Uint32Array;
-    /**
-     * @type {Uint8Array}
-     */
-    vertex_count: Uint8Array;
-    /**
-     * @type {Uint8Array}
-     */
-    triangle_count: Uint8Array;
-    /**
-     * @type {Uint32Array}
-     */
-    page_of_cluster: Uint32Array;
-    /**
-     * Group index within that page, so a colour can be keyed on the residency unit.
-     * @type {Uint16Array}
-     */
-    group_of_cluster: Uint16Array;
-    /**
-     * How many clusters store a normal per vertex rather than one constant-compressed word for the
-     * whole cluster.
-     *
-     * A source carrying no normals encodes the engine default everywhere, and then `colour by
-     * stored normal` comes out one flat colour across the whole model. That is the file's truth and
-     * it reads exactly like a broken viewer, so the panel says the number outright.
-     *
-     * It is not a count of clusters that *have* normals: a cluster whose vertices genuinely all
-     * face the same way compresses to one word as well, and a flat surface is not a missing one.
-     *
-     * @type {number}
-     */
-    per_vertex_normal_cluster_count: number;
-    /**
-     * What {@link vgeo_validate_container} made of the file. Empty is the only good answer, and a
-     * non-empty one is the most interesting thing this tool can tell you.
-     * @type {VGeoDefect[]}
-     */
-    defects: VGeoDefect[];
-}
-/**
- * The view a cut is selected for. `VIRTUAL_GEOMETRY_DESIGN.md` §4: a cut is selected at one
- * camera's distances and pixel budget, and is the wrong cut for any other.
- */
-export class VGeoCutView {
-    /**
-     * Camera position, object space — the viewer draws at identity, so world and object agree.
-     * @type {Float32Array}
-     */
-    eye: Float32Array;
-    /**
-     * Pixels of permitted error. The one quality dial.
-     * @type {number}
-     */
-    tau: number;
-    /**
-     * Height of the render target, in pixels — the projection's numerator.
-     * @type {number}
-     */
-    screen_height: number;
-    /**
-     * @type {number}
-     */
-    fov_y: number;
-    /**
-     * @type {boolean}
-     */
-    cull_enabled: boolean;
-    /**
-     * Six normalized world-space planes, as {@link Camera.frustum} holds them.
-     * @type {Float32Array}
-     */
-    frustum: Float32Array;
-}
-/**
- * What one traversal came to, including what it had to look at to get there.
- */
-export class VGeoCut {
-    /**
-     * Selected clusters, by reader id.
-     * @type {number[]}
-     */
-    clusters: number[];
-    /**
-     * @type {number}
-     */
-    triangle_count: number;
-    /**
-     * @type {number}
-     */
-    vertex_count: number;
-    /**
-     * @type {number}
-     */
-    groups_visited: number;
-    /**
-     * @type {number}
-     */
-    clusters_tested: number;
-    /**
-     * Clusters whose subtree the frustum threw away, which is a whole region rather than one
-     * cluster — the reason culling belongs in the traversal and not after it.
-     * @type {number}
-     */
-    culled: number;
-    /**
-     * Distinct pages the traversal had to have resident.
-     * @type {number}
-     */
-    pages_touched: number;
-    /**
-     * @type {number}
-     */
-    duration_ms: number;
-}
-/**
- * What a cluster's colour is keyed on.
- *
- * The two normal modes are not keyed on the cluster at all: they paint every vertex with its own
- * direction, and the cluster boundaries go with it. `stored normal` is the container's own
- * {@link VGEO_ATTRIBUTE.NORMAL }, decoded out of the payload — the only mode that shows an attribute
- * the file carries rather than something derived from it. `geometric normal` is the area-weighted
- * normal of the decoded triangles, which is what every other mode shades with. The pair is the
- * point: they agree where the builder's normals still describe the geometry it shipped, and a
- * source with no normals at all makes the first one flat.
- */
-export type VGEO_COLOR_MODE = string;
-export namespace VGEO_COLOR_MODE {
-    let Cluster: string;
-    let Group: string;
-    let Page: string;
-    let Error: string;
-    let StoredNormal: string;
-    let GeometricNormal: string;
-}
-/**
- * A cut, decoded into one geometry.
- *
- * Nothing about it depends on where the camera is: the mesh is drawn solid and the depth buffer
- * orders it, so the triangle list is uploaded once when the cut is taken and never touched again.
- */
-export class VGeoCutGeometry {
-    /**
-     * Position and colour, indexed by {@link triangles}.
-     * @type {Geometry}
-     */
-    geometry: Geometry;
-    /**
-     * `3 * triangle_count` — the full triangle list, in cluster order, and the geometry's index.
-     * @type {Uint32Array}
-     */
-    triangles: Uint32Array;
-    /**
-     * @type {number}
-     */
-    triangle_count: number;
-    /**
-     * @type {number}
-     */
-    vertex_count: number;
-}
-import { Geometry } from "../../Geometry.js";
-//# sourceMappingURL=prototypeVGEOFormatViewer.d.ts.map

package/src/shade/renderer/geometry/virtual/format/prototypeVGEOFormatViewer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"prototypeVGEOFormatViewer.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/format/prototypeVGEOFormatViewer.js"],"names":[],"mappings":"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"}

package/src/shade/renderer/particles/ParticleRenderMode.d.ts

@@ -1,19 +0,0 @@
-/**
- * How the frame's particles are drawn — the one thing {@link GPUParticleSystemexecute } branches on
- * once the simulation has run.
- *
- * The simulation half is identical either way; the modes differ in whether anything downstream
- * cares what ORDER the particles arrive in. Blending billboards over a colour target does —
- * premultiplied transparency is order-dependent, so the draw list has to be back-to-front. AVBOIT's
- * voxel volume and its accumulators do not: every contribution is a sum, and a sum has no order.
- *
- * That is why the depth sort is a property of the mode rather than of the simulation. It is four
- * passes and a scan over every live particle, plus two lists a word per particle each, and under
- * AVBOIT none of it changes a pixel.
- */
-export type ParticleRenderMode = number;
-export namespace ParticleRenderMode {
-    let BILLBOARD: number;
-    let AVBOIT: number;
-}
-//# sourceMappingURL=ParticleRenderMode.d.ts.map

package/src/shade/renderer/particles/ParticleRenderMode.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ParticleRenderMode.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/particles/ParticleRenderMode.js"],"names":[],"mappings":";;;;;;;;;;;;;iCAaU,MAAM"}

package/src/shade/renderer/particles/ParticleRenderMode.js

@@ -1,33 +0,0 @@
-/**
- * How the frame's particles are drawn — the one thing {@link GPUParticleSystem#execute} branches on
- * once the simulation has run.
- *
- * The simulation half is identical either way; the modes differ in whether anything downstream
- * cares what ORDER the particles arrive in. Blending billboards over a colour target does —
- * premultiplied transparency is order-dependent, so the draw list has to be back-to-front. AVBOIT's
- * voxel volume and its accumulators do not: every contribution is a sum, and a sum has no order.
- *
- * That is why the depth sort is a property of the mode rather than of the simulation. It is four
- * passes and a scan over every live particle, plus two lists a word per particle each, and under
- * AVBOIT none of it changes a pixel.
- *
- * @enum {number}
- */
-export const ParticleRenderMode = {
-    /**
-     * Standalone: depth-sort the alive list back-to-front and draw it as billboards straight over a
-     * colour target with fixed-function blending. `color` and `depth` are required.
-     *
-     * For a page with no transparency pipeline of its own. See `graph_particles_billboard.js`.
-     */
-    BILLBOARD: 0,
-    /**
-     * Under the renderer: the AVBOIT transparency orchestrator draws the particles later in the
-     * frame, through the side-channel calls (`graph_particles_avboit.js`), off the same alive list
-     * and the same GPU-written draw args.
-     *
-     * Order-independent, so {@link GPUParticleSystem#execute} records no sort and no draw, allocates
-     * no sort buffers, and hands the colour target back untouched.
-     */
-    AVBOIT: 1,
-};

package/src/shade/renderer/particles/graph_particles_billboard.d.ts

@@ -1,37 +0,0 @@
-/**
- * Loads the colour target, depth-tests read-only against the scene, and draws
- * `drawIndirect(draw_args)` instances over `draw_list`.
- *
- * @param {object} params
- * @param {import("../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} params.graph
- * @param {number} params.camera graph handle of the camera uniform buffer
- * @param {number} params.color graph handle of the colour target the billboards draw over
- * @param {number} params.depth graph handle of the scene depth, tested against and never written
- * @param {number} params.pool graph handle of the particle pool
- * @param {number} params.draw_list graph handle of the slot list to draw, in draw order
- * @param {number} params.emitter_database graph handle
- * @param {number} params.draw_args graph handle of the indirect draw args: six vertices, one
- *   instance per live particle, written on-GPU by this frame's build-indirect pass
- * @param {object} params.render
- * @param {GPUTextureView} params.render.atlas sprite atlas
- * @param {GPUSampler} params.render.atlas_sampler
- * @param {(color_format: string, depth_format: string) => object} params.render.obtain_pipeline
- *   the billboard pipeline for the frame's attachment formats
- * @returns {number} the colour handle after the draw
- */
-export function graph_particles_billboard({ graph, camera, color, depth, pool, draw_list, emitter_database, draw_args, render }: {
-    graph: import("../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
-    camera: number;
-    color: number;
-    depth: number;
-    pool: number;
-    draw_list: number;
-    emitter_database: number;
-    draw_args: number;
-    render: {
-        atlas: GPUTextureView;
-        atlas_sampler: GPUSampler;
-        obtain_pipeline: (color_format: string, depth_format: string) => object;
-    };
-}): number;
-//# sourceMappingURL=graph_particles_billboard.d.ts.map

package/src/shade/renderer/particles/graph_particles_billboard.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"graph_particles_billboard.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/particles/graph_particles_billboard.js"],"names":[],"mappings":"AAkBA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IAhBkG,KAAK,EAA5F,OAAO,2DAA2D,EAAE,UAAU;IAC/D,MAAM,EAArB,MAAM;IACS,KAAK,EAApB,MAAM;IACS,KAAK,EAApB,MAAM;IACS,IAAI,EAAnB,MAAM;IACS,SAAS,EAAxB,MAAM;IACS,gBAAgB,EAA/B,MAAM;IACS,SAAS,EAAxB,MAAM;IAES,MAAM;QACS,KAAK;QACT,aAAa;QAC+B,eAAe,EAArF,CAAC,YAAY,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,KAAK,MAAM;;IAEpD,MAAM,CAuDlB"}

package/src/shade/renderer/particles/graph_particles_billboard.js

@@ -1,93 +0,0 @@
-import { TextureViewDescriptor } from "../../descriptor/texture/TextureViewDescriptor.js";
-import { DEFAULT_DEPTH_TEXTURE_VIEW } from "../depth/DEFAULT_DEPTH_TEXTURE_VIEW.js";
-import { PARTICLE_BILLBOARD_RESOURCES } from "./shaders/shader_particle_render.js";
-
-/**
- * The particle system's standalone drawing: one instanced billboard draw over a colour target with
- * fixed-function blending, for {@link ParticleRenderMode.BILLBOARD}. The renderer's own path draws
- * through `graph_particles_avboit.js` instead; these two files are the alternatives
- * {@link GPUParticleSystem#execute} picks between, and both read the handles the simulation left.
- *
- * The draw list is a parameter rather than a buffer this file names, because what it must be is a
- * property of the caller's blend state: premultiplied over-blending is order-dependent, so the
- * standalone path hands in the back-to-front list `sort/graph_particle_sort.js` produced.
- */
-
-/** The colour attachment's view: one mip, the one the frame draws into. */
-const COLOR_VIEW = TextureViewDescriptor.from({ mipLevelCount: 1, baseMipLevel: 0 });
-
-/**
- * Loads the colour target, depth-tests read-only against the scene, and draws
- * `drawIndirect(draw_args)` instances over `draw_list`.
- *
- * @param {object} params
- * @param {import("../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} params.graph
- * @param {number} params.camera graph handle of the camera uniform buffer
- * @param {number} params.color graph handle of the colour target the billboards draw over
- * @param {number} params.depth graph handle of the scene depth, tested against and never written
- * @param {number} params.pool graph handle of the particle pool
- * @param {number} params.draw_list graph handle of the slot list to draw, in draw order
- * @param {number} params.emitter_database graph handle
- * @param {number} params.draw_args graph handle of the indirect draw args: six vertices, one
- *   instance per live particle, written on-GPU by this frame's build-indirect pass
- * @param {object} params.render
- * @param {GPUTextureView} params.render.atlas sprite atlas
- * @param {GPUSampler} params.render.atlas_sampler
- * @param {(color_format: string, depth_format: string) => object} params.render.obtain_pipeline
- *   the billboard pipeline for the frame's attachment formats
- * @returns {number} the colour handle after the draw
- */
-export function graph_particles_billboard({ graph, camera, color, depth, pool, draw_list, emitter_database, draw_args, render }) {
-    const data = {};
-
-    const pass = graph.add("Particle Billboard", data, (data, resources, context) => {
-        const encoder = context.encoder;
-
-        const color_texture = resources.get(data.color);
-        const depth_texture = resources.get(data.depth);
-
-        const pipeline = render.obtain_pipeline(color_texture.descriptor.format, depth_texture.descriptor.format);
-
-        // Read by the soft-depth fade and tested against by the pass: the same view, read-only in
-        // both roles.
-        const depth_view = depth_texture.obtainView(DEFAULT_DEPTH_TEXTURE_VIEW);
-
-        const bindings = PARTICLE_BILLBOARD_RESOURCES.generateBindings({
-            camera: resources.get(data.camera),
-            pool: resources.get(data.pool),
-            draw_list: resources.get(data.draw_list),
-            emitter_database: resources.get(data.emitter_database),
-            atlas: render.atlas,
-            atlas_sampler: render.atlas_sampler,
-            scene_depth: depth_view,
-        }, encoder);
-
-        const render_pass = encoder.constructRenderPass({
-            label: "Particle Billboard",
-            pipeline,
-            bindings,
-            colorAttachments: [{
-                view: color_texture.obtainView(COLOR_VIEW),
-                loadOp: "load",
-                storeOp: "store",
-            }],
-            depthStencilAttachment: {
-                view: depth_view,
-                depthReadOnly: true,
-            },
-        });
-
-        render_pass.drawIndirect(resources.get(data.draw_args), 0);
-        render_pass.end();
-    });
-
-    data.camera = pass.read(camera);
-    data.pool = pass.read(pool);
-    data.draw_list = pass.read(draw_list);
-    data.emitter_database = pass.read(emitter_database);
-    data.draw_args = pass.read(draw_args);
-    data.depth = pass.read(depth);
-    data.color = pass.write(pass.read(color));
-
-    return data.color;
-}

package/src/shade/renderer/particles/sort/graph_particle_sort.d.ts

@@ -1,55 +0,0 @@
-/**
- * Frame-graph wiring for the RENDER order: the frame's alive list quantised by view depth and
- * scattered back-to-front, for a draw whose blending is order-dependent.
- *
- * reset -> histogram -> csdldf scan -> scatter. The two per-particle passes are indirect, sized by
- * the same `sim_dispatch_args` the coherence reset wrote from the GPU's own alive count, so nothing
- * here is sized by a host-side particle count.
- *
- * ## Every buffer here is the graph's
- *
- * Nothing the sort touches outlives the frame — the reset zeroes the bins and cursors, and the two
- * per-particle lists are written for every entry the scatter goes on to read. So the pass that
- * first writes each one declares it (a {@link BufferResourceDescriptor} in place of a handle) and
- * the graph allocates it at that pass and releases it at its last reader, into the pool every other
- * feature draws from. Two of them are a word per particle: at the renderer's default capacity that
- * is 4 MiB the system would otherwise reserve for a mode it may never be drawn in.
- *
- * None of them asks for a clear. The reset pass covers the histogram (header, padding and the bins
- * up to the whole `vec4` the last one lands in) and the cursor; `keys` and `sorted` are written by
- * the same indirect dispatch that later reads them, entry for entry.
- *
- * This is the ONLY producer of a depth ordering, and only {@link ParticleRenderMode.BILLBOARD} runs
- * it. It must never be confused with the simulation order the coherence passes build (`coherence/`):
- * that one groups by VM program so a wave runs one program, is camera-independent, and lives in a
- * different buffer with a different counter slot. Depth-sorting it would destroy the coherence;
- * running the padded coherence list through a blended draw would draw its sentinels.
- *
- * @param {object} params
- * @param {import("../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} params.graph
- * @param {number} params.camera graph handle of the camera uniform buffer
- * @param {number} params.emitter_database graph handle
- * @param {number} params.pool graph handle of the particle pool
- * @param {number} params.alive graph handle of this frame's compacted alive list
- * @param {number} params.counters graph handle of the atomic counters
- * @param {number} params.dispatch_args graph handle of one workgroup per live particle
- * @param {number} params.capacity pool capacity in particles — the length of the two lists below
- * @param {number} params.bucket_count depth bins the sort quantises into
- * @param {number} params.near view depth the first bin starts at
- * @param {number} params.far view depth the last bin ends at
- * @returns {number} graph handle of the sorted slot list
- */
-export function graph_particle_sort({ graph, camera, emitter_database, pool, alive, counters, dispatch_args, capacity, bucket_count, near, far, }: {
-    graph: import("../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
-    camera: number;
-    emitter_database: number;
-    pool: number;
-    alive: number;
-    counters: number;
-    dispatch_args: number;
-    capacity: number;
-    bucket_count: number;
-    near: number;
-    far: number;
-}): number;
-//# sourceMappingURL=graph_particle_sort.d.ts.map

package/src/shade/renderer/particles/sort/graph_particle_sort.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"graph_particle_sort.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/sort/graph_particle_sort.js"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH;IAbqG,KAAK,EAA/F,OAAO,8DAA8D,EAAE,UAAU;IAClE,MAAM,EAArB,MAAM;IACS,gBAAgB,EAA/B,MAAM;IACS,IAAI,EAAnB,MAAM;IACS,KAAK,EAApB,MAAM;IACS,QAAQ,EAAvB,MAAM;IACS,aAAa,EAA5B,MAAM;IACS,QAAQ,EAAvB,MAAM;IACS,YAAY,EAA3B,MAAM;IACS,IAAI,EAAnB,MAAM;IACS,GAAG,EAAlB,MAAM;IACJ,MAAM,CA0ElB"}