@woosh/meep-engine 3.52.0 → 3.54.0

package/src/shade/renderer/object_property/chunk_write_object_property_node3d.d.ts

@@ -31,13 +31,14 @@
  * only to tell a missing `w` curve from an authored zero.
  *
  * `weight` is the clip weight `value` has already been multiplied by.
- * Rotation needs it because the identity it substitutes for a missing
- * channel has to carry the same weight as the channels that were
- * authored; nothing else here does.
- *
- * `rest_rotation` is the target's rest rotation, from its binding. Only
- * Rotation reads it: it rides into the slot with the contribution, for
- * the resolve to write when the rotations summed to nothing.
+ * All three properties use it to subtract `rest * weight` (`value - rest * weight`),
+ * and Rotation also uses it because the identity it substitutes for a missing
+ * `w` channel must carry the same weight as the authored channels.
+ *
+ * `rest_rotation` carries the target's rest value for the bound property
+ * (`rest.translation` in `.xyz` for Translation, `rest.rotation` in `.xyzw`
+ * for Rotation, `rest.scale` in `.xyz` for Scale). It rides into the slot
+ * with the contribution so the resolve pass can reconstruct `rest + delta`.
  *
  * @type {CodeChunk}
  */

package/src/shade/renderer/object_property/chunk_write_object_property_node3d.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_write_object_property_node3d.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/object_property/chunk_write_object_property_node3d.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,iDAFU,SAAS,CA8Bb;0BA1EoB,iCAAiC"}
+{"version":3,"file":"chunk_write_object_property_node3d.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/object_property/chunk_write_object_property_node3d.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,iDAFU,SAAS,CA8Bb;0BA3EoB,iCAAiC"}

package/src/shade/renderer/object_property/chunk_write_object_property_node3d.js

@@ -35,13 +35,14 @@ import { Node3DProperty } from "./Node3DProperty.js";
  * only to tell a missing `w` curve from an authored zero.
  *
  * `weight` is the clip weight `value` has already been multiplied by.
- * Rotation needs it because the identity it substitutes for a missing
- * channel has to carry the same weight as the channels that were
- * authored; nothing else here does.
+ * All three properties use it to subtract `rest * weight` (`value - rest * weight`),
+ * and Rotation also uses it because the identity it substitutes for a missing
+ * `w` channel must carry the same weight as the authored channels.
  *
- * `rest_rotation` is the target's rest rotation, from its binding. Only
- * Rotation reads it: it rides into the slot with the contribution, for
- * the resolve to write when the rotations summed to nothing.
+ * `rest_rotation` carries the target's rest value for the bound property
+ * (`rest.translation` in `.xyz` for Translation, `rest.rotation` in `.xyzw`
+ * for Rotation, `rest.scale` in `.xyz` for Scale). It rides into the slot
+ * with the contribution so the resolve pass can reconstruct `rest + delta`.
  *
  * @type {CodeChunk}
  */
@@ -60,13 +61,13 @@ fn write_object_property_node3d(
 
     switch(property){
         case ${Node3DProperty.Translation}u: {
-            pose_accumulator_add_translation(node_index, value.xyz, mask);
+            pose_accumulator_add_translation(node_index, value.xyz, mask, weight, rest_rotation.xyz);
         }
         case ${Node3DProperty.Rotation}u: {
             pose_accumulator_add_rotation(node_index, value, mask, weight, rest_rotation);
         }
         case ${Node3DProperty.Scale}u: {
-            pose_accumulator_add_scale(node_index, value.xyz, mask);
+            pose_accumulator_add_scale(node_index, value.xyz, mask, weight, rest_rotation.xyz);
         }
         default: {}
     }

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

@@ -1 +1 @@
-{"version":3,"file":"GPUParticleSystem.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/particles/GPUParticleSystem.js"],"names":[],"mappings":"AA4DA;;;;;;;;;;;;;GAaG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6FG;AACH;IAmLI;;;;;;OAMG;IACH,sBANW,MAAM,iBACN,OAAO,6BAA6B,EAAE,eAAe;QAEpC,QAAQ,GAAzB,MAAM;QACW,sBAAsB,GAAvC,MAAM;OAoBhB;IA1MD;;;OAGG;IACH,UAFU,MAAM,CAEP;IAET;;;;OAIG;IACH,eAFU,OAAO,6BAA6B,EAAE,eAAe,CAEjD;IAEd;;;OAGG;IACH,UAFU,MAAM,CAEP;IAET;;OAEG;IACH,UAFU,eAAe,CAEhB;IAET;;;OAGG;IACH,OAFU,MAAM,CAEN;IAEV;;;OAGG;IACH,MAFU,MAAM,CAEP;IAET;;;OAGG;IACH,qBAFU,MAAM,CAEQ;IAExB;;;;OAIG;IACH,sBAAM;IAEN,yBAAyB;IACzB,0BAAc;IAEd;;;;;;;;;;;OAWG;IACH,SAFU,MAAM,CAEH;IA4Ib;;;OAGG;IACH,kCAEC;IAED;;;OAGG;IACH,yEAEC;IAED;;;;;;;;;;;;OAYG;IACH,eAFa,MAAM,CAIlB;IAED;;;;;;;OAOG;IACH,eAHW,OAAO,8BAA8B,EAAE,eAAe,SACtD,MAAM,QAwBhB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH;QAPkG,KAAK,EAA5F,OAAO,2DAA2D,EAAE,UAAU;QAC/D,MAAM,EAArB,MAAM;QACS,cAAc,EAA7B,MAAM;QAES,EAAE,EAAjB,MAAM;QACJ,OAAO,sBAAsB,EAAE,yBAAyB,CAgEpE;IAiBD;;;;;;;;;OASG;IACH;QANgG,KAAK,EAA1F,OAAO,2DAA2D,EAAE,UAAU;QACjE,MAAM,EAAnB,MAAM;QACkB,kBAAkB,EAA1C,UAAU,MAAM,CAAC;QACJ,SAAS,EAAtB,MAAM;QACJ,MAAM,CAalB;IAED;;;;;;;;;;OAUG;IACH;QAPgG,KAAK,EAA1F,OAAO,2DAA2D,EAAE,UAAU;QACjE,MAAM,EAAnB,MAAM;QACO,IAAI,EAAjB,MAAM;QACO,aAAa,EAA1B,MAAM;QACsD,MAAM,EAAlE;YAAC,UAAU,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAC;YAAC,KAAK,EAAE,MAAM,CAAA;SAAC;QACnD;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC,CAkBjE;IAED;;;;;;;;;;;;;;;;OAgBG;IACH;QAbgG,KAAK,EAA1F,OAAO,2DAA2D,EAAE,UAAU;QACrB,QAAQ,EAAjE,OAAO,2BAA2B,EAAE,cAAc;QACrC,MAAM,EAAnB,MAAM;QACO,aAAa,EAA1B,MAAM;QACO,IAAI,EAAjB,MAAM;QACO,QAAQ,EAArB,MAAM;QACO,eAAe,EAA5B,MAAM;QACO,oBAAoB,EAAjC,MAAM;QAC0B,sBAAsB,EAAtD;YAAC,CAAC,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAC;QAEiD,YAAY,EAAtF;YAAC,KAAK,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAC;YAAC,UAAU,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAA;SAAC;QACjE;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAC,CAuB/E;IAED;;;;;;;;;OASG;IACH,qBAHW,OAAO,8BAA8B,EAAE,eAAe,iBACtD,MAAM,QAehB;IAED;;;;OAIG;IACH,wBAFW,OAAO,8BAA8B,EAAE,eAAe,QAMhE;IAED;;;;;OAKG;IACH,2BAHW,OAAO,8BAA8B,EAAE,eAAe,iBACtD,MAAM,QAMhB;IA2bD;;;;;;;OAOG;IACH;YAFoB,MAAM,GAAE,MAAM;MAgBjC;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,cAFa,QAAQ,mBAAmB,CAAC,CA8BxC;IAED,gBA2BC;;CACJ;;;;;;;;WA5oCa,MAAM;;;;UACN,MAAM;;;;kBACN,MAAM;;;;;cACN,MAAM;;;;;gBAEN,MAAM;;;;;oBAEN,MAAM;;gCAxCY,8BAA8B"}
+{"version":3,"file":"GPUParticleSystem.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/particles/GPUParticleSystem.js"],"names":[],"mappings":"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"}

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

