@woosh/meep-engine 3.15.0 → 3.17.0

package/src/shade/renderer/shader/chunk/noise/psrdnoise/chunk_srdnoise2.js

@@ -0,0 +1,59 @@
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+import { chunk_psrdnoise2_kernel } from "./chunk_psrdnoise2_kernel.js";
+
+/**
+ * 2-D simplex noise with rotating gradients and an analytic derivative — `psrdnoise` without the
+ * `p`, for fields that never need to tile.
+ *
+ * Returns `vec3(noise, gradient.x, gradient.y)`: the noise value is in `.x`, in `[-1, 1]`, and
+ * `.yz` is its exact gradient. Ask for only `.x` and the compiler drops the derivative.
+ *
+ * `alpha` turns every gradient in the field by that many radians. Animating it swirls the pattern
+ * in place — see {@link chunk_psrdnoise2_kernel} for what that buys and why it is nearly free.
+ *
+ * This is {@link chunk_psrdnoise2} with the wrap deleted, not a call into it with a zero period: it
+ * exists so a caller whose period is a runtime value it never sets does not pay for the branch and
+ * the modulo. It still repeats every 289 cells — that is the hash's modulus, not a choice — so it
+ * is "non-periodic" only in the sense that it does not tile to a period you name.
+ *
+ * psrdnoise (c) 2021 Stefan Gustavson and Ian McEwan. Published under the MIT license.
+ * @see https://github.com/stegu/psrdnoise/
+ * @type {CodeChunk}
+ */
+export const chunk_srdnoise2 = CodeChunk.from(
+    //language=WGSL
+    `
+fn srdnoise2(
+    x: vec2<f32>,
+    alpha: f32
+) -> vec3<f32> {
+    // into simplex space — an axis-aligned hexagonal grid, stretched in y so it can tile
+    let uv = vec2<f32>(x.x + x.y * 0.5, x.y);
+
+    // which simplex we are in. i0 is the base corner, o1 the offset to the second: the cell is a
+    // rhombus split along its diagonal, and which half we are in decides which corner joins
+    let i0 = floor(uv);
+    let f0 = uv - i0;
+    let o1 = select(vec2<f32>(0.0, 1.0), vec2<f32>(1.0, 0.0), f0.x > f0.y);
+
+    let i1 = i0 + o1;
+    let i2 = i0 + vec2<f32>(1.0);
+
+    // the three corners back in texture space
+    let v0 = vec2<f32>(i0.x - i0.y * 0.5, i0.y);
+    let v1 = vec2<f32>(v0.x + o1.x - o1.y * 0.5, v0.y + o1.y);
+    let v2 = vec2<f32>(v0.x + 0.5, v0.y + 1.0);
+
+    return psrdnoise2_kernel(
+        vec3<f32>(i0.x, i1.x, i2.x),
+        vec3<f32>(i0.y, i1.y, i2.y),
+        x - v0,
+        x - v1,
+        x - v2,
+        alpha
+    );
+}
+    `, [
+        chunk_psrdnoise2_kernel,
+    ]
+);

package/src/shade/renderer/shader/chunk/noise/psrdnoise/chunk_srdnoise3.d.ts

@@ -0,0 +1,23 @@
+/**
+ * 3-D simplex noise with rotating gradients and an analytic derivative — `psrdnoise` without the
+ * `p`, for fields that never need to tile.
+ *
+ * Returns `vec4(noise, gradient.xyz)`: the noise value is in `.x`, in `[-1, 1]`, and `.yzw` is its
+ * exact gradient. Ask for only `.x` and the compiler drops the derivative.
+ *
+ * `alpha` turns every gradient in the field by that many radians about a per-corner pseudo-random
+ * axis. Animating it swirls the field in place, which with the gradient is what curl noise wants —
+ * see {@link chunk_psrdnoise3_kernel}.
+ *
+ * This is {@link chunk_psrdnoise3} with the wrap deleted, not a call into it with a zero period: it
+ * exists so a caller whose period is a runtime value it never sets does not pay for the branch and
+ * the modulo. It still repeats every 289 cells — that is the hash's modulus, not a choice — so it
+ * is "non-periodic" only in the sense that it does not tile to a period you name.
+ *
+ * psrdnoise (c) 2021 Stefan Gustavson and Ian McEwan. Published under the MIT license.
+ * @see https://github.com/stegu/psrdnoise/
+ * @type {CodeChunk}
+ */
+export const chunk_srdnoise3: CodeChunk;
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_srdnoise3.d.ts.map

package/src/shade/renderer/shader/chunk/noise/psrdnoise/chunk_srdnoise3.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_srdnoise3.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/noise/psrdnoise/chunk_srdnoise3.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,8BAFU,SAAS,CAkDjB;0BAzEwB,gCAAgC"}

