@woosh/meep-engine 3.51.0 → 3.53.0

package/src/shade/renderer/loader/SceneBundle.js

@@ -1,111 +1,119 @@
-import { assert } from "../../../core/assert.js";
-import { m4_multiply } from "../../../core/geom/3d/mat4/m4_multiply.js";
-
-/**
- * @typedef {import("./SceneNode.js").SceneNode} SceneNode
- * @typedef {import("../animation/Skin.js").Skin} Skin
- * @typedef {import("../animation/ShadeAnimationClip.js").ShadeAnimationClip} ShadeAnimationClip
- * @typedef {import("../light/model/Light.js").Light} Light
- */
-
-/**
- * What came out of a loader: a model as a flat list of {@link SceneNode}s in pre-order, with the
- * skins, clips and lights the same file carried, each addressing nodes by index.
- *
- * Not glTF-specific by design — the bundle describes "what a loader produced", not "what was in
- * a file", and every loader ({@link load_gltf}, {@link load_usd}, {@link deserialize_scene})
- * produces one. It is pure data with no lifecycle: a model compiles from it once into a
- * {@link Prefab} (`prefab_compile`), and a prefab is what gets placed — as entities, each holding
- * a row — however many times the model appears. The bundle is read by that compile and never
- * written, so one bundle is shared by every placement, which is what the asset manager hands out.
- *
- * Pre-order is the one structural promise: a node's parent has a lower index. {@link add_node}
- * refuses anything else, so a reader composes world transforms in a single forward pass.
- */
-export class SceneBundle {
-    /**
-     * Every node of the model, parents before children.
-     *
-     * @type {SceneNode[]}
-     */
-    nodes = [];
-
-    /**
-     * Skins extracted from the asset. A skin's `joints` and `meshes` are indices into
-     * {@link nodes}. Empty if the asset has no skinned meshes.
-     *
-     * @type {Skin[]}
-     */
-    skins = [];
-
-    /**
-     * Animation clips extracted from the asset. Each channel's `target` is an index into
-     * {@link nodes}. Empty if the asset has no animations.
-     *
-     * @type {ShadeAnimationClip[]}
-     */
-    clips = [];
-
-    /**
-     * Punctual lights extracted from the asset, each with the index of the node it sits on. A
-     * light is not a node and has no place of its own; the node's transform is where it is,
-     * already turned to shine along the engine's +Z. Empty if the asset has no lights.
-     *
-     * @type {{light: Light, node: number}[]}
-     */
-    lights = [];
-
-    /**
-     * Append a node. Its parent, if it has one, must already be in the bundle — which is what
-     * keeps the list in pre-order.
-     *
-     * @param {SceneNode} node
-     * @returns {number} the node's index, what a child, a skin, a clip or a light names it by
-     */
-    add_node(node) {
-        assert.defined(node, 'node');
-        assert.equal(node.isSceneNode, true, 'node.isSceneNode !== true');
-
-        const index = this.nodes.length;
-
-        assert.lessThan(node.parent, index, `node ${index} (${node.name}) names parent ${node.parent}, which is not in the bundle yet — add parents before children`);
-
-        this.nodes.push(node);
-
-        return index;
-    }
-
-    /**
-     * The world matrix of every node, composed root-first in double precision — what a reader
-     * that wants where things are in the model's own space asks for, once.
-     *
-     * @returns {Float64Array[]} one 4x4 per node, column-major
-     */
-    compute_world_matrices() {
-        const nodes = this.nodes;
-        const count = nodes.length;
-        const worlds = new Array(count);
-
-        for (let i = 0; i < count; i++) {
-            const node = nodes[i];
-            const world = new Float64Array(16);
-            const local = node.local.matrix;
-
-            if (node.parent === -1) {
-                world.set(local);
-            } else {
-                m4_multiply(world, worlds[node.parent], local);
-            }
-
-            worlds[i] = world;
-        }
-
-        return worlds;
-    }
-}
-
-/**
- * @readonly
- * @type {boolean}
- */
-SceneBundle.prototype.isSceneBundle = true;
+import { assert } from "../../../core/assert.js";
+import { m4_multiply } from "../../../core/geom/3d/mat4/m4_multiply.js";
+
+/**
+ * @typedef {import("./SceneNode.js").SceneNode} SceneNode
+ * @typedef {import("../animation/Skin.js").Skin} Skin
+ * @typedef {import("../animation/ShadeAnimationClip.js").ShadeAnimationClip} ShadeAnimationClip
+ * @typedef {import("../light/model/Light.js").Light} Light
+ */
+
+/**
+ * What came out of a loader: a model as a flat list of {@link SceneNode}s in pre-order, with the
+ * skins, clips and lights the same file carried, each addressing nodes by index.
+ *
+ * Not glTF-specific by design — the bundle describes "what a loader produced", not "what was in
+ * a file", and every loader ({@link load_gltf}, {@link load_usd}, {@link deserialize_scene})
+ * produces one. It is pure data with no lifecycle: a model compiles from it once into a
+ * {@link Prefab} (`prefab_compile`), and a prefab is what gets placed — as entities, each holding
+ * a row — however many times the model appears. The bundle is read by that compile and never
+ * written, so one bundle is shared by every placement, which is what the asset manager hands out.
+ *
+ * Pre-order is the one structural promise: a node's parent has a lower index. {@link add_node}
+ * refuses anything else, so a reader composes world transforms in a single forward pass.
+ */
+export class SceneBundle {
+    /**
+     * Every node of the model, parents before children.
+     *
+     * @type {SceneNode[]}
+     */
+    nodes = [];
+
+    /**
+     * Skins extracted from the asset. A skin's `joints` and `meshes` are indices into
+     * {@link nodes}. Empty if the asset has no skinned meshes.
+     *
+     * @type {Skin[]}
+     */
+    skins = [];
+
+    /**
+     * Animation clips extracted from the asset. Each channel's `target` is an index into
+     * {@link nodes}. Empty if the asset has no animations.
+     *
+     * @type {ShadeAnimationClip[]}
+     */
+    clips = [];
+
+    /**
+     * Aeroelastic foliage wind rigs extracted from or generated for the asset.
+     * Each rig's `root` and each joint's `target` is an index into {@link nodes}.
+     *
+     * @type {import("../animation/foliage/FoliageWindRig.js").FoliageWindRig[]}
+     */
+    foliage_rigs = [];
+
+    /**
+     * Punctual lights extracted from the asset, each with the index of the node it sits on. A
+     * light is not a node and has no place of its own; the node's transform is where it is,
+     * already turned to shine along the engine's +Z. Empty if the asset has no lights.
+     *
+     * @type {{light: Light, node: number}[]}
+     */
+    lights = [];
+
+    /**
+     * Append a node. Its parent, if it has one, must already be in the bundle — which is what
+     * keeps the list in pre-order.
+     *
+     * @param {SceneNode} node
+     * @returns {number} the node's index, what a child, a skin, a clip or a light names it by
+     */
+    add_node(node) {
+        assert.defined(node, 'node');
+        assert.equal(node.isSceneNode, true, 'node.isSceneNode !== true');
+
+        const index = this.nodes.length;
+
+        assert.lessThan(node.parent, index, `node ${index} (${node.name}) names parent ${node.parent}, which is not in the bundle yet — add parents before children`);
+
+        this.nodes.push(node);
+
+        return index;
+    }
+
+    /**
+     * The world matrix of every node, composed root-first in double precision — what a reader
+     * that wants where things are in the model's own space asks for, once.
+     *
+     * @returns {Float64Array[]} one 4x4 per node, column-major
+     */
+    compute_world_matrices() {
+        const nodes = this.nodes;
+        const count = nodes.length;
+        const worlds = new Array(count);
+
+        for (let i = 0; i < count; i++) {
+            const node = nodes[i];
+            const world = new Float64Array(16);
+            const local = node.local.matrix;
+
+            if (node.parent === -1) {
+                world.set(local);
+            } else {
+                m4_multiply(world, worlds[node.parent], local);
+            }
+
+            worlds[i] = world;
+        }
+
+        return worlds;
+    }
+}
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+SceneBundle.prototype.isSceneBundle = true;

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

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