@@ -56,7 +56,7 @@ const STORAGE_GROWABLE = GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST | GPUB
  */
 const INDIRECT = GPUBufferUsage.STORAGE | GPUBufferUsage.INDIRECT | GPUBufferUsage.COPY_SRC;
 
-const DEFAULT_CAPACITY = 131072;
+const DEFAULT_CAPACITY = 65536;
 
 /**
  * What {@link GPUParticleSystem#read_stats} decodes: the counts the GPU keeps between frames, named.
@@ -618,6 +618,7 @@ export class GPUParticleSystem {
         const { handles } = this.#simulated_for(graph);
 
         return graph_particle_avboit_draw({
+            scene_context: this.scene_context,
             graph,
             view_ctx,
             camera,
@@ -1121,6 +1122,8 @@ export class GPUParticleSystem {
             label: "particles/atlas_sampler",
             magFilter: "linear",
             minFilter: "linear",
+            mipmapFilter: "linear",
+            maxAnisotropy: 16,
             addressModeU: "clamp-to-edge",
             addressModeV: "clamp-to-edge",
         });

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

@@ -70,8 +70,8 @@ export function graph_particle_avboit_splat({ graph, camera, warp, depth_texture
  * @param {number} params.integral graph handle of the integral texture
  * @param {number} params.volumetrics_lut graph handle
  * @param {number} params.volumetrics_metadata graph handle
- * @param {{Y: number, CoCg: number}} params.volumetrics_irradiance graph handles of the froxel
- *   irradiance volume a lit emitter's particles are lit by
+ * @param {{Y: number, CoCg: number, uniform?: number}} params.volumetrics_irradiance graph handles of
+ *   the world-space irradiance clipmap a lit emitter's particles are lit by
  * @param {{color: number, norm: number, extinction: number, emission: number}} params.accumulators to add to
  * @param {GPUTextureView} params.atlas
  * @param {GPUSampler} params.atlas_sampler
@@ -81,7 +81,7 @@ export function graph_particle_avboit_splat({ graph, camera, warp, depth_texture
  * @param {number} params.draw_args graph handle of the indirect draw args
  * @returns {{color: number, norm: number, extinction: number, emission: number}} the accumulators after the draw
  */