package/src/shade/renderer/shader/chunk/noise/psrdnoise/chunk_srdnoise3.js

@@ -0,0 +1,74 @@
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+import { chunk_psrdnoise3_kernel } from "./chunk_psrdnoise3_kernel.js";
+import { chunk_psrdnoise3_skew } from "./chunk_psrdnoise3_skew.js";
+import { chunk_psrdnoise3_unskew } from "./chunk_psrdnoise3_unskew.js";
+
+/**
+ * 3-D simplex noise with rotating gradients and an analytic derivative — `psrdnoise` without the
+ * `p`, for fields that never need to tile.
+ *
+ * Returns `vec4(noise, gradient.xyz)`: the noise value is in `.x`, in `[-1, 1]`, and `.yzw` is its
+ * exact gradient. Ask for only `.x` and the compiler drops the derivative.
+ *
+ * `alpha` turns every gradient in the field by that many radians about a per-corner pseudo-random
+ * axis. Animating it swirls the field in place, which with the gradient is what curl noise wants —
+ * see {@link chunk_psrdnoise3_kernel}.
+ *
+ * This is {@link chunk_psrdnoise3} with the wrap deleted, not a call into it with a zero period: it
+ * exists so a caller whose period is a runtime value it never sets does not pay for the branch and
+ * the modulo. It still repeats every 289 cells — that is the hash's modulus, not a choice — so it
+ * is "non-periodic" only in the sense that it does not tile to a period you name.
+ *
+ * psrdnoise (c) 2021 Stefan Gustavson and Ian McEwan. Published under the MIT license.
+ * @see https://github.com/stegu/psrdnoise/
+ * @type {CodeChunk}
+ */
+export const chunk_srdnoise3 = CodeChunk.from(
+    //language=WGSL
+    `
+fn srdnoise3(
+    x: vec3<f32>,
+    alpha: f32
+) -> vec4<f32> {
+    let uvw = psrdnoise3_skew(x);
+
+    // which simplex we are in. i0 is the base corner of the skewed cube; o1 and o2 step to the
+    // second and third corners, found by rank-ordering u, v, w — the descending order of the
+    // fractional coordinates is exactly the order the tetrahedron's corners are traversed in
+    let i0 = floor(uvw);
+    let f0 = uvw - i0;
+
+    let gt_ = step(f0.xyx, f0.yzz);
+    let lt_ = 1.0 - gt_;
+    let gt = vec3<f32>(lt_.z, gt_.xy);
+    let lt = vec3<f32>(lt_.xy, gt_.z);
+    let o1 = min(gt, lt);
+    let o2 = max(gt, lt);
+
+    let i1 = i0 + o1;
+    let i2 = i0 + o2;
+    let i3 = i0 + vec3<f32>(1.0);
+
+    // the four corners back in texture space
+    let v0 = psrdnoise3_unskew(i0);
+    let v1 = psrdnoise3_unskew(i1);
+    let v2 = psrdnoise3_unskew(i2);
+    let v3 = psrdnoise3_unskew(i3);
+
+    return psrdnoise3_kernel(
+        vec4<f32>(i0.x, i1.x, i2.x, i3.x),
+        vec4<f32>(i0.y, i1.y, i2.y, i3.y),
+        vec4<f32>(i0.z, i1.z, i2.z, i3.z),
+        x - v0,
+        x - v1,
+        x - v2,
+        x - v3,
+        alpha
+    );
+}
+    `, [
+        chunk_psrdnoise3_kernel,
+        chunk_psrdnoise3_skew,
+        chunk_psrdnoise3_unskew,
+    ]
+);

package/src/shade/renderer/shader/chunk/random/chunk_hash_to_float01.d.ts

@@ -1,7 +1,17 @@
 /**
- * Converts a 0..MAX_U32 value to a float in [0,1) range
- * Primarily used for hashing
- * https://github.com/nvpro-samples/vk_raytrace/blob/ca07abfa081eca0d0eb8d4f45a52fd59033bffab/shaders/random.glsl#L101
+ * Converts a 0..MAX_U32 value to a float in [0,1) range.
+ * Primarily used for hashing.
+ *
+ * Takes the top 24 bits of the hash onto a 2^-24 grid. The multiply is by a power of two and the
+ * integer is below 2^24, so every value is exact — no rounding, and the distribution is exactly
+ * uniform over the grid.
+ *
+ * The classic alternative, `bitcast<f32>(0x3f800000 | (hash >> 9)) - 1.0`, is equally exact and
+ * equally uniform but consumes only 23 bits, halving the number of distinct outputs (and topping
+ * out at 1 - 2^-23) for the same three instructions. There is no reason to give up the bit: the
+ * bitcast trick exists to dodge an integer-to-float conversion that modern GPUs do in one
+ * instruction anyway.
+ *
  * @type {CodeChunk}
  */
 export const chunk_hash_to_float01: CodeChunk;