package/src/shade/renderer/material/standard/fragment_gbuffer.d.ts

@@ -45,6 +45,10 @@ export function build_gbuffer_pipeline_descriptor({ label, material_group, surfa
  * @returns {RenderPipelineDescriptor}
  */
 export function gbuffer_pipeline_descriptor_for_shader(label: string, shader: ShaderDescriptor): RenderPipelineDescriptor;
+/**
+ *
+ * @type {number}
+ */
 /**
  * Group 1 of every material's G-buffer pipeline: the visibility buffer and the view that drew it.
  *

package/src/shade/renderer/material/standard/fragment_gbuffer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fragment_gbuffer.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/material/standard/fragment_gbuffer.js"],"names":[],"mappings":"AAkGA;;;;;;;;GAQG;AACH,+DAHW,6BAA6B,GAC3B,2BAA2B,CAUvC;AASD;;;;;;;;;;;GAWG;AACH,qDAHW,SAAS,GACP,SAAS,CA8OrB;AAED;;;;;;;;;GASG;AACH;IAL2B,KAAK,EAArB,MAAM;IACiC,cAAc,EAArD,6BAA6B;IACV,OAAO,EAA1B,SAAS;IACP,wBAAwB,CAUpC;AAED;;;;;;;GAOG;AACH,8DAJW,MAAM,UACN,gBAAgB,GACd,wBAAwB,CA4BpC;AAnXD;;;;;;;;;GASG;AACH,qCAFU,6BAA6B,CAEmC;AAa1E;;;;GAIG;AACH,uCAFU,6BAA6B,CAEqC;AAgC5E;;;;GAIG;AACH,wCAFU,2BAA2B,CAEoE;AAoTzG;;;;GAIG;AACH,6BAFU,gBAAgB,CAMvB;8CA7Y2C,wDAAwD;4CAC1D,sDAAsD;0BAFxE,oCAAoC;yCAxCrB,iEAAiE;iCA2CzE,kCAAkC"}
+{"version":3,"file":"fragment_gbuffer.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/material/standard/fragment_gbuffer.js"],"names":[],"mappings":"AAkGA;;;;;;;;GAQG;AACH,+DAHW,6BAA6B,GAC3B,2BAA2B,CAUvC;AASD;;;;;;;;;;;GAWG;AACH,qDAHW,SAAS,GACP,SAAS,CA+OrB;AAED;;;;;;;;;GASG;AACH;IAL2B,KAAK,EAArB,MAAM;IACiC,cAAc,EAArD,6BAA6B;IACV,OAAO,EAA1B,SAAS;IACP,wBAAwB,CAUpC;AAED;;;;;;;GAOG;AACH,8DAJW,MAAM,UACN,gBAAgB,GACd,wBAAwB,CA4BpC;AA1XD;;;GAGG;AAGH;;;;;;;;;GASG;AACH,qCAFU,6BAA6B,CAEmC;AAa1E;;;;GAIG;AACH,uCAFU,6BAA6B,CAEqC;AAgC5E;;;;GAIG;AACH,wCAFU,2BAA2B,CAEoE;AAqTzG;;;;GAIG;AACH,6BAFU,gBAAgB,CAMvB;8CA9Y2C,wDAAwD;4CAC1D,sDAAsD;0BAFxE,oCAAoC;yCAxCrB,iEAAiE;iCA2CzE,kCAAkC"}

package/src/shade/renderer/material/standard/fragment_gbuffer.js

@@ -9,7 +9,7 @@ import { GEOMETRY_METADATA_STRUCT } from "../../geometry/GEOMETRY_METADATA_STRUC
 import { MESHLET_METADATA_STRUCT } from "../../geometry/meshlet/encoding/MESHLET_METADATA_STRUCT.js";
 import { chunk_node3d_flags } from "../../scene/chunk_node3d_flags.js";
 import { chunk_scene_database_access } from "../../scene/chunk_scene_database_access.js";
-import { RENDER_GLOBAL_MIP_BIAS } from "../../postprocess/taa/RENDER_GLOBAL_MIP_BIAS.js";
+import { chunk_view_mip_bias } from "../../view/chunk_view_mip_bias.js";
 import { chunk_barycentric_full } from "../../shader/chunk/geometry/triangle/chunk_barycentric_full.js";
 import { chunk_barycentric_interpolate_uv } from "../../shader/chunk/geometry/triangle/chunk_barycentric_interpolate_uv.js";
 import { chunk_compute_normal_matrix_from_m4 } from "../../shader/chunk/geometry/mat4/chunk_compute_normal_matrix_from_m4.js";
@@ -53,7 +53,7 @@ import { SHADING_MATERIAL_RESOURCE_GROUP } from "./SHADING_MATERIAL_RESOURCE_GRO
  *
  * @type {number}
  */
-const MIP_DERIVATIVE_BIAS = 1 / (1 - RENDER_GLOBAL_MIP_BIAS);
+
 
 /**
  * Group 1 of every material's G-buffer pipeline: the visibility buffer and the view that drew it.
@@ -146,7 +146,7 @@ struct GBufferOutput {
 }
 
 // this is a multiplies applies to gradients before invoking texture sampling
-const MIP_BIAS = ${MIP_DERIVATIVE_BIAS.toFixed(8)};
+
 
 @fragment
 fn main(
@@ -228,7 +228,7 @@ fn main(
     var uv_info = barycentric_interpolate_uv(barycentric, geometry_vertex_uv_0, geometry_vertex_uv_1, geometry_vertex_uv_2);
 
     // figure out final mip bias
-    let uv_derivative_bias = MIP_BIAS / view.upscale_ratio;
+    let uv_derivative_bias = view_uv_derivative_bias(view.upscale_ratio);
 
     // bias UV derivatives to supersample textures
     uv_info.ddx *= uv_derivative_bias.x;
@@ -367,7 +367,8 @@ fn main(
         chunk_rgbe9995_encode,
         chunk_dither_color_8bit_triangle_noise,
         chunk_scene_database_access,
-        chunk_node3d_flags,
+        chunk_node3d_flags,
+        chunk_view_mip_bias,
     ]
     );
 }

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":"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"}
+{"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

@@ -1120,7 +1120,9 @@ export class GPUParticleSystem {
         this.atlas_sampler = device.createSampler({
             label: "particles/atlas_sampler",
             magFilter: "linear",
-            minFilter: "linear",
+            minFilter: "linear",
+            mipmapFilter: "linear",
+            maxAnisotropy: 16,
             addressModeU: "clamp-to-edge",
             addressModeV: "clamp-to-edge",
         });

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":"AAyMA,2EAAsI;AACtI,8EAA2I;AAC3I,6EAA8I;AAE9I,mEAAmE;AACnE,yEAAwD;AAExD,mDAAmD;AACnD,2DAAsD;yCAjNb,iEAAiE;4CAa9D,sDAAsD;iCAFjE,kCAAkC"}

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

@@ -13,7 +13,8 @@ import { ShaderDescriptor } from "../../shader/ShaderDescriptor.js";
 import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
 import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
 import { SAMPLER_LINEAR_UPSCALE } from "../../texture/SAMPLER_LINEAR_UPSCALE.js";
-import { VIEW_UNIFORM_STRUCT } from "../../view/VIEW_UNIFORM_STRUCT.js";
+import { VIEW_UNIFORM_STRUCT } from "../../view/VIEW_UNIFORM_STRUCT.js";
+import { chunk_view_mip_bias } from "../../view/chunk_view_mip_bias.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";
@@ -110,7 +111,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 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
@@ -130,7 +134,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);
@@ -166,7 +170,8 @@ fn fs_main(in : ParticleVertexOut) -> ParticleAVBOITDrawOutput {
     chunk_sample_volumetrics,
     chunk_avboit_view_depth_to_virtual,
     chunk_avboit_footprint_bias,
-    chunk_avboit_sample_transmittance,
+    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 "__#200@#preprocess_tensor_descriptor"(render_w: any, render_h: any): TextureResourceDescriptor;
+    static "__#201@#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,

package/src/shade/renderer/rasterize/native/oit/oit_resolve_fragment_body.js

@@ -2,7 +2,7 @@ import { chunk_sample_volumetrics } from "../../../deferred/chunk_sample_volumet
 import {
     chunk_resolve_power_moments_4
 } from "../../../shader/chunk/mboit/moments/power/chunk_resolve_power_moments_4.js";
-import { chunk_unjitter_uv } from "../../../shader/chunk/texture/chunk_unjitter_uv.js";
+
 import { FORWARD_VERTEX_SHADER_STRUCT } from "../../forward/FORWARD_VERTEX_SHADER_STRUCT.js";
 import { chunk_oit_linearize_depth } from "./chunk_oit_linearize_depth.js";
 import { OIT_COVERAGE_MAX } from "./OIT_CONSTANTS.js";
@@ -51,7 +51,7 @@ fn main(
 
     // need to unjitter UV to account for TAA
     var vert_adjusted = vert;
-    vert_adjusted.uv = unjitter_uv(vert.uv, view.jitter);
+
 
     let shaded = forward_shade_standard_fragment(vert_adjusted, front_facing, ${OIT_RESOLVE_LIGHT_BUDGET}u, ${OIT_RESOLVE_LIGHT_BUDGET}u);
 
@@ -99,7 +99,7 @@ export const OIT_RESOLVE_FRAGMENT_DEPENDENCIES = [
     FORWARD_VERTEX_SHADER_STRUCT.declaration_chunk,
     chunk_resolve_power_moments_4,
     chunk_oit_linearize_depth,
-    chunk_unjitter_uv,
+
     chunk_sample_volumetrics,
 ];
 

package/src/shade/renderer/rasterize/native/oit/shader_oit_generate_moments.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_oit_generate_moments.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/oit/shader_oit_generate_moments.js"],"names":[],"mappings":"AAgJA;;;;GAIG;AACH,0CAFU,sBAAsB,CAgE7B;uCArMoC,iCAAiC"}
+{"version":3,"file":"shader_oit_generate_moments.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/oit/shader_oit_generate_moments.js"],"names":[],"mappings":"AAmJA;;;;GAIG;AACH,0CAFU,sBAAsB,CAgE7B;uCAxMoC,iCAAiC"}