-export function graph_particle_avboit_draw({ graph, view_ctx, camera, depth_texture, warp, integral, volumetrics_lut, volumetrics_metadata, volumetrics_irradiance, accumulators, atlas, atlas_sampler, pool, alive, emitter_database, draw_args, }: {
+export function graph_particle_avboit_draw({ graph, view_ctx, scene_context, camera, depth_texture, warp, integral, volumetrics_lut, volumetrics_metadata, volumetrics_irradiance, accumulators, atlas, atlas_sampler, pool, alive, emitter_database, draw_args, }: {
     graph: import("../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
     view_ctx: import("../view/GPUViewContext.js").GPUViewContext;
     camera: number;
@@ -93,6 +93,7 @@ export function graph_particle_avboit_draw({ graph, view_ctx, camera, depth_text
     volumetrics_irradiance: {
         Y: number;
         CoCg: number;
+        uniform?: number;
     };
     accumulators: {
         color: number;

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

@@ -1 +1 @@
-{"version":3,"file":"graph_particles_avboit.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/particles/graph_particles_avboit.js"],"names":[],"mappings":"AAuCA;;;;;;;;;;;;;;;GAeG;AACH;IARkG,KAAK,EAA5F,OAAO,2DAA2D,EAAE,UAAU;IAC/D,MAAM,EAArB,MAAM;IACoB,kBAAkB,EAA5C,UAAU,MAAM,CAAC;IACF,SAAS,EAAxB,MAAM;IACS,gBAAgB,EAA/B,MAAM;IACS,mBAAmB,EAAlC,MAAM;IACJ,MAAM,CA8ClB;AAED;;;;;;;;;;;;;;;GAeG;AACH;IAZkG,KAAK,EAA5F,OAAO,2DAA2D,EAAE,UAAU;IAC/D,MAAM,EAArB,MAAM;IACS,IAAI,EAAnB,MAAM;IACwD,MAAM,EAApE;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC;IAC9B,KAAK;IACT,aAAa;IACjB,IAAI,EAAnB,MAAM;IACS,KAAK,EAApB,MAAM;IACS,gBAAgB,EAA/B,MAAM;IACS,SAAS,EAAxB,MAAM;IACJ;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,CA8EjE;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH;IAnBkG,KAAK,EAA5F,OAAO,2DAA2D,EAAE,UAAU;IACnB,QAAQ,EAAnE,OAAO,2BAA2B,EAAE,cAAc;IACnC,MAAM,EAArB,MAAM;IACS,aAAa,EAA5B,MAAM;IACS,IAAI,EAAnB,MAAM;IACS,QAAQ,EAAvB,MAAM;IACS,eAAe,EAA9B,MAAM;IACS,oBAAoB,EAAnC,MAAM;IAC4B,sBAAsB,EAAxD;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC;IAEmD,YAAY,EAAxF;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAC;IAC5C,KAAK;IACT,aAAa;IACjB,IAAI,EAAnB,MAAM;IACS,KAAK,EAApB,MAAM;IACS,gBAAgB,EAA/B,MAAM;IACS,SAAS,EAAxB,MAAM;IACJ;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAC,CAkH/E"}
+{"version":3,"file":"graph_particles_avboit.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/particles/graph_particles_avboit.js"],"names":[],"mappings":"AA2CA;;;;;;;;;;;;;;;GAeG;AACH;IARkG,KAAK,EAA5F,OAAO,2DAA2D,EAAE,UAAU;IAC/D,MAAM,EAArB,MAAM;IACoB,kBAAkB,EAA5C,UAAU,MAAM,CAAC;IACF,SAAS,EAAxB,MAAM;IACS,gBAAgB,EAA/B,MAAM;IACS,mBAAmB,EAAlC,MAAM;IACJ,MAAM,CA8ClB;AAED;;;;;;;;;;;;;;;GAeG;AACH;IAZkG,KAAK,EAA5F,OAAO,2DAA2D,EAAE,UAAU;IAC/D,MAAM,EAArB,MAAM;IACS,IAAI,EAAnB,MAAM;IACwD,MAAM,EAApE;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC;IAC9B,KAAK;IACT,aAAa;IACjB,IAAI,EAAnB,MAAM;IACS,KAAK,EAApB,MAAM;IACS,gBAAgB,EAA/B,MAAM;IACS,SAAS,EAAxB,MAAM;IACJ;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,CA0EjE;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH;IAnBkG,KAAK,EAA5F,OAAO,2DAA2D,EAAE,UAAU;IACnB,QAAQ,EAAnE,OAAO,2BAA2B,EAAE,cAAc;IACnC,MAAM,EAArB,MAAM;IACS,aAAa,EAA5B,MAAM;IACS,IAAI,EAAnB,MAAM;IACS,QAAQ,EAAvB,MAAM;IACS,eAAe,EAA9B,MAAM;IACS,oBAAoB,EAAnC,MAAM;IAC8C,sBAAsB,EAA1E;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAC;IAEiC,YAAY,EAAxF;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAC;IAC5C,KAAK;IACT,aAAa;IACjB,IAAI,EAAnB,MAAM;IACS,KAAK,EAApB,MAAM;IACS,gBAAgB,EAA/B,MAAM;IACS,SAAS,EAAxB,MAAM;IACJ;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAC,CAmI/E"}

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

@@ -3,14 +3,18 @@ import { SamplerDescriptor } from "../../descriptor/texture/SamplerDescriptor.js
 import { TextureViewDescriptor } from "../../descriptor/texture/TextureViewDescriptor.js";
 import { DEFAULT_DEPTH_TEXTURE_VIEW } from "../depth/DEFAULT_DEPTH_TEXTURE_VIEW.js";
 import { AVBOIT_OCCUPANCY_SETTINGS_STRUCT } from "../rasterize/native/avboit/shader_avboit_occupancy.js";
+import {
+    METRO_L1_IRRADIANCE_STRUCT
+} from "../shader/chunk/spherical_harmonics/l1i/chunk_convert_to_irradiance_sh.js";
 import { STATIC_GRAPHICS_ENGINE_ASSETS } from "../STATIC_GRAPHICS_ENGINE_ASSETS.js";
-import { shader_particle_avboit_occupancy } from "./shaders/shader_particle_avboit_occupancy.js";
+import { IRRADIANCE_CLIPMAP_STRUCT } from "../volumetrics/irradiance_clipmap/IRRADIANCE_CLIPMAP_STRUCT.js";
 import {
-    PARTICLE_AVBOIT_DRAW_ALPHA_PIPELINE,
     PARTICLE_AVBOIT_DRAW_ADDITIVE_PIPELINE,
+    PARTICLE_AVBOIT_DRAW_ALPHA_PIPELINE,
     PARTICLE_AVBOIT_DRAW_GENERAL_PIPELINE,
     PARTICLE_AVBOIT_DRAW_RESOURCES,
 } from "./shaders/shader_particle_avboit_draw.js";
+import { shader_particle_avboit_occupancy } from "./shaders/shader_particle_avboit_occupancy.js";
 import {
     PARTICLE_AVBOIT_SPLAT_PIPELINE,
     PARTICLE_AVBOIT_SPLAT_RESOURCES,
@@ -135,10 +139,6 @@ export function graph_particle_avboit_splat({
     function execute(data, resources, context) {
         const encoder = context.encoder;
 
-        // By name, never by position: the order a shader declares its bindings in is the shader's
-        // business, and a list built here to match it binds a sampler where a texture goes the
-        // moment a binding is inserted anywhere but the end. The device rejects that, and only when
-        // the pass is first encoded on real hardware. See the layout-kind check in the spec.
         const bindings = PARTICLE_AVBOIT_SPLAT_RESOURCES.generateBindings({
             camera: resources.get(data.camera),
             warp: resources.get(data.warp),
@@ -205,8 +205,8 @@ export function graph_particle_avboit_splat({
  * @param {number} params.integral graph handle of the integral texture
  * @param {number} params.volumetrics_lut graph handle
  * @param {number} params.volumetrics_metadata graph handle
- * @param {{Y: number, CoCg: number}} params.volumetrics_irradiance graph handles of the froxel
- *   irradiance volume a lit emitter's particles are lit by
+ * @param {{Y: number, CoCg: number, uniform?: number}} params.volumetrics_irradiance graph handles of
+ *   the world-space irradiance clipmap a lit emitter's particles are lit by
  * @param {{color: number, norm: number, extinction: number, emission: number}} params.accumulators to add to
  * @param {GPUTextureView} params.atlas
  * @param {GPUSampler} params.atlas_sampler
@@ -219,6 +219,7 @@ export function graph_particle_avboit_splat({
 export function graph_particle_avboit_draw({
                                                graph,
                                                view_ctx,
+                                               scene_context,
                                                camera,
                                                depth_texture,
                                                warp,
@@ -246,6 +247,16 @@ export function graph_particle_avboit_draw({
 
         const t_depth = resources.get(data.depth);
         const depth_view = t_depth.obtainView(DEFAULT_DEPTH_TEXTURE_VIEW);
+        const linear_sampler = graphics.samplers.obtain(SAMPLER_LINEAR);
+
+        const irradiance_clipmap_buffer = data.irradiance_uniform !== undefined
+            ? resources.get(data.irradiance_uniform)
+            : (view_ctx.volumetrics?.irradiance_clipmap?.uniform
+                ?? encoder.allocateTransientBuffer(GPUBufferUsage.UNIFORM, IRRADIANCE_CLIPMAP_STRUCT.size));
+
+        const far_field_sh_buffer = scene_context?.lights?.far_field_irradiance_sh
+            ?? view_ctx.scene?.lights?.far_field_irradiance_sh
+            ?? encoder.allocateTransientBuffer(GPUBufferUsage.UNIFORM, METRO_L1_IRRADIANCE_STRUCT.aligned_size);
 
         // by name rather than by position, for the reason the splat gives
         const bindings = PARTICLE_AVBOIT_DRAW_RESOURCES.generateBindings({
@@ -259,12 +270,15 @@ export function graph_particle_avboit_draw({
             atlas_sampler,
             scene_depth: depth_view,
             tIntegral: resources.get(data.integral).obtainView(),
-            sLinear: graphics.samplers.obtain(SAMPLER_LINEAR),
+            sLinear: linear_sampler,
             volumetrics_metadata: resources.get(data.volumetrics_metadata),
             tVolumetrics: resources.get(data.volumetrics_lut).obtainView(),
             tSTBN_vec3: graphics.textures.obtain(STATIC_GRAPHICS_ENGINE_ASSETS.stbn_vec3).obtainView(),
-            tIrradianceY: resources.get(data.irradiance_Y).obtainView(),
-            tIrradianceCoCg: resources.get(data.irradiance_CoCg).obtainView(),
+            irradiance_clipmap: irradiance_clipmap_buffer,
+            irradiance_clipmap_atlas_y: resources.get(data.irradiance_Y).obtainView(),
+            irradiance_clipmap_atlas_cocg: resources.get(data.irradiance_CoCg).obtainView(),
+            irradiance_clipmap_sampler: linear_sampler,
+            far_field_irradiance_sh: far_field_sh_buffer,
         }, encoder);
 
         const attachment = (handle) => ({
@@ -312,6 +326,9 @@ export function graph_particle_avboit_draw({
     pass_data.volumetrics_metadata = pass.read(volumetrics_metadata);
     pass_data.irradiance_Y = pass.read(volumetrics_irradiance.Y);
     pass_data.irradiance_CoCg = pass.read(volumetrics_irradiance.CoCg);
+    if (volumetrics_irradiance.uniform !== undefined) {
+        pass_data.irradiance_uniform = pass.read(volumetrics_irradiance.uniform);
+    }
     pass_data.pool = pass.read(pool);
     pass_data.alive = pass.read(alive);
     pass_data.emitter_database = pass.read(emitter_database);

package/src/shade/renderer/particles/shaders/chunk_particle_lighting.d.ts

@@ -1,19 +1,15 @@
 /**
  * How an emitter flagged `EMITTER_FLAG.LIGHTING` is lit, per fragment:
- * `particle_apply_lighting(color, world, normal)` treats the particle's colour as a diffuse albedo and
- * returns what it reflects and transmits (`chunk_particle_lighting_model`), from the froxel
- * irradiance volume (`chunk_volumetrics_irradiance_sh`) at the fragment: the renderer's indirect
- * lighting, whichever mode it runs (the froxel GI stage, `volumetrics/gi/`), plus every directional,
- * point and spot light, shadowed, as the surfaces around the particle receive them. One trilinear read of each
- * of its two textures, so the cost grows with neither the lights nor the GI; the price is resolution —
- * a froxel is 16 pixels across and a slice deep, and light and shadow edges inside a particle are that
- * soft.
+ * `particle_apply_lighting(color, world_position, normal)` treats the particle's colour as a diffuse
+ * albedo and returns what it reflects and transmits (`chunk_particle_lighting_model`), sampled from
+ * the world-space irradiance clipmap (`chunk_irradiance_clipmap_sample_with_far_field`):
  *
- * The normal is whatever the vertex stage bent it to (`particle_billboard_normal`), so a camera-facing
- * sprite reads as a rounded puff rather than a card.
- *
- * The enclosing shader binds `camera`, `volumetrics_metadata`, `sLinear`, `tIrradianceY` and
- * `tIrradianceCoCg` under those names.
+ * - Inside the clipmap cascades, performs a single-cascade stochastic tap using a non-linear
+ *   `smoothstep` transition across each cascade's blend-skirt (`irradiance_clipmap.blend_skirt`,
+ *   default `IRRADIANCE_CLIPMAP_DEFAULT_BLEND_SKIRT = 2` voxels), with `random_u` generated via
+ *   `hash_lowbias32_vec2u` and `hash_to_float01`.
+ * - Across the coarsest cascade's blend-skirt and outside all cascades (`CLIPMAP_LEVEL_NONE`),
+ *   smoothly falls back to `far_field_irradiance_sh` (cached on `GPULightCollection`).
  *
  * @type {CodeChunk}
  */

package/src/shade/renderer/particles/shaders/chunk_particle_lighting.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_particle_lighting.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/chunk_particle_lighting.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;GAkBG;AACH,sCAFU,SAAS,CAgBZ;0BAvCmB,oCAAoC"}
+{"version":3,"file":"chunk_particle_lighting.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/chunk_particle_lighting.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;GAcG;AACH,sCAFU,SAAS,CAmBZ;0BAvCmB,oCAAoC"}

package/src/shade/renderer/particles/shaders/chunk_particle_lighting.js

@@ -1,25 +1,25 @@
+import { chunk_hash_to_float01 } from "../../shader/chunk/random/chunk_hash_to_float01.js";
+import { chunk_hash_lowbias32_vec2u } from "../../shader/chunk/random/lowbias/chunk_hash_lowbias32_vec2u.js";
+import { chunk_hash_lowbias32_vec3u } from "../../shader/chunk/random/lowbias/chunk_hash_lowbias32_vec3u.js";
 import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { VIEW_RESOURCE } from "../../view/VIEW_RESOURCE.js";
 import {
-    volumetrics_position_world_to_froxel_uvw
-} from "../../volumetrics/volumetrics_position_world_to_froxel_uvw.js";
+    chunk_irradiance_clipmap_sample_with_far_field
+} from "../../volumetrics/irradiance_clipmap/chunk_irradiance_clipmap_sample.js";
 import { chunk_particle_lighting_model } from "./chunk_particle_lighting_model.js";
 
 /**
  * How an emitter flagged `EMITTER_FLAG.LIGHTING` is lit, per fragment:
- * `particle_apply_lighting(color, world, normal)` treats the particle's colour as a diffuse albedo and
- * returns what it reflects and transmits (`chunk_particle_lighting_model`), from the froxel
- * irradiance volume (`chunk_volumetrics_irradiance_sh`) at the fragment: the renderer's indirect
- * lighting, whichever mode it runs (the froxel GI stage, `volumetrics/gi/`), plus every directional,
- * point and spot light, shadowed, as the surfaces around the particle receive them. One trilinear read of each
- * of its two textures, so the cost grows with neither the lights nor the GI; the price is resolution —
- * a froxel is 16 pixels across and a slice deep, and light and shadow edges inside a particle are that
- * soft.
+ * `particle_apply_lighting(color, world_position, normal)` treats the particle's colour as a diffuse
+ * albedo and returns what it reflects and transmits (`chunk_particle_lighting_model`), sampled from
+ * the world-space irradiance clipmap (`chunk_irradiance_clipmap_sample_with_far_field`):
  *
- * The normal is whatever the vertex stage bent it to (`particle_billboard_normal`), so a camera-facing
- * sprite reads as a rounded puff rather than a card.
- *
- * The enclosing shader binds `camera`, `volumetrics_metadata`, `sLinear`, `tIrradianceY` and
- * `tIrradianceCoCg` under those names.
+ * - Inside the clipmap cascades, performs a single-cascade stochastic tap using a non-linear
+ *   `smoothstep` transition across each cascade's blend-skirt (`irradiance_clipmap.blend_skirt`,
+ *   default `IRRADIANCE_CLIPMAP_DEFAULT_BLEND_SKIRT = 2` voxels), with `random_u` generated via
+ *   `hash_lowbias32_vec2u` and `hash_to_float01`.
+ * - Across the coarsest cascade's blend-skirt and outside all cascades (`CLIPMAP_LEVEL_NONE`),
+ *   smoothly falls back to `far_field_irradiance_sh` (cached on `GPULightCollection`).
  *
  * @type {CodeChunk}
  */
@@ -27,14 +27,19 @@ export const chunk_particle_lighting = CodeChunk.from(
     /* language=wgsl */
     `
 fn particle_apply_lighting(color : vec4<f32>, world_position : vec3<f32>, normal : vec3<f32>) -> vec4<f32> {
-    let uvw = volumetrics_position_world_to_froxel_uvw(world_position);
+    let pos_hash = hash_lowbias32_vec3u(bitcast<vec3<u32>>(world_position));
+    let random_u = hash_to_float01(hash_lowbias32_vec2u(vec2<u32>(pos_hash, view.frame_index)));
 
-    let sh_Y = textureSampleLevel(tIrradianceY, sLinear, uvw, 0.0);
-    let sh_CoCg = textureSampleLevel(tIrradianceCoCg, sLinear, uvw, 0.0).xy;
+    let sh = irradiance_clipmap_sample_with_far_field(world_position, random_u);
 
-    return particle_lit(color, sh_Y, sh_CoCg, normal);
+    return particle_lit(color, sh.Y, sh.CoCg, normal);
 }
 `, [
-        volumetrics_position_world_to_froxel_uvw,
+        chunk_hash_lowbias32_vec3u,
+        chunk_hash_lowbias32_vec2u,
+        chunk_hash_to_float01,
+        chunk_irradiance_clipmap_sample_with_far_field,
         chunk_particle_lighting_model,
     ]);
+
+chunk_particle_lighting.requireResource(VIEW_RESOURCE);

package/src/shade/renderer/particles/shaders/shader_particle_avboit_draw.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_particle_avboit_draw.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/shader_particle_avboit_draw.js"],"names":[],"mappings":"AAoMA,2EAAsI;AACtI,8EAA2I;AAC3I,6EAA8I;AAE9I,mEAAmE;AACnE,yEAAwD;AAExD,mDAAmD;AACnD,2DAAsD;yCA5Mb,iEAAiE;4CAa9D,sDAAsD;iCAFjE,kCAAkC"}
+{"version":3,"file":"shader_particle_avboit_draw.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/shader_particle_avboit_draw.js"],"names":[],"mappings":"AAwLA,2EAAsI;AACtI,8EAA2I;AAC3I,6EAA8I;AAE9I,mEAAmE;AACnE,yEAAwD;AAExD,mDAAmD;AACnD,2DAAsD;yCA/Lb,iEAAiE;4CAU9D,sDAAsD;iCACjE,kCAAkC"}

package/src/shade/renderer/particles/shaders/shader_particle_avboit_draw.js

@@ -1,26 +1,30 @@
-import { RenderPipelineDescriptor } from "../../../descriptor/pipeline/render/RenderPipelineDescriptor.js";
 import { DepthStencilState } from "../../../descriptor/pipeline/render/DepthStencilState.js";
-import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { RenderPipelineDescriptor } from "../../../descriptor/pipeline/render/RenderPipelineDescriptor.js";
 import { CAMERA_UNIFORM_STRUCT } from "../../camera/CAMERA_UNIFORM_STRUCT.js";
 import { chunk_sample_volumetrics } from "../../deferred/chunk_sample_volumetrics.js";
 import { AVBOIT_EXTINCT_TRANSMITTANCE } from "../../rasterize/native/avboit/AVBOIT_CONSTANTS.js";
-import { AVBOIT_WARP_STRUCT } from "../../rasterize/native/avboit/AVBOIT_WARP_STRUCT.js";
 import { AVBOIT_DRAW_TARGETS } from "../../rasterize/native/avboit/avboit_draw_fragment_body.js";
-import { chunk_avboit_view_depth_to_virtual } from "../../rasterize/native/avboit/chunk_avboit_view_depth_to_virtual.js";
+import { AVBOIT_WARP_STRUCT } from "../../rasterize/native/avboit/AVBOIT_WARP_STRUCT.js";
 import { chunk_avboit_footprint_bias } from "../../rasterize/native/avboit/chunk_avboit_footprint_bias.js";
 import { chunk_avboit_sample_transmittance } from "../../rasterize/native/avboit/chunk_avboit_sample_transmittance.js";
-import { ShaderDescriptor } from "../../shader/ShaderDescriptor.js";
+import { chunk_avboit_view_depth_to_virtual } from "../../rasterize/native/avboit/chunk_avboit_view_depth_to_virtual.js";
 import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
 import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { ShaderDescriptor } from "../../shader/ShaderDescriptor.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
 import { SAMPLER_LINEAR_UPSCALE } from "../../texture/SAMPLER_LINEAR_UPSCALE.js";
+import { chunk_view_mip_bias } from "../../view/chunk_view_mip_bias.js";
 import { VIEW_UNIFORM_STRUCT } from "../../view/VIEW_UNIFORM_STRUCT.js";
+import {
+    irradiance_clipmap_add_resources
+} from "../../volumetrics/irradiance_clipmap/chunk_irradiance_clipmap_sample.js";
 import { VOLUMETRICS_METADATA_STRUCT } from "../../volumetrics/VOLUMETRICS_METADATA_STRUCT.js";
 import { EMITTER_FLAG } from "../data/PARTICLE_EMITTER_STRUCT.js";
 import { PARTICLE_SOFT_FADE_RANGE } from "../ParticleConstants.js";
 import { chunk_particle_avboit_contribution } from "./chunk_particle_avboit_contribution.js";
-import { chunk_particle_scene_view_depth } from "./chunk_particle_scene_view_depth.js";
 import { chunk_particle_billboard_vertex } from "./chunk_particle_billboard_vertex.js";
 import { chunk_particle_lighting } from "./chunk_particle_lighting.js";
+import { chunk_particle_scene_view_depth } from "./chunk_particle_scene_view_depth.js";
 
 /**
  * The particles' AVBOIT draw: the billboard quads at internal resolution, depth-tested against the
@@ -29,28 +33,13 @@ import { chunk_particle_lighting } from "./chunk_particle_lighting.js";
  *
  * Per fragment: the atlas sample times the particle colour, the soft-depth fade against the scene
  * depth, lighting for an emitter flagged `EMITTER_FLAG.LIGHTING` (`chunk_particle_lighting`: the
- * froxel irradiance volume: the lights and the indirect lighting), the volumetric fog composite exactly as the
- * mesh draw applies it, then the transmittance of everything in front from the integral texture —
- * and a fragment the volume already calls extinct is discarded unshaded. An emitter without the
- * flag is its own colour, which is what an additive one wants.
- *
- * What is written depends on how the particle blends:
- *
- * - **alpha / premultiplied** — a surface: `color += premultiplied × T`, `norm += coverage × T`,
- *   `extinction += -log(1 - coverage)`, the same three the meshes write, with an untinted
- *   `T_self = 1 - coverage`; the splat recorded exactly that.
- * - **additive** — light: `emission += premultiplied × T`, nothing else. It joins the resolve
- *   attenuated by what is in front of it and outside the coverage normalization, which is what an
- *   additive fragment means.
- *
- * The scene depth is bound twice: as the read-only depth attachment the pipeline tests against, and
- * as the texture the soft fade reads. Both are reads, which WebGPU allows within one pass; the pass
- * is recorded with the attachment read-only for that reason.
+ * world-space irradiance clipmap and cached far-field SH), the volumetric fog composite, then the
+ * transmittance of everything in front from the integral texture.
  */
 
 const resources = new ShaderResourceSetDescriptor();
 
-resources.createGroup()
+const group = resources.createGroup()
     .addUniform("camera", CAMERA_UNIFORM_STRUCT)
     .addUniform("view", VIEW_UNIFORM_STRUCT)
     .addStorageBuffer("warp", AVBOIT_WARP_STRUCT)
@@ -66,10 +55,10 @@ resources.createGroup()
     // volumetrics (composited inline)
     .addUniform("volumetrics_metadata", VOLUMETRICS_METADATA_STRUCT)
     .addTexture("tVolumetrics", "float", "3d")
-    .addTexture("tSTBN_vec3", "float", "3d")
-    // lighting (chunk_particle_lighting): the froxel irradiance volume, trilinear through sLinear
-    .addTexture("tIrradianceY", "float", "3d")
-    .addTexture("tIrradianceCoCg", "float", "3d");
+    .addTexture("tSTBN_vec3", "float", "3d");
+
+// lighting (chunk_particle_lighting): world-space irradiance clipmap + cached far-field SH fallback
+irradiance_clipmap_add_resources(group, { include_far_field: true });
 
 const body = CodeChunk.from(
     /* language=wgsl */ `
@@ -111,12 +100,10 @@ fn vs_general(@builtin(vertex_index) vi : u32, @builtin(instance_index) ii : u32
 @fragment
 fn fs_main(in : ParticleVertexOut) -> ParticleAVBOITDrawOutput {
     let screen_uv = in.clip.xy / vec2<f32>(f32(view.width), f32(view.height));
+    let uv_bias = view_uv_derivative_bias(view.upscale_ratio);
+    let uv_ddx = dpdx(in.uv) * uv_bias.x;
+    let uv_ddy = dpdy(in.uv) * uv_bias.y;
 
-    // a billboard, stretched or not, is built from the camera's right and up and lies in the view plane,
-    // so its footprint is zero; a horizontal, vertical or world-facing quad seen at an angle runs
-    // through depth across a voxel (avboit_footprint_bias). An additive particle writes nothing into
-    // the volume, so nothing of its own is there to occlude it, and takes none. The derivative is
-    // taken here, in uniform control flow, whatever the blend
     let footprint = select(
         avboit_footprint_bias(&warp, fwidth(avboit_view_depth_to_virtual(&warp, in.view_depth))),
         0.0,
@@ -130,7 +117,7 @@ fn fs_main(in : ParticleVertexOut) -> ParticleAVBOITDrawOutput {
         discard;
     }
 
-    var color = textureSample(atlas, atlas_sampler, in.uv) * in.color;
+    var color = textureSampleGrad(atlas, atlas_sampler, in.uv, uv_ddx, uv_ddy) * in.color;
 
     if ((in.flags & PARTICLE_FLAG_SOFT_DEPTH) != 0u) {
         let scene_vd = particle_scene_view_depth(textureLoad(scene_depth, vec2<i32>(in.clip.xy), 0).r, camera);
@@ -167,6 +154,7 @@ fn fs_main(in : ParticleVertexOut) -> ParticleAVBOITDrawOutput {
     chunk_avboit_view_depth_to_virtual,
     chunk_avboit_footprint_bias,
     chunk_avboit_sample_transmittance,
+    chunk_view_mip_bias,
 ]);
 
 const descriptor = ShaderDescriptor.from({ label: "Particle AVBOIT Draw", body, resources });

package/src/shade/renderer/postprocess/nss/NSS.d.ts

@@ -53,7 +53,7 @@ export class NSS {
      * @returns {number}
      */
     static recommended_jitter_sequence_size(upscale_ratio: number): number;
-    static "__#201@#preprocess_tensor_descriptor"(render_w: any, render_h: any): TextureResourceDescriptor;
+    static "__#203@#preprocess_tensor_descriptor"(render_w: any, render_h: any): TextureResourceDescriptor;
     /**
      * @param {GraphicsContext} graphics
      */

package/src/shade/renderer/postprocess/ssr/resolve/ssr_resolve_shader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ssr_resolve_shader.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/postprocess/ssr/resolve/ssr_resolve_shader.js"],"names":[],"mappings":"AAiWA;;;;;;;GAOG;AACH,iCAFU,WAAW,CAgBlB;4BApWyB,gCAAgC"}
+{"version":3,"file":"ssr_resolve_shader.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/postprocess/ssr/resolve/ssr_resolve_shader.js"],"names":[],"mappings":"AAmWA;;;;;;;GAOG;AACH,iCAFU,WAAW,CAgBlB;4BAtWyB,gCAAgC"}

package/src/shade/renderer/postprocess/ssr/resolve/ssr_resolve_shader.js

@@ -1,6 +1,6 @@
 import { chunk_ssr_metadata } from "../chunk_ssr_metadata.js";
 import { chunk_is_on_screen_i32 } from "../../../shader/chunk/texture/chunk_is_on_screen_i32.js";
-import { SamplerDescriptor } from "../../../../descriptor/texture/SamplerDescriptor.js";
+import { SAMPLER_TRILINEAR_CLAMP } from "../../../texture/SAMPLER_TRILINEAR_CLAMP.js";
 import { u32 } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
 import { CAMERA_UNIFORM_STRUCT } from "../../../camera/CAMERA_UNIFORM_STRUCT.js";
@@ -62,12 +62,14 @@ resources.createGroup()
     .addTexture("tNormal", "uint")
     .addTexture("tColor", "float")
     .addTexture("tAlbedoAO", "unfilterable-float")
-    .addSampler("sLinear", "filtering", SamplerDescriptor.from({
-        magFilter: "linear",
-        mipmapFilter: "linear",
-        addressModeU: "clamp-to-edge",
-        addressModeV: "clamp-to-edge",
-    }))
+    .addSampler("sLinear", "filtering", SAMPLER_TRILINEAR_CLAMP)
+
+
+
+
+
+
+
     .addUniform("camera", CAMERA_UNIFORM_STRUCT)
 ;
 

package/src/shade/renderer/rasterize/forward/chunk_forward_shade_standard_fragment.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_forward_shade_standard_fragment.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/forward/chunk_forward_shade_standard_fragment.js"],"names":[],"mappings":"AAuCA;;;;;;GAMG;AACH,8DAiKC;0BAxLyB,oCAAoC"}
+{"version":3,"file":"chunk_forward_shade_standard_fragment.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/forward/chunk_forward_shade_standard_fragment.js"],"names":[],"mappings":"AAyCA;;;;;;GAMG;AACH,8DAsKC;0BA/LyB,oCAAoC"}

package/src/shade/renderer/rasterize/forward/chunk_forward_shade_standard_fragment.js

@@ -24,7 +24,9 @@ import { MATERIAL_SHADING_INFO_STRUCT } from "../../shader/chunk/material/MATERI
 import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
 import { chunk_forward_sample_indirect } from "./chunk_forward_sample_indirect.js";
 import { FORWARD_VERTEX_SHADER_STRUCT } from "./FORWARD_VERTEX_SHADER_STRUCT.js";
-import { CAMERA_RESOURCE } from "../../camera/CAMERA_RESOURCE.js";
+import { CAMERA_RESOURCE } from "../../camera/CAMERA_RESOURCE.js";
+import { VIEW_RESOURCE } from "../../view/VIEW_RESOURCE.js";
+import { chunk_view_mip_bias } from "../../view/chunk_view_mip_bias.js";
 import {
     MATERIAL_DIFFUSE_SAMPLER_RESOURCE,
     MATERIAL_DIFFUSE_TEXTURE_RESOURCE,
@@ -55,7 +57,11 @@ fn forward_shade_standard_fragment(
 ) -> vec4f {
     let world_tangent_frame = build_orthonormal_matrix_nt(vert.normal, vert.tangent);
 
-    let t_normal = decode_tangent_normal(textureSample(texture_normal, texture_normal_sampler, vert.uv));
+    let uv_bias = view_uv_derivative_bias(view.upscale_ratio);
+    let uv_ddx = dpdx(vert.uv) * uv_bias.x;
+    let uv_ddy = dpdy(vert.uv) * uv_bias.y;
+
+    let t_normal = decode_tangent_normal(textureSampleGrad(texture_normal, texture_normal_sampler, vert.uv, uv_ddx, uv_ddy));
     var world_shading_normal:vec3<f32> = normalize( world_tangent_frame * t_normal );
 
     // flip the normal when looking at the surface's back. The raw front_facing cannot say:
@@ -77,9 +83,9 @@ fn forward_shade_standard_fragment(
         view_direction: 'view_direction',
     })};
 
-    let t_pbr = textureSample(texture_orm, texture_orm_sampler, vert.uv);
-    let t_diffuse = textureSample(texture_diffuse, texture_diffuse_sampler, vert.uv);
-    let t_emissive = textureSample(texture_emissive, texture_emissive_sampler, vert.uv);
+    let t_pbr = textureSampleGrad(texture_orm, texture_orm_sampler, vert.uv, uv_ddx, uv_ddy);
+    let t_diffuse = textureSampleGrad(texture_diffuse, texture_diffuse_sampler, vert.uv, uv_ddx, uv_ddy);
+    let t_emissive = textureSampleGrad(texture_emissive, texture_emissive_sampler, vert.uv, uv_ddx, uv_ddy);
 
     // the vertex stage hands on the vertex's own colour; the material's is applied here
     var diffuse = t_diffuse.rgb * vert.color * material_info.albedo_color.rgb;
@@ -203,11 +209,13 @@ fn forward_shade_standard_fragment(
         chunk_compute_indirect_specular,
         chunk_forward_sample_indirect,
         chunk_compute_specular_occlusion,
-        chunk_material_draw_side,
+        chunk_material_draw_side,
+        chunk_view_mip_bias,
     ]
 )
 
-chunk_forward_shade_standard_fragment.requireResource(CAMERA_RESOURCE);
+chunk_forward_shade_standard_fragment.requireResource(CAMERA_RESOURCE);
+chunk_forward_shade_standard_fragment.requireResource(VIEW_RESOURCE);
 chunk_forward_shade_standard_fragment.requireResource(MATERIAL_INFO_RESOURCE);
 chunk_forward_shade_standard_fragment.requireResource(MATERIAL_DIFFUSE_TEXTURE_RESOURCE);
 chunk_forward_shade_standard_fragment.requireResource(MATERIAL_DIFFUSE_SAMPLER_RESOURCE);

package/src/shade/renderer/rasterize/native/avboit/avboit_draw_fragment_body.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"avboit_draw_fragment_body.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/avboit_draw_fragment_body.js"],"names":[],"mappings":"AAWA;;;;GAIG;AACH,uCAFU,MAAM,CAE2B;AAE3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wCAFU,MAAM,CAoEV;AAEN;;;GAGG;AACH,gDAFU,WAAW,CAWnB;AAEF;;;GAGG;AACH,kCAFU,qBAAqB,CAiB3B"}
+{"version":3,"file":"avboit_draw_fragment_body.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/avboit_draw_fragment_body.js"],"names":[],"mappings":"AAWA;;;;GAIG;AACH,uCAFU,MAAM,CAE2B;AAE3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wCAFU,MAAM,CAsEV;AAEN;;;GAGG;AACH,gDAFU,WAAW,CAWnB;AAEF;;;GAGG;AACH,kCAFU,qBAAqB,CAiB3B"}

package/src/shade/renderer/rasterize/native/avboit/avboit_draw_fragment_body.js

@@ -1,6 +1,6 @@
 import { chunk_sample_volumetrics } from "../../../deferred/chunk_sample_volumetrics.js";
 import { chunk_get_view_space_depth } from "../../../shader/chunk/depth/chunk_get_view_space_depth.js";
-import { chunk_unjitter_uv } from "../../../shader/chunk/texture/chunk_unjitter_uv.js";
+import { chunk_view_mip_bias } from "../../../view/chunk_view_mip_bias.js";
 import { FORWARD_VERTEX_SHADER_STRUCT } from "../../forward/FORWARD_VERTEX_SHADER_STRUCT.js";
 import { OIT_COVERAGE_MAX } from "../oit/OIT_CONSTANTS.js";
 import { AVBOIT_EXTINCT_TRANSMITTANCE } from "./AVBOIT_CONSTANTS.js";
@@ -66,7 +66,9 @@ fn main(
 
     // need to unjitter UV to account for TAA
     var vert_adjusted = vert;
-    vert_adjusted.uv = unjitter_uv(vert.uv, view.jitter);
+    let uv_bias = view_uv_derivative_bias(view.upscale_ratio);
+    let uv_ddx = dpdx(vert.uv) * uv_bias.x;
+    let uv_ddy = dpdy(vert.uv) * uv_bias.y;
 
     // linear view depth (vert.position is @builtin(position); .z is device depth) and screen uv,
     // for the volume lookup and the fog composite alike
@@ -98,7 +100,7 @@ fn main(
     var tint = vec3<f32>(1.0);
     let f_transmission = material_info.transmission_factor;
     if (f_transmission > 0.0) {
-        let t_diffuse = textureSample(texture_diffuse, texture_diffuse_sampler, vert_adjusted.uv);
+        let t_diffuse = textureSampleGrad(texture_diffuse, texture_diffuse_sampler, vert_adjusted.uv, uv_ddx, uv_ddy);
         let base_color = (t_diffuse.rgb / max(t_diffuse.a, 1e-7)) * vert.color * material_info.albedo_color.rgb;
         tint = avboit_transmission_tint(base_color, f_transmission * f32(warp.tint_from_base_color));
     }
@@ -122,7 +124,7 @@ fn main(
  */
 export const AVBOIT_DRAW_FRAGMENT_DEPENDENCIES = [
     FORWARD_VERTEX_SHADER_STRUCT.declaration_chunk,
-    chunk_unjitter_uv,
+    chunk_view_mip_bias,
     chunk_get_view_space_depth,
     chunk_sample_volumetrics,
     chunk_avboit_view_depth_to_virtual,