package/src/shade/renderer/shader/chunk/random/chunk_hash_to_float01.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_hash_to_float01.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/random/chunk_hash_to_float01.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,oCAFU,SAAS,CASlB;0BAfyB,6BAA6B"}
+{"version":3,"file":"chunk_hash_to_float01.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/random/chunk_hash_to_float01.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;GAeG;AACH,oCAFU,SAAS,CASlB;0BAzByB,6BAA6B"}

package/src/shade/renderer/shader/chunk/random/chunk_hash_to_float01.js

@@ -1,16 +1,26 @@
 import { CodeChunk } from "../../compiler/CodeChunk.js";
 
 /**
- * Converts a 0..MAX_U32 value to a float in [0,1) range
- * Primarily used for hashing
- * https://github.com/nvpro-samples/vk_raytrace/blob/ca07abfa081eca0d0eb8d4f45a52fd59033bffab/shaders/random.glsl#L101
+ * Converts a 0..MAX_U32 value to a float in [0,1) range.
+ * Primarily used for hashing.
+ *
+ * Takes the top 24 bits of the hash onto a 2^-24 grid. The multiply is by a power of two and the
+ * integer is below 2^24, so every value is exact — no rounding, and the distribution is exactly
+ * uniform over the grid.
+ *
+ * The classic alternative, `bitcast<f32>(0x3f800000 | (hash >> 9)) - 1.0`, is equally exact and
+ * equally uniform but consumes only 23 bits, halving the number of distinct outputs (and topping
+ * out at 1 - 2^-23) for the same three instructions. There is no reason to give up the bit: the
+ * bitcast trick exists to dodge an integer-to-float conversion that modern GPUs do in one
+ * instruction anyway.
+ *
  * @type {CodeChunk}
  */
 export const chunk_hash_to_float01 = CodeChunk.from(
     //language=WGSL
     `
 fn hash_to_float01( hash:u32 ) -> f32{
-    return bitcast<f32>(0x3f800000 | (hash >> 9)) - 1.0f;
+    return f32( hash >> 8u ) * (1.0 / 16777216.0);
 }
     `
-)
+)

package/src/shade/renderer/shader/chunk/random/chunk_random_uint.d.ts

@@ -1,4 +1,12 @@
 /**
+ * The next value from the global PCG-RXS-M-XS-32 stream, seeded by `random_initialize()`.
+ *
+ * `rnd_state` holds the raw LCG state and each draw is the output permutation of it. Collapsing the
+ * two — `rnd_state = pcg(rnd_state)`, carrying the permuted output as the state — passes every
+ * distribution test but gives up the LCG's guaranteed 2^32 period: the output permutation is a
+ * bijection, so chaining it walks the cycles of a fixed permutation and a seed can land in a short
+ * one. Keep the state and the output distinct.
+ *
  * @see https://www.pcg-random.org/
  * @type {CodeChunk}
  */

package/src/shade/renderer/shader/chunk/random/chunk_random_uint.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_random_uint.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/random/chunk_random_uint.js"],"names":[],"mappings":"AAIA;;;GAGG;AACH,gCAFU,SAAS,CAejB;0BArBwB,6BAA6B"}
+{"version":3,"file":"chunk_random_uint.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/random/chunk_random_uint.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;GAWG;AACH,gCAFU,SAAS,CAgBjB;0BA/BwB,6BAA6B"}

package/src/shade/renderer/shader/chunk/random/chunk_random_uint.js

@@ -1,8 +1,17 @@
 import { CodeChunk } from "../../compiler/CodeChunk.js";
 import { chunk_random_variable_declaration } from "./chunk_random_variable_declaration.js";
-import { chunk_pcg } from "./pcg/chunk_pcg.js";
+import { chunk_pcg_advance } from "./pcg/chunk_pcg_advance.js";
+import { chunk_pcg_output } from "./pcg/chunk_pcg_output.js";
 
 /**
+ * The next value from the global PCG-RXS-M-XS-32 stream, seeded by `random_initialize()`.
+ *
+ * `rnd_state` holds the raw LCG state and each draw is the output permutation of it. Collapsing the
+ * two — `rnd_state = pcg(rnd_state)`, carrying the permuted output as the state — passes every
+ * distribution test but gives up the LCG's guaranteed 2^32 period: the output permutation is a
+ * bijection, so chaining it walks the cycles of a fixed permutation and a seed can land in a short
+ * one. Keep the state and the output distinct.
+ *
  * @see https://www.pcg-random.org/
  * @type {CodeChunk}
  */
