@woosh/meep-engine 3.21.0 → 3.22.0

package/src/shade/renderer/lightmap/bake/raster/graph_draw_lightmap_viz_buffer.js

@@ -46,10 +46,11 @@ const offsets =
 
 /**
  *
- * @param {FrameGraph} graph
- * @param {number} output Viz buffer texture
- * @param {GPUSceneContext} scene
- * @param {boolean} [force]
+ * @param {Object} options
+ * @param {FrameGraph} options.graph
+ * @param {number} options.output Viz buffer texture
+ * @param {GPUSceneContext} options.scene
+ * @param {boolean} [options.force]
  * @returns {number} written output ID
  */
 export function graph_draw_lightmap_viz_buffer({

package/src/shade/renderer/loader/gltf/tiny-gltf.d.ts

@@ -13,7 +13,7 @@ export class TinyGltf {
      * @readonly
      * @type {TextureFormat}
      */
-    static readonly "__#225@#UNCOMPRESSED_TARGET": TextureFormat;
+    static readonly "__#230@#UNCOMPRESSED_TARGET": TextureFormat;
     /**
      * @param {AssetManager} assetManager
      * @param {AssetRequestScope} [scope]

package/src/shade/renderer/material/GPUMaterialContext.d.ts

@@ -1,3 +1,12 @@
+/**
+ * @typedef {import("../../device/pipeline/RenderPipelineManager.js").RenderPipelineManager} RenderPipelineManager
+ * @typedef {import("../texture/GPUTextureContext.js").GPUTextureContext} GPUTextureContext
+ * @typedef {import("../texture/ShadeTexture.js").ShadeTexture} ShadeTexture
+ * @typedef {import("../texture/TextureManager.js").TextureManager} TextureManager
+ * @typedef {import("../texture/virtual/VirtualTextureManager.js").VirtualTextureManager} VirtualTextureManager
+ * @typedef {import("./ShadeMaterial.js").ShadeMaterial} ShadeMaterial
+ * @typedef {import("./StandardShadeMaterial.js").StandardShadeMaterial} StandardShadeMaterial
+ */
 export const MATERIAL_BIND_GROUP_VIZ_BUFFER: import("../../descriptor/binding/BindGroupLayoutDescriptor.js").BindGroupLayoutDescriptor;
 export const MATERIAL_BIND_GROUP_SCENE_DATA: import("../../descriptor/binding/BindGroupLayoutDescriptor.js").BindGroupLayoutDescriptor;
 /**
@@ -14,7 +23,7 @@ export class GPUMaterialContext {
      *
      * @return {StandardShadeMaterial}
      */
-    get source(): StandardShadeMaterial;
+    get source(): import("./StandardShadeMaterial.js").StandardShadeMaterial;
     /**
      * @type {GPURenderPipeline}
      */
@@ -60,4 +69,11 @@ export class GPUMaterialContext {
     obtainMaterialBindGroup(defaults: MaterialGPUDefaults): GPUBindGroup;
     #private;
 }
+export type RenderPipelineManager = import("../../device/pipeline/RenderPipelineManager.js").RenderPipelineManager;
+export type GPUTextureContext = import("../texture/GPUTextureContext.js").GPUTextureContext;
+export type ShadeTexture = import("../texture/ShadeTexture.js").ShadeTexture;
+export type TextureManager = import("../texture/TextureManager.js").TextureManager;
+export type VirtualTextureManager = import("../texture/virtual/VirtualTextureManager.js").VirtualTextureManager;
+export type ShadeMaterial = import("./ShadeMaterial.js").ShadeMaterial;
+export type StandardShadeMaterial = import("./StandardShadeMaterial.js").StandardShadeMaterial;
 //# sourceMappingURL=GPUMaterialContext.d.ts.map

package/src/shade/renderer/material/GPUMaterialContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUMaterialContext.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/material/GPUMaterialContext.js"],"names":[],"mappings":"AAkBA,uIAAyG;AAEzG,uIAA2G;AAqD3G;;GAEG;AACH;IAkNI;;;;OAIG;IACH,uCAFW,qCAAmC,EAyB7C;IAhOD;;;OAGG;IACH,oCAEC;IAED;;OAEG;IACH,4BAAS;IAET;;;OAGG;IACH,UAFU,oCAAmC,CAExB;IAQrB;;;OAGG;IACH,gCAEC;IAOD;;;OAGG;IACH,qCAEC;IAED;;;OAGG;IACH,cAFU,EAAE,CAEK;IAEjB;;;OAGG;IACH,wBAEC;IAwKD;;;;;OAKG;IACH,yHAoCC;IAGD,gBAEC;IAED;;;;OAIG;IACH,qEAOC;;CAEJ"}
+{"version":3,"file":"GPUMaterialContext.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/material/GPUMaterialContext.js"],"names":[],"mappings":"AAkBA;;;;;;;;GAQG;AAEH,uIAAyG;AAEzG,uIAA2G;AAqD3G;;GAEG;AACH;IAkNI;;;;OAIG;IACH,uCAFW,aAAa,GAAC,qBAAqB,EAyB7C;IAhOD;;;OAGG;IACH,yEAEC;IAED;;OAEG;IACH,4BAAS;IAET;;;OAGG;IACH,UAFU,IAAI,YAAY,EAAC,iBAAiB,CAAC,CAExB;IAQrB;;;OAGG;IACH,gCAEC;IAOD;;;OAGG;IACH,qCAEC;IAED;;;OAGG;IACH,cAFU,EAAE,CAEK;IAEjB;;;OAGG;IACH,wBAEC;IAwKD;;;;;OAKG;IACH,gBAJW,cAAc,oBACd,qBAAqB,qBACrB,qBAAqB,QAsC/B;IAGD,gBAEC;IAED;;;;OAIG;IACH,qEAOC;;CAEJ;oCAlXY,OAAO,gDAAgD,EAAE,qBAAqB;gCAC9E,OAAO,iCAAiC,EAAE,iBAAiB;2BAC3D,OAAO,4BAA4B,EAAE,YAAY;6BACjD,OAAO,8BAA8B,EAAE,cAAc;oCACrD,OAAO,6CAA6C,EAAE,qBAAqB;4BAC3E,OAAO,oBAAoB,EAAE,aAAa;oCAC1C,OAAO,4BAA4B,EAAE,qBAAqB"}

package/src/shade/renderer/material/GPUMaterialContext.js

@@ -16,6 +16,16 @@ import { material_gbuffer_vertex_shader_code } from "./standard/material_gbuffer
 import { SHADING_MATERIAL_RESOURCE_GROUP } from "./standard/SHADING_MATERIAL_RESOURCE_GROUP.js";
 import { standard_material_to_struct } from "./standard_material_to_struct.js";
 
+/**
+ * @typedef {import("../../device/pipeline/RenderPipelineManager.js").RenderPipelineManager} RenderPipelineManager
+ * @typedef {import("../texture/GPUTextureContext.js").GPUTextureContext} GPUTextureContext
+ * @typedef {import("../texture/ShadeTexture.js").ShadeTexture} ShadeTexture
+ * @typedef {import("../texture/TextureManager.js").TextureManager} TextureManager
+ * @typedef {import("../texture/virtual/VirtualTextureManager.js").VirtualTextureManager} VirtualTextureManager
+ * @typedef {import("./ShadeMaterial.js").ShadeMaterial} ShadeMaterial
+ * @typedef {import("./StandardShadeMaterial.js").StandardShadeMaterial} StandardShadeMaterial
+ */
+
 export const MATERIAL_BIND_GROUP_VIZ_BUFFER = g_buffer_viz_resources.generateBindGroupLayoutDescriptor();
 
 export const MATERIAL_BIND_GROUP_SCENE_DATA = g_buffer_scene_resources.generateBindGroupLayoutDescriptor();

package/src/shade/renderer/material/GPUMaterialManager.d.ts

@@ -25,13 +25,19 @@ export class GPUMaterialManager {
     get version(): number;
     /**
      * Render all materials using visibility buffer
-     * @param {FrameGraph} graph
-     * @param {GPUViewContext} view
-     * @param {number} texture_viz_mesh
-     * @param {number} texture_viz_triangle
+     * @param {Object} options
+     * @param {FrameGraph} options.graph
+     * @param {GPUViewContext} options.view
+     * @param {number} options.texture_viz_mesh
+     * @param {number} options.texture_viz_triangle
      * @returns {{g_pbr: number, g_normal: number, g_albedo: number, g_emissive: number}} updated g-buffer
      */
-    graph_viz_render({ graph, view, texture_viz_mesh, texture_viz_triangle, }: FrameGraph): {
+    graph_viz_render({ graph, view, texture_viz_mesh, texture_viz_triangle, }: {
+        graph: FrameGraph;
+        view: GPUViewContext;
+        texture_viz_mesh: number;
+        texture_viz_triangle: number;
+    }): {
         g_pbr: number;
         g_normal: number;
         g_albedo: number;
@@ -50,6 +56,14 @@ export class GPUMaterialManager {
     update(ctx: ShadeGPUCommandContext): void;
     #private;
 }
+export type GPUViewContext = import("../view/GPUViewContext.js").GPUViewContext;
+export type FrameGraph = import("../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
+export type ShadeGPUCommandContext = import("../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext;
+export type RenderPipelineManager = import("../../device/pipeline/RenderPipelineManager.js").RenderPipelineManager;
+export type BindGroupManager = import("../binding/BindGroupManager.js").BindGroupManager;
+export type TextureManager = import("../texture/TextureManager.js").TextureManager;
+export type VirtualTextureManager = import("../texture/virtual/VirtualTextureManager.js").VirtualTextureManager;
+export type ShadeMaterial = import("./ShadeMaterial.js").ShadeMaterial;
 import { GPUMaterialContext } from "./GPUMaterialContext.js";
 import { GPUSingleTypeTable } from "../buffer/table/single/GPUSingleTypeTable.js";
 //# sourceMappingURL=GPUMaterialManager.d.ts.map

package/src/shade/renderer/material/GPUMaterialManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUMaterialManager.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/material/GPUMaterialManager.js"],"names":[],"mappings":"AA8JA;IAmEI;;;;;;;OAOG;IACH,wKAwCC;IA5GD;;;OAGG;IACH,UAFU,mBAAmB,kBAAkB,CAAC,CAE3B;IA2BrB;;;OAGG;IACH,yCAEC;IAID;;;OAGG;IACH,sBAEC;IA8JD;;;;;;;OAOG;IACH,wFAFa;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAC,CAqNnF;IAED;;;;OAIG;IACH,iCAFa,kBAAkB,CAqB9B;IAED;;;OAGG;IACH,0CAEC;;CAEJ;mCAvlBM,yBAAyB;mCAjBG,8CAA8C"}
+{"version":3,"file":"GPUMaterialManager.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/material/GPUMaterialManager.js"],"names":[],"mappings":"AA4KA;IAmEI;;;;;;;OAOG;IACH,yCALW,cAAc,oBACd,qBAAqB,YACrB,gBAAgB,qBAChB,qBAAqB,EA0C/B;IA5GD;;;OAGG;IACH,UAFU,IAAI,aAAa,EAAE,kBAAkB,CAAC,CAE3B;IA2BrB;;;OAGG;IACH,yCAEC;IAID;;;OAGG;IACH,sBAEC;IA8JD;;;;;;;;OAQG;IACH;QAN+B,KAAK,EAAzB,UAAU;QACc,IAAI,EAA5B,cAAc;QACE,gBAAgB,EAAhC,MAAM;QACU,oBAAoB,EAApC,MAAM;QACJ;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAC,CAqNnF;IAED;;;;OAIG;IACH,iBAHW,aAAa,GACX,kBAAkB,CAqB9B;IAED;;;OAGG;IACH,YAFW,sBAAsB,QAIhC;;CAEJ;6BA/lBY,OAAO,2BAA2B,EAAE,cAAc;yBAIlD,OAAO,2DAA2D,EAAE,UAAU;qCAC9E,OAAO,wCAAwC,EAAE,sBAAsB;oCACvE,OAAO,gDAAgD,EAAE,qBAAqB;+BAC9E,OAAO,gCAAgC,EAAE,gBAAgB;6BACzD,OAAO,8BAA8B,EAAE,cAAc;oCACrD,OAAO,6CAA6C,EAAE,qBAAqB;4BAC3E,OAAO,oBAAoB,EAAE,aAAa;mCAjBhD,yBAAyB;mCAjBG,8CAA8C"}

package/src/shade/renderer/material/GPUMaterialManager.js

@@ -30,6 +30,20 @@ import { PIXEL_TEXTURE_ORM } from "./PIXEL_TEXTURE_ORM.js";
 import { standard_material_to_struct } from "./standard_material_to_struct.js";
 import { TransparencyMode } from "./TransparencyMode.js";
 
+/**
+ * @typedef {import("../view/GPUViewContext.js").GPUViewContext} GPUViewContext
+ */
+
+/**
+ * @typedef {import("../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} FrameGraph
+ * @typedef {import("../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext} ShadeGPUCommandContext
+ * @typedef {import("../../device/pipeline/RenderPipelineManager.js").RenderPipelineManager} RenderPipelineManager
+ * @typedef {import("../binding/BindGroupManager.js").BindGroupManager} BindGroupManager
+ * @typedef {import("../texture/TextureManager.js").TextureManager} TextureManager
+ * @typedef {import("../texture/virtual/VirtualTextureManager.js").VirtualTextureManager} VirtualTextureManager
+ * @typedef {import("./ShadeMaterial.js").ShadeMaterial} ShadeMaterial
+ */
+
 class MaterialGPUDefaults {
     /**
      * Wired when the graphics context carries a virtual texture system;
@@ -370,10 +384,11 @@ export class GPUMaterialManager {
 
     /**
      * Render all materials using visibility buffer
-     * @param {FrameGraph} graph
-     * @param {GPUViewContext} view
-     * @param {number} texture_viz_mesh
-     * @param {number} texture_viz_triangle
+     * @param {Object} options
+     * @param {FrameGraph} options.graph
+     * @param {GPUViewContext} options.view
+     * @param {number} options.texture_viz_mesh
+     * @param {number} options.texture_viz_triangle
      * @returns {{g_pbr: number, g_normal: number, g_albedo: number, g_emissive: number}} updated g-buffer
      */
     graph_viz_render({

package/src/shade/renderer/material/ShadeMaterial.d.ts

@@ -39,7 +39,7 @@ export class ShadeMaterial {
     /**
      * @returns {ShadeTexture[]}
      */
-    get textures(): ShadeTexture[];
+    get textures(): import("../texture/ShadeTexture.js").ShadeTexture[];
     /**
      * @readonly
      * @type {boolean}
@@ -47,6 +47,7 @@ export class ShadeMaterial {
     readonly isShadeMaterial: boolean;
     #private;
 }
+export type ShadeTexture = import("../texture/ShadeTexture.js").ShadeTexture;
 import { ShadeDrawMode } from "./ShadeDrawMode.js";
 import { ShadeDrawSide } from "./ShadeDrawSide.js";
 //# sourceMappingURL=ShadeMaterial.d.ts.map

package/src/shade/renderer/material/ShadeMaterial.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ShadeMaterial.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/material/ShadeMaterial.js"],"names":[],"mappings":"AAMA;IAII,aAAU;IAEV;;;OAGG;IACH,mBAFU,MAAM,CAE4B;IAE5C;;;OAGG;IACH,WAFU,aAAa,GAAC,MAAM,CAEM;IAGpC;;;;OAIG;IACH,WAFU,aAAa,GAAC,MAAM,CAEE;IAEhC,iBAEC;IAED;;;;;OAKG;IACH,YAFW,aAAa,QAOvB;IAED;;;OAGG;IACH,SAFa,aAAa,CAQzB;IAED;;;;OAIG;IACH,cAHW,aAAa,GACX,OAAO,CAOnB;IAED,eAGC;IAED;;OAEG;IACH,+BAEC;IAGL;;;OAGG;IACH,0BAFU,OAAO,CAEsB;;CANtC;8BApF6B,oBAAoB;8BACpB,oBAAoB"}
+{"version":3,"file":"ShadeMaterial.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/material/ShadeMaterial.js"],"names":[],"mappings":"AAUA;IAII,aAAU;IAEV;;;OAGG;IACH,mBAFU,MAAM,CAE4B;IAE5C;;;OAGG;IACH,WAFU,aAAa,GAAC,MAAM,CAEM;IAGpC;;;;OAIG;IACH,WAFU,aAAa,GAAC,MAAM,CAEE;IAEhC,iBAEC;IAED;;;;;OAKG;IACH,YAFW,aAAa,QAOvB;IAED;;;OAGG;IACH,SAFa,aAAa,CAQzB;IAED;;;;OAIG;IACH,cAHW,aAAa,GACX,OAAO,CAOnB;IAED,eAGC;IAED;;OAEG;IACH,oEAEC;IAGL;;;OAGG;IACH,0BAFU,OAAO,CAEsB;;CANtC;2BAnFY,OAAO,4BAA4B,EAAE,YAAY;8BALhC,oBAAoB;8BACpB,oBAAoB"}

package/src/shade/renderer/material/ShadeMaterial.js

@@ -2,6 +2,10 @@ import { ShadeDrawMode } from "./ShadeDrawMode.js";
 import { ShadeDrawSide } from "./ShadeDrawSide.js";
 import { TransparencyMode } from "./TransparencyMode.js";
 
+/**
+ * @typedef {import("../texture/ShadeTexture.js").ShadeTexture} ShadeTexture
+ */
+
 let id_counter = 0;
 
 export class ShadeMaterial {

package/src/shade/renderer/material/StandardShadeMaterial.d.ts

@@ -1,3 +1,7 @@
+/**
+ * @typedef {import("../texture/ShadeTexture.js").ShadeTexture} ShadeTexture
+ * @typedef {import("../texture/virtual/VirtualTextureStack.js").VirtualTextureStack} VirtualTextureStack
+ */
 export class StandardShadeMaterial extends ShadeMaterial {
     /**
      * If there is transparency, it is encoded into Alpha channel (RGBA)
@@ -97,6 +101,8 @@ export class StandardShadeMaterial extends ShadeMaterial {
      */
     readonly isStandardShadeMaterial: boolean;
 }
+export type ShadeTexture = import("../texture/ShadeTexture.js").ShadeTexture;
+export type VirtualTextureStack = import("../texture/virtual/VirtualTextureStack.js").VirtualTextureStack;
 import { ShadeMaterial } from "./ShadeMaterial.js";
 import { Color } from "../../../core/color/Color.js";
 import LinearModifier from "../../../core/model/stat/LinearModifier.js";

package/src/shade/renderer/material/StandardShadeMaterial.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"StandardShadeMaterial.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/material/StandardShadeMaterial.js"],"names":[],"mappings":"AAOA;IACI;;;OAGG;IACH,6BAAe;IAEf;;;OAGG;IACH,eAFU,KAAK,CAEsB;IAErC;;OAEG;IACH,6BAAe;IAEf;;;;;;OAMG;IACH,0BAAY;IAEZ;;OAEG;IACH,+BAAiB;IAEjB;;;;;;;;OAQG;IACH,UAFU,sBAAoB,SAAS,CAE9B;IAET;;;OAGG;IACH,kBAFU,MAAM,CAEK;IAErB;;;OAGG;IACH,iBAFU,MAAM,CAEI;IAEpB;;;;;;;;OAQG;IACH,qBAFU,MAAM,CAEQ;IAExB;;;;;;OAMG;IACH,YAFU,MAAM,CAEC;IAEjB;;;OAGG;IACH,iBAFU,KAAK,CAE4B;IAE3C;;;OAGG;IACH,iBAFU,cAAc,CAEmB;IAW3C;;;;;OAKG;IACH,YAFW,qBAAqB,QAmB/B;IAED;;;OAGG;IACH,SAFa,qBAAqB,CAQjC;IAaD;;;;OAIG;IACH,cAHW,qBAAqB,GACnB,OAAO,CA8BnB;IAGL;;;OAGG;IACH,kCAFU,OAAO,CAEsC;CANtD;8BApL6B,oBAAoB;sBAJ5B,8BAA8B;2BACzB,4CAA4C"}
+{"version":3,"file":"StandardShadeMaterial.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/material/StandardShadeMaterial.js"],"names":[],"mappings":"AAOA;;;GAGG;AAEH;IACI;;;OAGG;IACH,gBAFU,YAAY,CAEP;IAEf;;;OAGG;IACH,eAFU,KAAK,CAEsB;IAErC;;OAEG;IACH,gBAFU,YAAY,CAEP;IAEf;;;;;;OAMG;IACH,aAFU,YAAY,CAEV;IAEZ;;OAEG;IACH,kBAFU,YAAY,CAEL;IAEjB;;;;;;;;OAQG;IACH,UAFU,mBAAmB,GAAC,SAAS,CAE9B;IAET;;;OAGG;IACH,kBAFU,MAAM,CAEK;IAErB;;;OAGG;IACH,iBAFU,MAAM,CAEI;IAEpB;;;;;;;;OAQG;IACH,qBAFU,MAAM,CAEQ;IAExB;;;;;;OAMG;IACH,YAFU,MAAM,CAEC;IAEjB;;;OAGG;IACH,iBAFU,KAAK,CAE4B;IAE3C;;;OAGG;IACH,iBAFU,cAAc,CAEmB;IAW3C;;;;;OAKG;IACH,YAFW,qBAAqB,QAmB/B;IAED;;;OAGG;IACH,SAFa,qBAAqB,CAQjC;IAaD;;;;OAIG;IACH,cAHW,qBAAqB,GACnB,OAAO,CA8BnB;IAGL;;;OAGG;IACH,kCAFU,OAAO,CAEsC;CANtD;2BAtLY,OAAO,4BAA4B,EAAE,YAAY;kCACjD,OAAO,2CAA2C,EAAE,mBAAmB;8BAJtD,oBAAoB;sBAJ5B,8BAA8B;2BACzB,4CAA4C"}

package/src/shade/renderer/material/StandardShadeMaterial.js

@@ -5,6 +5,11 @@ import { optional_equality } from "../../../core/model/object/optional_equality.
 import { optional_hash } from "../../../core/model/object/optional_hash.js";
 import { ShadeMaterial } from "./ShadeMaterial.js";
 
+/**
+ * @typedef {import("../texture/ShadeTexture.js").ShadeTexture} ShadeTexture
+ * @typedef {import("../texture/virtual/VirtualTextureStack.js").VirtualTextureStack} VirtualTextureStack
+ */
+
 export class StandardShadeMaterial extends ShadeMaterial {
     /**
      * If there is transparency, it is encoded into Alpha channel (RGBA)

package/src/shade/renderer/material/resident/GPUResidentMaterialContext.d.ts

@@ -52,7 +52,19 @@ export class GPUResidentMaterialContext {
     destroy(): void;
     #private;
 }
+export type GraphicsContext = import("../../GraphicsContext.js").GraphicsContext;
+export type Scene = import("../../scene/Scene.js").Scene;
+export type ShadeTexture = import("../../texture/ShadeTexture.js").ShadeTexture;
+export type ShadeMaterial = import("../ShadeMaterial.js").ShadeMaterial;
+export type StandardShadeMaterial = import("../StandardShadeMaterial.js").StandardShadeMaterial;
 import { GPUTextureContext } from "../../texture/GPUTextureContext.js";
+/**
+ * @typedef {import("../../GraphicsContext.js").GraphicsContext} GraphicsContext
+ * @typedef {import("../../scene/Scene.js").Scene} Scene
+ * @typedef {import("../../texture/ShadeTexture.js").ShadeTexture} ShadeTexture
+ * @typedef {import("../ShadeMaterial.js").ShadeMaterial} ShadeMaterial
+ * @typedef {import("../StandardShadeMaterial.js").StandardShadeMaterial} StandardShadeMaterial
+ */
 declare class MaterialInfo {
     id: number;
     /**

package/src/shade/renderer/material/resident/GPUResidentMaterialContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUResidentMaterialContext.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/material/resident/GPUResidentMaterialContext.js"],"names":[],"mappings":"AAuDA,sDAAuD;AAEvD,wDAAyD;AAEzD,+DAAiJ;AAEjJ,+DAA+I;AAE/I;IA8GI;;;;OAIG;IACH,0DAoCC;IA3HD;;;OAGG;IACH,6BAEC;IAQD;;;OAGG;IACH,kCAEC;IAQD;;;OAGG;IACH,yCAEC;IAED;;;OAGG;IACH,kCAIC;IA0GD;;;;OAIG;IACH,0CAFa,YAAY,CAIxB;IAgBD;;;;OAIG;IACH,uCAFa,WAAW,CAIvB;IAGD,uBA+HC;IAED,wBA2EC;IAED;;;OAGG;IACH,2CAgBC;IAoCD,eASC;IAGD,gBAGC;;CACJ;kCA7hBiC,oCAAoC;AAOtE;IACI,WAAM;IAEN;;OAEG;IACH,8BAAO;IAEP;;OAEG;IACH,gBAFU,WAAW,CAEP;IAEd;;OAEG;IACH,aAFU,WAAW,CAEV;IAEX;;OAEG;IACH,gBAFU,WAAW,CAEP;IACd;;OAEG;IACH,kBAFU,WAAW,CAEL;CACnB;AAED;IACI,WAAO;IAEP;;OAEG;IACH,qBAAO;CACV"}
+{"version":3,"file":"GPUResidentMaterialContext.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/material/resident/GPUResidentMaterialContext.js"],"names":[],"mappings":"AA+DA,sDAAuD;AAEvD,wDAAyD;AAEzD,+DAAiJ;AAEjJ,+DAA+I;AAE/I;IA8GI;;;;OAIG;IACH,yCAFW,eAAe,EAsCzB;IA3HD;;;OAGG;IACH,6BAEC;IAQD;;;OAGG;IACH,kCAEC;IAQD;;;OAGG;IACH,yCAEC;IAED;;;OAGG;IACH,kCAIC;IA0GD;;;;OAIG;IACH,0BAHW,aAAa,GACX,YAAY,CAIxB;IAgBD;;;;OAIG;IACH,wBAHW,YAAY,GACV,WAAW,CAIvB;IAGD,uBA+HC;IAED,wBA2EC;IAED;;;OAGG;IACH,8BAFW,KAAK,QAkBf;IAoCD,eASC;IAGD,gBAGC;;CACJ;8BA7hBY,OAAO,0BAA0B,EAAE,eAAe;oBAClD,OAAO,sBAAsB,EAAE,KAAK;2BACpC,OAAO,+BAA+B,EAAE,YAAY;4BACpD,OAAO,qBAAqB,EAAE,aAAa;oCAC3C,OAAO,6BAA6B,EAAE,qBAAqB;kCAZtC,oCAAoC;AAOtE;;;;;;GAMG;AAEH;IACI,WAAM;IAEN;;OAEG;IACH,QAFU,qBAAqB,CAExB;IAEP;;OAEG;IACH,gBAFU,WAAW,CAEP;IAEd;;OAEG;IACH,aAFU,WAAW,CAEV;IAEX;;OAEG;IACH,gBAFU,WAAW,CAEP;IACd;;OAEG;IACH,kBAFU,WAAW,CAEL;CACnB;AAED;IACI,WAAO;IAEP;;OAEG;IACH,QAFU,YAAY,CAEf;CACV"}

package/src/shade/renderer/material/resident/GPUResidentMaterialContext.js

@@ -16,6 +16,14 @@ import { WHITE_PIXEL_TEXTURE } from "../../texture/util/WHITE_PIXEL_TEXTURE.js";
 import { INDIRECT_MATERIAL_ARRAY_TYPE } from "./INDIRECT_MATERIAL_ARRAY_TYPE.js";
 import { INDIRECT_MATERIAL_STRUCT } from "./INDIRECT_MATERIAL_STRUCT.js";
 
+/**
+ * @typedef {import("../../GraphicsContext.js").GraphicsContext} GraphicsContext
+ * @typedef {import("../../scene/Scene.js").Scene} Scene
+ * @typedef {import("../../texture/ShadeTexture.js").ShadeTexture} ShadeTexture
+ * @typedef {import("../ShadeMaterial.js").ShadeMaterial} ShadeMaterial
+ * @typedef {import("../StandardShadeMaterial.js").StandardShadeMaterial} StandardShadeMaterial
+ */
+
 class MaterialInfo {
     id = 0
 

package/src/shade/renderer/particles/DESIGN.md

@@ -10,7 +10,8 @@ the decision to spawn is the GPU's.
 
 - Single simulation execution shader (data-driven VM, not one-pipeline-per-effect).
 - Projection modes: camera-facing billboard (+ velocity-stretched, axis-locked, world-oriented).
-- Depth sorting for correct transparency, built on the `csdldf` prefix scan.
+- Order-independent transparency: the particles are a side channel of the AVBOIT pipeline, so they
+  composite against the transparent meshes with no depth ordering of any kind.
 - Node-based composition → shader VM (compile graph → bytecode).
 - Frustum culling of spawning (optional, flagged, sleep-when-culled + bounded catch-up).
 - Flipbooks (atlas sub-rect + frame grid).
@@ -20,9 +21,9 @@ the decision to spawn is the GPU's.
 - Scene-node / bone attachment: an emitter **is** a `Node3D`; its world matrix is its row of the
   scene's `transforms` table, composed by the GPU hierarchy pass.
 - Distinct per-particle lifecycle: **no** built-in age/position — the schema + program define state.
-- Billboard renderer reuses engine shader chunks incl. lighting (forward-shaded, optional per emitter).
+- Billboard drawing reuses engine shader chunks incl. lighting (forward-shaded, optional per emitter).
 - Blend modes (alpha + additive) via a **single** premultiplied blend setup.
-- Authored curves and RGB/RGBA gradients compiled into arithmetic for simulation.
+- Authored curves and RGB/RGBA gradients compiled into arithmetic for simulation.
 - Spawning decided on the GPU, per emitter, with the CPU able to ask for bursts through the same path.
 - No per-frame allocation on the CPU beyond the frame graph's own records.
 
@@ -45,9 +46,12 @@ runtime GPU: particle pool (array<u32>, uniform stride) + alive/dead lists + cou
              ├─ simulate (VM UPDATE program) ── update → (kill|orphan→dead | keep→alive_new)
              ├─ bucket (histogram → csdldf scan → scatter)  ── alive → program-coherent sim list
              ├─ bounds (per particle → per emitter box, published to the state row)
-             ├─ build indirect (dispatch + draw args)
-             ├─ sort  (histogram → csdldf scan → scatter)    [render order]
-             └─ render (instanced billboard quads, forward + optional lighting + soft depth)
+             └─ build indirect (dispatch + draw args)
+
+             the AVBOIT transparency pipeline then draws the alive list through the side channel:
+             ├─ occupancy (per emitter box → depth slices)
+             ├─ splat     (extinction into the voxel volume)
+             └─ draw      (instanced billboard quads → the four accumulators)
 ```
 
 ### Particle storage — single shared pool, uniform stride
@@ -69,11 +73,11 @@ bucketing pass built from `alive_current` → run UPDATE → kill pushes to `dea
 
 **The loop is strictly GPU-driven.** The build-indirect pass snapshots the padded length of the
 coherence list into `counters[ALIVE_IN]` and writes the indirect dispatch args next frame's simulate
-consumes (`dispatchWorkgroupsIndirect`) plus the indirect draw args this frame's render consumes
+consumes (`dispatchWorkgroupsIndirect`) plus the indirect draw args this frame's draws consume
 (`drawIndirect`, sized by the *unpadded* alive count); simulate bound-checks against the ALIVE_IN
-snapshot. The sort's per-particle passes take the dispatch the bucket reset writes from the alive
-count. Sizing any of this from a CPU readback is a correctness bug, not a shortcut: the readback is
-inevitably stale, so a growing population orphans the tail of the alive list (slots leak into limbo)
+snapshot. The bounds pass takes the dispatch the bucket reset writes from the alive count. Sizing
+any of this from a CPU readback is a correctness bug, not a shortcut: the readback is inevitably
+stale, so a growing population orphans the tail of the alive list (slots leak into limbo)
 and a shrinking one re-simulates stale entries — double-freeing slots so two live particles later
 share one record. The emit pass's dead-list pop guards against wrapped counters
 (`old == 0 || old > capacity`), so racing an exhausted pool drops spawns cleanly instead of handing
@@ -159,7 +163,7 @@ recursion, no data-dependent jumps — conditionals are predicated via CMP/SELEC
   Word 0 packs the opcode (bits 0..7), the lane count (8..10), each source's `VM_KIND` (two bits per
   slot at 16..21) and the destination slot (24..31). A source word means what its kind says: `REG`
   is a base slot plus a swizzle, `IMM` is an `f32` bit pattern read in every lane, and `NONE` is a
-  raw field the opcode reads for itself (attribute word-offset+comp / builtin id /
+  raw field the opcode reads for itself (attribute word-offset+comp / builtin id /
   pool index).
 - Constant pool: `array<vec4f>` per program, referenced by `LOAD_CONST`.
 - Two entry sections per program: **INIT** and **UPDATE** (offsets in the emitter record). INIT
@@ -210,13 +214,13 @@ A core `NodeGraph` holds particle nodes (ports + parameters) for INIT and UPDATE
 2. lowers each node to VM ops (nodes emit via a small builder that allocates result registers),
 3. linear-scan register allocation with liveness,
 4. interns constants into the pool,
-5. resolves attribute references,
-6. emits `Program { init, update, constants, reg_count, attributes }`.
+5. resolves attribute references,
+6. emits `Program { init, update, constants, reg_count, attributes }`.
 
 Standard node library: constants, attribute get/set, arithmetic/vector/math, random (uniform/sphere/
-disk/cone), authored curves and RGB/RGBA gradients, noise (curl), integrate, gravity, emit-shapes,
-compare/select, kill-if. Curves and gradients expand into graph nodes that emit ordinary VM
-arithmetic; no animation-table binding or sampling opcode is needed.
+disk/cone), authored curves and RGB/RGBA gradients, noise (curl), integrate, gravity, emit-shapes,
+compare/select, kill-if. Curves and gradients expand into graph nodes that emit ordinary VM
+arithmetic; no animation-table binding or sampling opcode is needed.
 
 ### Emitters are scene nodes
 
@@ -251,7 +255,7 @@ was staged from. An author who edits an emitter says so the way they say it for
 
 One `emitters` table (CPU-managed, low churn). Row = `PARTICLE_EMITTER_STRUCT`: program
 offsets+lengths, constant-pool offset, seed, spawn rate, **node** (transforms row), **generation**,
-flags (lighting/soft/sort/cull/blend/projection), render binding (attr offsets for
+flags (lighting/soft/cull/blend/projection), render binding (attr offsets for
 position/size/color/rotation/frame/velocity), atlas region + flipbook grid, and the program id
 the coherence pass buckets on. The atlas region is resolved, not authored: the emitter names an
 image and the system packs it, the way `ShaderManager` packs the old engine's sprites, so a repack
@@ -484,45 +488,47 @@ programs again. Padding entries carry `PARTICLE_SIM_PAD_SLOT` and the simulate s
 It is an **indirection** list. Particle records never move: slots are referenced by the dead list and
 across frames, so relocating a record would leave both pointing at the wrong particle.
 
-The three-phase shape is the depth sort's, with the padding added: histogram (atomic per bucket) →
+It is a counting sort in three phases, with the padding added: histogram (atomic per bucket) →
 round each bin up to a whole workgroup → `graph_prefix_scan_csdldf` (reused as-is — the one scan here
 whose only cross-workgroup wait is CSDLDF's bounded spin-then-fallback) → scatter → fill the tails
 with the sentinel. Nothing reads back to the CPU; the only host-supplied number is the bucket count,
 which is static topology.
 
-**Render order** (`sort/`) — per-frame, particles sorted back-to-front by view depth so
-premultiplied transparency composites correctly. Counting sort on a quantised view depth
-(`PARTICLE_SORT_BUCKET_COUNT` bins over `GPUParticleSystem#sort_depth_range`): histogram from the
-camera uniform's view matrix, `graph_prefix_scan_csdldf` the bin counts to offsets, scatter (index
-payload). The sorted index list feeds the instanced draw. Both per-particle passes are bounded by
-the alive counter and dispatched by the args the bucket reset wrote from it.
-
-Every buffer the sort touches is the graph's, made at the pass that writes it and released after the
-draw, so a system drawn through AVBOIT — which records none of these passes — allocates none of it.
+**There is no render order.** The draws walk the alive list exactly as compaction left it, because
+everything downstream of them is a sum: the AVBOIT volume accumulates extinction and the four
+accumulators accumulate colour, coverage and emission, and no arrangement of the instances changes
+any of those. So the system spends nothing on ordering: no key pass, no scan, no scatter, and no
+per-particle key and index lists to hold them in.
 
-Reordering the render list for program coherence would break transparency; depth-sorting the
-simulation list would destroy the coherence. They share no buffer and no counter slot —
-`PARTICLE_COUNTER.SORTED` belongs to the render order, `SIM_PADDED` to the simulation order.
+The two lists are still distinct and must stay so: the simulation list is permuted and padded with
+sentinels, so drawing it would draw them, and depth-ordering it would destroy the coherence. They
+share no buffer and no counter slot — `SIM_PADDED` is the simulation list's length, `ALIVE` the
+draw's.
 
 ### Rendering
 
-One render pipeline, one blend state = premultiplied: `color: (one, one-minus-src-alpha)`,
-`alpha: (one, one-minus-src-alpha)`. Additive vs. alpha is chosen by the shader emitting premultiplied
-RGB with alpha 0 (additive) vs. alpha a (normal) — GPU-driven, no pipeline switch. A 6-vertex quad is
-expanded per instance (billboard/velocity-stretch/axis-lock/world modes). Fragment: sample atlas
-(region + flipbook frame), optional forward lighting via `chunk_shade_standard_material_direct` +
-IBL, optional soft-depth fade. Depth-tested, no depth write. Draws into the HDR color target.
-Soft-depth fading scales both RGB and alpha for premultiplied inputs; straight-alpha and additive
-inputs have alpha scaled before premultiplication. Both draw paths share `particle_fade_color`.
-
-### Drawing under the renderer: an AVBOIT side channel
-
-Under `Renderer` the particles are not drawn by the billboard pass above. They go through the AVBOIT
-transparency pipeline (`rasterize/native/avboit/`) as a **side channel** — the contract in
-`AVBOITSideChannel.js` — so they composite order-independently with the transparent meshes and
-against the opaque scene, through the same volume and the same accumulators. Quads are not packed
-into meshlets; the orchestrator asks the channel for its contribution at the three points where the
-meshlet buckets have just made theirs:
+A 6-vertex quad is expanded per instance (billboard/velocity-stretch/axis-lock/world modes) by
+`chunk_particle_billboard_vertex`. Fragment: sample atlas (region + flipbook frame), optional forward
+lighting via `chunk_shade_standard_material_direct` + IBL, optional soft-depth fade. Soft-depth
+fading scales both RGB and alpha for premultiplied inputs; straight-alpha and additive inputs have
+alpha scaled before premultiplication.
+
+Additive vs. alpha is never a pipeline switch: the shader emits premultiplied RGB with alpha 0
+(additive) or alpha a (normal), so one setup covers both and the choice stays per particle and
+GPU-driven. Under AVBOIT that choice picks which accumulators the fragment writes; in the blended
+pipeline `shaders/shader_particle_render.js` builds it is one blend state,
+`(one, one-minus-src-alpha)` on both channels. That pipeline is not this system's — it is what
+`GPUParticularRenderer` draws `particular`'s CPU-simulated particles with, over a draw list it sorts
+back to front on the CPU — but it shares this vertex stage, this atlas and flipbook math, and
+`particle_fade_color`, so a sprite looks the same whichever draws it.
+
+### Drawing: an AVBOIT side channel
+
+The particles are drawn by the AVBOIT transparency pipeline (`rasterize/native/avboit/`) as a
+**side channel** — the contract in `AVBOITSideChannel.js` — so they composite order-independently
+with the transparent meshes and against the opaque scene, through the same volume and the same
+accumulators. Quads are not packed into meshlets; the orchestrator asks the channel for its
+contribution at the three points where the meshlet buckets have just made theirs:
 
 1. **occupancy** (`shader_particle_avboit_occupancy`): one thread per emitter row, the emitter's
    measured box (the culling box, off the state row) as a view-depth interval, dilated and OR-ed
@@ -549,12 +555,11 @@ meshlet buckets have just made theirs:
    scene behind already has it. That accumulator is the one addition to AVBOIT's resolve for this.
    The whole decision is `chunk_particle_avboit_contribution`, and it is spec'd on the emulator.
 
-No sort: the volume makes order irrelevant, so this path reads the alive list and the draw args
-straight from `simulate`. The billboard vertex stage is one chunk
-(`chunk_particle_billboard_vertex`) shared by the standalone renderer and both AVBOIT passes.
-`GPUParticleSystem` implements the three methods; `Renderer.feature_particles_enabled` runs
-`simulate` before the transparency pass and hands the system to the orchestrator. MBOIT is legacy
-and gets no particle path.
+All three read the alive list and the draw args straight from `simulate`; the vertex stage is one
+chunk (`chunk_particle_billboard_vertex`), shared by the splat, the draw and the blended pipeline
+`particular` uses. `GPUParticleSystem` implements the three methods; `Renderer.feature_particles_enabled`
+runs `execute` before the transparency pass and hands the system to the orchestrator. MBOIT is legacy
+and gets no particle path, so under it the particles simulate and are not drawn.
 
 ### The ECS: `ParticleEffect` + `Transform64`
 
@@ -640,11 +645,20 @@ pool, alive lists, dead list, counters, the coherence list, simulate's indirect
 emitter database (both tables), the packed program buffer, the spawn-command ring and the warm-up
 queue — and grows the ones that depend on the emitter set inside `execute`. Everything else a frame
 touches is the frame graph's, declared by the pass that first writes it: the bucketing scratch, the
-whole depth sort, the draw args, the spawn counts and the wide register file. The
-default atlas is a 1x1 white texel. `execute({graph, camera, scene_database, color, depth, dt})`
-sweeps the scene, pushes what changed (on a command context opened only when something needs
-one), and records the whole frame through `graph_particles`, returning the colour handle after
-the draw. An integrator does not encode a particle pass by hand.
+draw args, the spawn counts and the wide register file. The default atlas is a 1x1 white texel.
+`execute({graph, camera, scene_database, dt})` sweeps the scene, pushes what changed (on a command
+context opened only when something needs one), and records the simulation through `graph_particles`,
+returning the handles the side channels draw from. It touches no colour target — the drawing is the
+transparency pipeline's — and an integrator does not encode a particle pass by hand.
+
+The frame reads nothing back, but a HUD or an inspector wants to: `read_stats()` copies the counters
+and the dispatch args out and returns them named — alive, free, the spawn budget, both list lengths
+and the workgroups the next simulate will launch. That is the whole of the readback, and the only
+reason the dispatch args carry `COPY_SRC` (the counters and the coherence list carry it to be copied
+forward when they grow). Nothing it returns may size a pass: the numbers describe a frame already
+submitted, and what sizing from a stale count costs is set out under the finalize pass above. The
+draw args are not among them and cannot be — they are the graph's, released after the last draw that
+reads them — and their instance count is the alive count regardless.
 
 ## File layout
 
@@ -686,7 +700,7 @@ src/shade/renderer/particles/
   shaders/shader_particle_emit.js            per-newborn INIT, sized by the scan
   shaders/shader_particle_simulate.js        per-particle UPDATE + compaction + orphan kill
   shaders/shader_particle_finalize.js        reset counters (+ budget) / build indirect args
-  shaders/shader_particle_render.js          billboard pipeline
+  shaders/shader_particle_render.js          blended billboard pipeline (GPUParticularRenderer's)
   shaders/chunk_particle_setup_context.js    VM builtins from the emitter's node, + the RNG seed
   shaders/chunk_particle_emitter_age.js      the tick pass's running age, off the emitter_state table
   shaders/chunk_particle_spawn_budget.js     take from the frame's spawn budget; both ticks spend it
@@ -698,8 +712,7 @@ src/shade/renderer/particles/
   shaders/chunk_particle_billboard_vertex.js the billboard vertex stage, shared by every draw
   shaders/shader_particle_avboit_*.js        occupancy / splat / draw through AVBOIT
   bounds/*                           the measured emitter box: accumulate, publish
-  sort/*                             render-order depth sort
-  graph_particles.js                 simulate (to the draw args) + the standalone sort and draw
+  graph_particles.js                 the simulation, to the draw args
   graph_particles_avboit.js          the AVBOIT side channel: occupancy, splat, draw
   GPUParticleSystem.js               the feature: owns the buffers, sweeps the scene, execute()
   *.spec.js                          co-located tests (JS + emulator + software device)
@@ -709,19 +722,19 @@ src/shade/renderer/particles/
 
 - Pure JS: layout packing, assembler, register allocator, node compiler, heap/emitter/registry
   bookkeeping (via `SoftwareGPUDevice`), the header encoding.
-- WGSL via emulator: VM opcode parity (JS vs WGSL), curve sampling, sort key/depth, atlas+flipbook
-  UV math, billboard expansion, soft-depth fade, and every compute pass on small fixtures — the tick
+- WGSL via emulator: VM opcode parity (JS vs WGSL), curve sampling, atlas+flipbook UV math,
+  billboard expansion, soft-depth fade, and every compute pass on small fixtures — the tick
   (rate integration, generations, pending, budget, culling, page-group walk), emit (expansion over
-  the scan, node position, orphans), simulate, spawn commands, finalize, bucket, sort. Each such spec
+  the scan, node position, orphans), simulate, spawn commands, finalize, bucket. Each such spec
   carries its own copy of the scaffolding: a real scene with a `GPUSceneContext` and a real registry,
   laid out by `gpu_database_words` the way the GPU holds both databases, so the shaders read rows the
   real writers wrote.
 - Multi-frame capstone (`particle_lifecycle.spec`): reset → commands → tick → (JS scan) → emit →
   simulate across frames, with the GPU deciding to spawn, a CPU burst, the budget, and death.
 - Orchestration on `SoftwareGPUDevice`: `GPUParticleSystem.spec` (scene sweep, growth, uploads only
-  when needed, the ring), `graph_particles.spec` (pass sequence, indirect sizing, the two orderings,
-  every persistent buffer imported exactly once), and the playground's `particle_scene.spec` (the
-  integration: geometry → hierarchy → particles → draw).
+  when needed, the ring, the `read_stats` decode), `graph_particles.spec` (pass sequence, indirect
+  sizing, the two lists, every persistent buffer imported exactly once), and the playground's
+  `particle_scene.spec` (the integration: geometry → hierarchy → particles → draw).
 - Cross-parity meta-tests: every ISA opcode implemented by both executors.
 
 Regression checks use the existing tools: seeded software-device buffer copies for list growth,
@@ -753,5 +766,5 @@ was seeded.
 Done: `Renderer.feature_particles_enabled` (off by default), `Renderer.particles(scene_ctx)` creating
 one system per scene context on first use, `simulate` recorded before the transparency pass and the
 system passed to the AVBOIT orchestrator as its side channel. Remaining:
-1. For lit emitters, compile a render variant that swaps the disabled lighting hook for a
-   shading-chunk-backed lighting hook (+ the `SHADING_LIGHT_RESOURCE_GROUP`).
+1. For lit emitters, compile a render variant that swaps the disabled lighting hook for a
+   shading-chunk-backed lighting hook (+ the `SHADING_LIGHT_RESOURCE_GROUP`).