@@ -10,13 +19,14 @@ export const chunk_random_uint = CodeChunk.from(
     //language=WGSL
     `
 fn random_uint() -> u32{
-  rnd_state = pcg(rnd_state);
+  rnd_state = pcg_advance(rnd_state);
   
-  return rnd_state;
+  return pcg_output(rnd_state);
 }
     `,
     [
         chunk_random_variable_declaration,
-        chunk_pcg,
+        chunk_pcg_advance,
+        chunk_pcg_output,
     ]
-);
+);

package/src/shade/renderer/shader/chunk/random/pcg/chunk_pcg.d.ts

@@ -1,4 +1,11 @@
 /**
+ * PCG-RXS-M-XS-32 as a one-shot hash: advance an LCG from `v` and permute the result.
+ *
+ * Use this to hash an arbitrary value. A generator that draws a *sequence* should instead keep its
+ * own state, step it with {@link chunk_pcg_advance} and permute with {@link chunk_pcg_output} —
+ * chaining `pcg` into itself makes the output double as the state, which costs the LCG's guaranteed
+ * 2^32 period.
+ *
  * @see https://www.pcg-random.org/
  * @type {CodeChunk}
  */

package/src/shade/renderer/shader/chunk/random/pcg/chunk_pcg.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_pcg.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/random/pcg/chunk_pcg.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,wBAFU,SAAS,CAclB;0BAlByB,gCAAgC"}
+{"version":3,"file":"chunk_pcg.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/random/pcg/chunk_pcg.js"],"names":[],"mappings":"AAIA;;;;;;;;;;GAUG;AACH,wBAFU,SAAS,CAelB;0BA5ByB,gCAAgC"}

package/src/shade/renderer/shader/chunk/random/pcg/chunk_pcg.js

@@ -1,6 +1,15 @@
 import { CodeChunk } from "../../../compiler/CodeChunk.js";
+import { chunk_pcg_advance } from "./chunk_pcg_advance.js";
+import { chunk_pcg_output } from "./chunk_pcg_output.js";
 
 /**
+ * PCG-RXS-M-XS-32 as a one-shot hash: advance an LCG from `v` and permute the result.
+ *
+ * Use this to hash an arbitrary value. A generator that draws a *sequence* should instead keep its
+ * own state, step it with {@link chunk_pcg_advance} and permute with {@link chunk_pcg_output} —
+ * chaining `pcg` into itself makes the output double as the state, which costs the LCG's guaranteed
+ * 2^32 period.
+ *
  * @see https://www.pcg-random.org/
  * @type {CodeChunk}
  */
@@ -9,11 +18,12 @@ export const chunk_pcg = CodeChunk.from(
     `
 fn pcg(v: u32) -> u32 {
 
-  let state = v * 747796405u + 2891336453u;
-  let word = ((state >> ((state >> 28u) + 4u)) ^ state) * 277803737u;
-  
-  return (word >> 22u) ^ word;
-  
+  return pcg_output(pcg_advance(v));
+
 }
-    `
-)
+    `,
+    [
+        chunk_pcg_advance,
+        chunk_pcg_output,
+    ]
+)

package/src/shade/renderer/shader/chunk/random/pcg/chunk_pcg_advance.d.ts

@@ -0,0 +1,17 @@
+/**
+ * The LCG state step of PCG-RXS-M-XS-32 — `state -> state * 747796405 + 2891336453`.
+ *
+ * Split out from {@link chunk_pcg} so a generator that keeps a running state can advance it and
+ * hold onto the result. That distinction matters: iterating the *state* through this LCG has a
+ * guaranteed period of 2^32, whereas feeding the permuted output ({@link chunk_pcg_output}) back in
+ * as the next state degenerates into a walk over the cycles of a fixed permutation, whose length
+ * depends on where the seed lands. Stateful generators (`random_uint`, the particle VM) advance
+ * this and permute for output; one-shot hashing of an arbitrary value still wants the fused
+ * {@link chunk_pcg}.
+ *
+ * @see https://www.pcg-random.org/
+ * @type {CodeChunk}
+ */
+export const chunk_pcg_advance: CodeChunk;
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_pcg_advance.d.ts.map

package/src/shade/renderer/shader/chunk/random/pcg/chunk_pcg_advance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_pcg_advance.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/random/pcg/chunk_pcg_advance.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH,gCAFU,SAAS,CAWlB;0BAzByB,gCAAgC"}

package/src/shade/renderer/shader/chunk/random/pcg/chunk_pcg_advance.js

@@ -0,0 +1,26 @@
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+
+/**
+ * The LCG state step of PCG-RXS-M-XS-32 — `state -> state * 747796405 + 2891336453`.
+ *
+ * Split out from {@link chunk_pcg} so a generator that keeps a running state can advance it and
+ * hold onto the result. That distinction matters: iterating the *state* through this LCG has a
+ * guaranteed period of 2^32, whereas feeding the permuted output ({@link chunk_pcg_output}) back in
+ * as the next state degenerates into a walk over the cycles of a fixed permutation, whose length
+ * depends on where the seed lands. Stateful generators (`random_uint`, the particle VM) advance
+ * this and permute for output; one-shot hashing of an arbitrary value still wants the fused
+ * {@link chunk_pcg}.
+ *
+ * @see https://www.pcg-random.org/
+ * @type {CodeChunk}
+ */
+export const chunk_pcg_advance = CodeChunk.from(
+    //language=WGSL
+    `
+fn pcg_advance(state: u32) -> u32 {
+
+  return state * 747796405u + 2891336453u;
+
+}
+    `
+)

package/src/shade/renderer/shader/chunk/random/pcg/chunk_pcg_output.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The RXS-M-XS output permutation of PCG-RXS-M-XS-32: a random-xorshift, multiply, xorshift
+ * scramble that turns a raw LCG state into a well-mixed u32.
+ *
+ * This is a bijection by construction — which is exactly why it must not be used to carry the
+ * generator's state. Split out from {@link chunk_pcg} so a stateful generator can advance its state
+ * with {@link chunk_pcg_advance} and derive each output from it without the two roles collapsing
+ * into one value.
+ *
+ * @see https://www.pcg-random.org/
+ * @type {CodeChunk}
+ */
+export const chunk_pcg_output: CodeChunk;
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_pcg_output.d.ts.map

package/src/shade/renderer/shader/chunk/random/pcg/chunk_pcg_output.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_pcg_output.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/random/pcg/chunk_pcg_output.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH,+BAFU,SAAS,CAalB;0BAzByB,gCAAgC"}

package/src/shade/renderer/shader/chunk/random/pcg/chunk_pcg_output.js

@@ -0,0 +1,26 @@
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+
+/**
+ * The RXS-M-XS output permutation of PCG-RXS-M-XS-32: a random-xorshift, multiply, xorshift
+ * scramble that turns a raw LCG state into a well-mixed u32.
+ *
+ * This is a bijection by construction — which is exactly why it must not be used to carry the
+ * generator's state. Split out from {@link chunk_pcg} so a stateful generator can advance its state
+ * with {@link chunk_pcg_advance} and derive each output from it without the two roles collapsing
+ * into one value.
+ *
+ * @see https://www.pcg-random.org/
+ * @type {CodeChunk}
+ */
+export const chunk_pcg_output = CodeChunk.from(
+    //language=WGSL
+    `
+fn pcg_output(state: u32) -> u32 {
+
+  let word = ((state >> ((state >> 28u) + 4u)) ^ state) * 277803737u;
+
+  return (word >> 22u) ^ word;
+
+}
+    `
+)

package/src/shade/renderer/shadow/map/DirectionalLightShadowmap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DirectionalLightShadowmap.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/map/DirectionalLightShadowmap.js"],"names":[],"mappings":"AAkGA;IACI;;;OAGG;IACH,cAFU,MAAM,CAEC;IAEjB;;;OAGG;IACH,cAFU,MAAM,CAEC;IAEjB,qBAAuD;IAEvD,+CA+PC;IAED,qBAYC;CAEJ;0BArWyB,gBAAgB"}
+{"version":3,"file":"DirectionalLightShadowmap.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/map/DirectionalLightShadowmap.js"],"names":[],"mappings":"AAkGA;IACI;;;OAGG;IACH,cAFU,MAAM,CAEC;IAEjB;;;OAGG;IACH,cAFU,MAAM,CAEC;IAEjB,qBAAuD;IAEvD,+CAqQC;IAED,qBAYC;CAEJ;0BA3WyB,gBAAgB"}

package/src/shade/renderer/shadow/map/DirectionalLightShadowmap.js

@@ -348,8 +348,14 @@ export class DirectionalLightShadowmap extends Shadowmap {
             camera.far = extents.z1;
 
 
-            camera.transform.rotation.copy(light_rotation);
-            camera.transform.position.copy(cascade_frustum_center);
+            // Vector3 and Quaternion are both Float64Array-backed with indexed access, so the
+            // components read straight out of them. camera.update() recomposes the matrix.
+            camera.transform.setRotation(
+                light_rotation[0], light_rotation[1], light_rotation[2], light_rotation[3]
+            );
+            camera.transform.setTranslation(
+                cascade_frustum_center[0], cascade_frustum_center[1], cascade_frustum_center[2]
+            );
 
 
             camera.update(); // make sure to re-generate view/projection matrices and frustum

package/src/shade/renderer/shadow/map/PointLightShadowmap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PointLightShadowmap.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/map/PointLightShadowmap.js"],"names":[],"mappings":"AAKA;;;;GAIG;AACH,oCAFU,MAAM,CAE0B;AAgC1C;;;;;GAKG;AACH;IAEI;;;;;OAKG;IACH,WAFU,MAAM,CAEkB;IAElC,+CAoCC;IAED,wBAOC;CACJ;0BArGyB,gBAAgB"}
+{"version":3,"file":"PointLightShadowmap.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/map/PointLightShadowmap.js"],"names":[],"mappings":"AAMA;;;;GAIG;AACH,oCAFU,MAAM,CAE0B;AAgC1C;;;;;GAKG;AACH;IAEI;;;;;OAKG;IACH,WAFU,MAAM,CAEkB;IAElC,+CAwCC;IAED,wBAOC;CACJ;0BA1GyB,gBAAgB"}

package/src/shade/renderer/shadow/map/PointLightShadowmap.js

@@ -2,6 +2,7 @@ import { assert } from "../../../../core/assert.js";
 import Vector3 from "../../../../core/geom/Vector3.js";
 import { make_octahedral_point_shadow_record } from "./POINT_SHADOW_TETRAHEDRON_LAYOUT.js";
 import { Shadowmap } from "./Shadowmap.js";
+import { t64_look_rotation } from "../../../../engine/ecs/transform/t64_look_rotation.js";
 
 /**
  * Minimum near-plane distance for point light cube-face cameras, used when `light.near_clip_distance` is 0.
@@ -82,8 +83,12 @@ export class PointLightShadowmap extends Shadowmap {
 
             assert.equal(camera.isPerspectiveCamera, true, 'point-shadow cube face must use a PerspectiveCamera');
 
-            camera.transform.position.set(px, py, pz);
-            camera.transform.rotation.lookRotation(CUBE_FACE_FORWARDS[i], CUBE_FACE_UPS[i]);
+            camera.transform.setTranslation(px, py, pz);
+            t64_look_rotation(
+                camera.transform,
+                CUBE_FACE_FORWARDS[i][0], CUBE_FACE_FORWARDS[i][1], CUBE_FACE_FORWARDS[i][2],
+                CUBE_FACE_UPS[i][0], CUBE_FACE_UPS[i][1], CUBE_FACE_UPS[i][2]
+            );
 
             camera.fov = Math.PI * 0.5;
             camera.aspect = 1;

package/src/shade/renderer/shadow/map/SpotLightShadowmap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SpotLightShadowmap.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/map/SpotLightShadowmap.js"],"names":[],"mappings":"AAUA;IAEI,+CAyCC;IAED;;;MAMC;CACJ;0BA7DyB,gBAAgB"}
+{"version":3,"file":"SpotLightShadowmap.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/map/SpotLightShadowmap.js"],"names":[],"mappings":"AAUA;IAEI,+CA6BC;IAED;;;MAMC;CACJ;0BAjDyB,gBAAgB"}

package/src/shade/renderer/shadow/map/SpotLightShadowmap.js

@@ -22,21 +22,9 @@ export class SpotLightShadowmap extends Shadowmap {
 
         assert.equal(camera.isPerspectiveCamera, true, 'spot shadow view must use a PerspectiveCamera');
 
-        // the camera keeps the authored f32-matrix Transform, so the two are copied across by
-        // component rather than by object
-        const light_transform = light.transform_global;
-
-        camera.transform.rotation.set(
-            light_transform.rotation_x,
-            light_transform.rotation_y,
-            light_transform.rotation_z,
-            light_transform.rotation_w
-        );
-        camera.transform.position.set(
-            light_transform.translation_x,
-            light_transform.translation_y,
-            light_transform.translation_z
-        );
+        // both sides are Transform64 now, so this is one buffer copy rather than a component-by-
+        // component transfer across two representations
+        camera.transform.copy(light.transform_global);
 
         camera.fov = light.angle * 2;
         camera.aspect = 1;

package/src/shade/renderer/shadow/map/TetrahedronPointLightShadowmap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TetrahedronPointLightShadowmap.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/map/TetrahedronPointLightShadowmap.js"],"names":[],"mappings":"AAWA;;;;;;;;;;;GAWG;AACH;IAEI;;;;;;OAMG;IACH,YAFU,MAAM,CAEmB;IAEnC,+CAwCC;IAED,wBAGC;IAGL;;;;;OAKG;IACH,eAFU,OAAO,CAEqC;CARrD;0BAvEyB,gBAAgB"}
+{"version":3,"file":"TetrahedronPointLightShadowmap.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/map/TetrahedronPointLightShadowmap.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;GAWG;AACH;IAEI;;;;;;OAMG;IACH,YAFU,MAAM,CAEmB;IAEnC,+CA6CC;IAED,wBAGC;IAGL;;;;;OAKG;IACH,eAFU,OAAO,CAEqC;CARrD;0BA7EyB,gBAAgB"}

package/src/shade/renderer/shadow/map/TetrahedronPointLightShadowmap.js

@@ -8,6 +8,7 @@ import {
     POINT_SHADOW_TETRA_FOV,
 } from "./POINT_SHADOW_TETRAHEDRON_LAYOUT.js";
 import { Shadowmap } from "./Shadowmap.js";
+import { t64_look_rotation } from "../../../../engine/ecs/transform/t64_look_rotation.js";
 
 /**
  * Tetrahedral point-light shadow map: the 4-frustum parallel to {@link PointLightShadowmap}.
@@ -57,10 +58,15 @@ export class TetrahedronPointLightShadowmap extends Shadowmap {
 
             assert.equal(camera.isPerspectiveCamera, true, 'tetra-shadow face must use a PerspectiveCamera');
 
-            camera.transform.position.set(px, py, pz);
-            camera.transform.rotation.lookRotation(
-                POINT_SHADOW_TETRA_FACE_FORWARDS[i],
-                POINT_SHADOW_TETRA_FACE_UPS[i]
+            camera.transform.setTranslation(px, py, pz);
+            t64_look_rotation(
+                camera.transform,
+                POINT_SHADOW_TETRA_FACE_FORWARDS[i][0],
+                POINT_SHADOW_TETRA_FACE_FORWARDS[i][1],
+                POINT_SHADOW_TETRA_FACE_FORWARDS[i][2],
+                POINT_SHADOW_TETRA_FACE_UPS[i][0],
+                POINT_SHADOW_TETRA_FACE_UPS[i][1],
+                POINT_SHADOW_TETRA_FACE_UPS[i][2]
             );
 
             // symmetric square frustum (see POINT_SHADOW_TETRA_FOV_DEGREES) — aspect 1 so the

package/src/shade/renderer/shadow/vsm/GPUViewShadowMaps.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUViewShadowMaps.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/vsm/GPUViewShadowMaps.js"],"names":[],"mappings":"AAYA;IAYI;;;;OAIG;IACH,uDAGC;IAED;;;OAGG;IACH,SAFU,mBAAmB,gBAAgB,CAAC,CAE1B;IAEpB;;OAEG;IACH,+BAEC;IAED;;OAEG;IACH,2BAAO;IA0CP,eAkBC;IAED,qBAEC;IAED,gBAEC;;CACJ;iCArHgC,uBAAuB"}
+{"version":3,"file":"GPUViewShadowMaps.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/vsm/GPUViewShadowMaps.js"],"names":[],"mappings":"AAaA;IAYI;;;;OAIG;IACH,uDAGC;IAED;;;OAGG;IACH,SAFU,mBAAmB,gBAAgB,CAAC,CAE1B;IAEpB;;OAEG;IACH,+BAEC;IAED;;OAEG;IACH,2BAAO;IA8CP,eAkBC;IAED,qBAEC;IAED,gBAEC;;CACJ;iCA1HgC,uBAAuB"}

package/src/shade/renderer/shadow/vsm/GPUViewShadowMaps.js

@@ -1,6 +1,7 @@
 import { GPUCameraContext } from "../../camera/GPUCameraContext.js";
 import { OrthographicCamera } from "../../camera/OrthographicCamera.js";
 import { VirtualShadowMap } from "./VirtualShadowMap.js";
+import { t64_look_rotation } from "../../../../engine/ecs/transform/t64_look_rotation.js";
 
 // const DEFAULT_VIRTUAL_RESOLUTION = 1024;
 const DEFAULT_VIRTUAL_RESOLUTION = 16384;
@@ -76,8 +77,12 @@ export class GPUViewShadowMaps {
         shadow_camera.top = 100;
         shadow_camera.bottom = -100;
 
-        shadow_camera.transform.position.set(0,-10,0);
-        shadow_camera.transform.rotation.lookRotation(light.direction);
+        shadow_camera.transform.setTranslation(0, -10, 0);
+        t64_look_rotation(
+            shadow_camera.transform,
+            light.direction[0], light.direction[1], light.direction[2],
+            0, 1, 0
+        );
 
         const context = new GPUCameraContext(this.#device, shadow_camera);
 

package/src/shade/renderer/volumetrics/GPUViewVolumetrics.js

@@ -286,7 +286,7 @@ export class GPUViewVolumetrics {
         const direction = sun.forward;
 
         const view_matrix = camera.view_matrix;
-        const position = camera.transform.position;
+        const position = camera.transform;
 
         // the medium lives in the froxel grid and the grid stops here, so there is nothing to
         // integrate past it
@@ -307,7 +307,7 @@ export class GPUViewVolumetrics {
                 ws_to_uvw: this.#sun_shadow_ws_to_uvw[cascade],
                 uvw_to_ws: this.#sun_shadow_uvw_to_ws[cascade],
                 light_direction: [direction.x, direction.y, direction.z],
-                camera_position: [position.x, position.y, position.z],
+                camera_position: [position.translation_x, position.translation_y, position.translation_z],
                 camera_forward,
                 fov_y: camera.fov,
                 aspect: camera.aspect,

package/src/shade/renderer/volumetrics/ParticipatingMediaVolume.d.ts

@@ -98,10 +98,10 @@ export class ParticipatingMediaVolume {
     /**
      * Defines actual scale, orientation and world position of the volume.
      * The base size of the volume is 1, centered at 0,0,0
-     * @type {Transform}
+     * @type {Transform64}
      */
-    transform: Transform;
+    transform: Transform64;
     #private;
 }
-import { Transform } from "../../../engine/ecs/transform/Transform.js";
+import { Transform64 } from "../../../engine/ecs/transform/Transform64.js";
 //# sourceMappingURL=ParticipatingMediaVolume.d.ts.map

package/src/shade/renderer/volumetrics/ParticipatingMediaVolume.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ParticipatingMediaVolume.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/ParticipatingMediaVolume.js"],"names":[],"mappings":"AAKA;IA6EI;;;;OAIG;IACH,+BAHW;QAAC,wBAAwB,CAAC;QAAC,wBAAwB,CAAC;QAAC,MAAM,CAAC;QAAC,CAAC,CAAA;KAAC,GAC9D,uBAAuB,CAalC;IAED,oDAIC;IAlGD;;;OAGG;IACH,YAFU,MAAM,EAAE,CAEK;IAEvB;;;OAGG;IACH,YAFU,MAAM,EAAE,CAEK;IAEvB;;;OAGG;IACH,QAFU,MAAM,CAEL;IAEX,UAAQ;IAER,iCAIC;IAED;;;OAGG;IACH,YAFW,uBAAuB,QAOjC;IAED;;;;;aA0BC;IAED;;;OAGG;IACH,cAHW,uBAAuB,GACrB,OAAO,CAOnB;CAyBJ;AAED,6EAKI;AAIJ;IAII,iBAEC;IAED;;;OAGG;IACH,aAFU,MAAM,EAAE,CAEM;IACxB,0BAA4B;IAC5B,uBAAyB;IAEzB;;;OAGG;IACH,gBAFU,MAAM,EAAE,CAES;IAE3B;;;OAGG;IACH,uBAFU,MAAM,EAAE,CAEgB;IAElC;;;OAGG;IACH,MAFU,MAAM,CAEP;IAET;;;OAGG;IACH,gBAAc;IAEd;;;;;;;;;OASG;IACH,mCAEC;IAED,uCAA+E;IAE/E;;;;;;OAMG;IACH,eAFU,MAAM,CAEI;IAEpB;;;;OAIG;IACH,WAFU,SAAS,CAES;;CAE/B;0BAzLyB,4CAA4C"}
+{"version":3,"file":"ParticipatingMediaVolume.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/ParticipatingMediaVolume.js"],"names":[],"mappings":"AAKA;IA6EI;;;;OAIG;IACH,+BAHW;QAAC,wBAAwB,CAAC;QAAC,wBAAwB,CAAC;QAAC,MAAM,CAAC;QAAC,CAAC,CAAA;KAAC,GAC9D,uBAAuB,CAalC;IAED,oDAIC;IAlGD;;;OAGG;IACH,YAFU,MAAM,EAAE,CAEK;IAEvB;;;OAGG;IACH,YAFU,MAAM,EAAE,CAEK;IAEvB;;;OAGG;IACH,QAFU,MAAM,CAEL;IAEX,UAAQ;IAER,iCAIC;IAED;;;OAGG;IACH,YAFW,uBAAuB,QAOjC;IAED;;;;;aA0BC;IAED;;;OAGG;IACH,cAHW,uBAAuB,GACrB,OAAO,CAOnB;CAyBJ;AAED,6EAKI;AAIJ;IAII,iBAEC;IAED;;;OAGG;IACH,aAFU,MAAM,EAAE,CAEM;IACxB,0BAA4B;IAC5B,uBAAyB;IAEzB;;;OAGG;IACH,gBAFU,MAAM,EAAE,CAES;IAE3B;;;OAGG;IACH,uBAFU,MAAM,EAAE,CAEgB;IAElC;;;OAGG;IACH,MAFU,MAAM,CAEP;IAET;;;OAGG;IACH,gBAAc;IAEd;;;;;;;;;OASG;IACH,mCAEC;IAED,uCAA+E;IAE/E;;;;;;OAMG;IACH,eAFU,MAAM,CAEI;IAEpB;;;;OAIG;IACH,WAFU,WAAW,CAES;;CAEjC;4BAzL2B,8CAA8C"}