@woosh/meep-engine 3.55.0 → 3.57.0

package/src/shade/renderer/camera/OrbitalCameraController.d.ts

@@ -1,63 +1,2 @@
-export class OrbitalCameraController {
-    /**
-     *
-     * @param {PerspectiveCamera} camera
-     * @param {HTMLElement} domElement
-     */
-    constructor(camera: PerspectiveCamera, domElement: HTMLElement);
-    pointer: PointerDevice;
-    keyboard: KeyboardDevice;
-    /**
-     * @type {PerspectiveCamera}
-     */
-    camera: PerspectiveCamera;
-    /**
-     * phi, theta
-     * @type {*}
-     */
-    rotation_delta: any;
-    /**
-     *
-     * @type {Vector3}
-     */
-    pan_offset: Vector3;
-    /**
-     * phi, theta, radius
-     * @type {*}
-     */
-    spherical: any;
-    /**
-     *
-     * @type {number}
-     */
-    movement_speed_scale: number;
-    distanceLimits: NumericInterval;
-    distance: number;
-    distance_delta: number;
-    target: Vector3;
-    /**
-     *
-     * @param {Vector3} from
-     * @param {Vector3} to
-     */
-    look(from: Vector3, to: Vector3): void;
-    /**
-     *
-     * @param {Transform64} transform
-     */
-    from_transform(transform: Transform64): void;
-    /**
-     *
-     * @param {number} delta_x
-     * @param {number} delta_y
-     */
-    pan(delta_x: number, delta_y: number): void;
-    update(): void;
-    #private;
-}
-import { PointerDevice } from "../../../engine/input/devices/PointerDevice.js";
-import KeyboardDevice from "../../../engine/input/devices/KeyboardDevice.js";
-import Vector3 from "../../../core/geom/Vector3.js";
-import { NumericInterval } from "../../../core/math/interval/NumericInterval.js";
-import { Transform64 } from "../../../engine/ecs/transform/Transform64.js";
+export { OrbitalCameraController } from "./orbital/OrbitalCameraController.js";
 //# sourceMappingURL=OrbitalCameraController.d.ts.map

package/src/shade/renderer/camera/OrbitalCameraController.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"OrbitalCameraController.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/camera/OrbitalCameraController.js"],"names":[],"mappings":"AAwBA;IAiKI;;;;OAIG;IACH,mDAFW,WAAW,EA4DrB;IA/ND,uBAAkC;IAClC,yBAA6C;IAE7C;;OAEG;IACH,0BAAM;IAEN;;;OAGG;IACH,oBAAqC;IAErC;;;OAGG;IACH,YAFU,OAAO,CAEU;IAE3B;;;OAGG;IACH,eAAwC;IAExC;;;OAGG;IACH,sBAFU,MAAM,CAES;IAEzB,gCAAgD;IAEhD,iBAAY;IAEZ,uBAAmB;IAEnB,gBAAuB;IAMvB;;;;OAIG;IACH,WAHW,OAAO,MACP,OAAO,QA+BjB;IAED;;;OAGG;IACH,0BAFW,WAAW,QAsBrB;IAwBD;;;;OAIG;IACH,aAHW,MAAM,WACN,MAAM,QA2BhB;IAyHD,eAoEC;;CACJ;8BAxW6B,gDAAgD;2BADnD,iDAAiD;oBAVxD,+BAA+B;gCAGnB,gDAAgD;4BAMpD,8CAA8C"}
+{"version":3,"file":"OrbitalCameraController.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/camera/OrbitalCameraController.js"],"names":[],"mappings":""}

package/src/shade/renderer/camera/OrbitalCameraController.js

@@ -1,374 +1 @@
-import { assert } from "../../../core/assert.js";
-import { v3_matrix4_rotate } from "../../../core/geom/vec3/v3_matrix4_rotate.js";
-import Vector3 from "../../../core/geom/Vector3.js";
-import { clamp } from "../../../core/math/clamp.js";
-import { clamp01 } from "../../../core/math/clamp01.js";
-import { NumericInterval } from "../../../core/math/interval/NumericInterval.js";
-import { lerp } from "../../../core/math/lerp.js";
-import { current_time_in_seconds } from "../../../core/time/current_time_in_seconds.js";
-import { AnimationCurve } from "../../../engine/animation/curve/AnimationCurve.js";
-import { Keyframe } from "../../../engine/animation/curve/Keyframe.js";
-import { t64_equals_components } from "../../../engine/ecs/transform/t64_equals_components.js";
-import { Transform64 } from "../../../engine/ecs/transform/Transform64.js";
-import KeyboardDevice from "../../../engine/input/devices/KeyboardDevice.js";
-import { PointerDevice } from "../../../engine/input/devices/PointerDevice.js";
-
-const scratch_transform = new Transform64();
-
-const ZOOM_CURVE = AnimationCurve.from([
-    Keyframe.from(0, 0.01),
-    Keyframe.from(0.5, 0.2),
-    Keyframe.from(1, 1)
-]);
-ZOOM_CURVE.alignAllTangents();
-
-export class OrbitalCameraController {
-    pointer = new PointerDevice(null);
-    keyboard = new KeyboardDevice(document.body);
-
-    /**
-     * @type {PerspectiveCamera}
-     */
-    camera
-
-    /**
-     * phi, theta
-     * @type {*}
-     */
-    rotation_delta = new Float32Array(2);
-
-    /**
-     *
-     * @type {Vector3}
-     */
-    pan_offset = new Vector3();
-
-    /**
-     * phi, theta, radius
-     * @type {*}
-     */
-    spherical = new Float32Array([0, 0, 0]);
-
-    /**
-     *
-     * @type {number}
-     */
-    movement_speed_scale = 1;
-
-    distanceLimits = new NumericInterval(0.1, 1000);
-
-    distance = 1
-
-    distance_delta = 0;
-
-    target = new Vector3();
-
-    #last_recorded_transform = new Transform64();
-
-    #last_update_time = 0;
-
-    /**
-     *
-     * @param {Vector3} from
-     * @param {Vector3} to
-     */
-    look(from, to) {
-        assert.defined(from, 'from')
-        assert.defined(to, 'to')
-
-        this.target.copy(to);
-
-        const radius = Vector3.distance(from, to);
-
-        this.distance = radius;
-
-        const x = from.x - to.x;
-        const y = from.y - to.y;
-        const z = from.z - to.z;
-
-        let theta = 0;
-        let phi = 0;
-
-        if (radius > 1e-9) {
-
-            theta = Math.atan2(x, z);
-            phi = Math.acos(clamp(y / radius, -1, 1));
-
-        }
-
-        this.spherical[0] = phi;
-        this.spherical[1] = theta;
-        this.spherical[2] = radius;
-
-        this.#last_recorded_transform.copy(this.camera.transform);
-    }
-
-    /**
-     *
-     * @param {Transform64} transform
-     */
-    from_transform(transform) {
-
-        // forward is a fresh view over the transform buffer; look() wants Vector3s, so the
-        // two endpoints are built as such rather than passed through as arrays
-        const forward = transform.forward;
-
-        const t = new Vector3(
-            forward[0] * this.distance + transform.translation_x,
-            forward[1] * this.distance + transform.translation_y,
-            forward[2] * this.distance + transform.translation_z
-        );
-
-        const from = new Vector3(
-            transform.translation_x,
-            transform.translation_y,
-            transform.translation_z
-        );
-
-        this.look(from, t);
-
-    }
-
-    /**
-     *
-     * @param {number} distance
-     * @param {Float32Array} matrix
-     */
-    #pan_left(distance, matrix) {
-        this.pan_offset[0] -= distance * matrix[0];
-        this.pan_offset[1] -= distance * matrix[1];
-        this.pan_offset[2] -= distance * matrix[2];
-    }
-
-    /**
-     *
-     * @param {number} distance
-     * @param {Float32Array} matrix
-     */
-    #pan_up(distance, matrix) {
-        this.pan_offset[0] -= distance * matrix[4];
-        this.pan_offset[1] -= distance * matrix[5];
-        this.pan_offset[2] -= distance * matrix[6];
-    }
-
-    /**
-     *
-     * @param {number} delta_x
-     * @param {number} delta_y
-     */
-    pan(delta_x, delta_y) {
-
-        const transform = this.camera.transform;
-
-        const offest = new Vector3()
-
-        offest.set(transform.translation_x, transform.translation_y, transform.translation_z);
-        offest.sub(this.target);
-
-        const target_distance = offest.length();
-
-        const movement_scale = target_distance * Math.tan(this.camera.fov / 2);
-
-        const element = this.pointer.domElement;
-
-        const t_matrix = this.camera.transform;
-
-        this.#pan_left(
-            2 * delta_x * movement_scale / element.clientHeight,
-            t_matrix
-        );
-        this.#pan_up(
-            2 * delta_y * movement_scale / element.clientHeight,
-            t_matrix
-        );
-    }
-
-    /**
-     *
-     * @param {PerspectiveCamera} camera
-     * @param {HTMLElement} domElement
-     */
-    constructor(camera, domElement) {
-        this.camera = camera;
-
-        this.pointer.domElement = domElement;
-
-        this.pointer.start();
-
-        this.keyboard.domElement = domElement;
-        this.keyboard.start();
-
-        this.from_transform(camera.transform);
-
-        this.pointer.on.drag.add(
-            /**
-             *
-             * @param {Vector3} position
-             * @param {Vector3} origin
-             * @param {Vector3} last_position
-             * @param {PointerEvent} event
-             */
-            (position, origin, last_position, event) => {
-                const delta = last_position.clone().sub(position);
-
-                const rotation_scale = Math.PI * 2 / domElement.clientHeight;
-
-
-                if (this.pointer.mouseButtonRight.is_down) {
-
-                    this.pan(delta.x, delta.y);
-
-                } else {
-                    this.rotation_delta[1] += delta.x * rotation_scale;
-                    this.rotation_delta[0] += delta.y * rotation_scale;
-                }
-
-            });
-
-        this.pointer.on.wheel.add(
-            /**
-             *
-             * @param {Vector3} delta
-             */
-            (delta) => {
-                const limit_position = clamp01(this.distanceLimits.normalizeValue(this.distance));
-
-                let delta_max = delta.x;
-                if (Math.abs(delta.y) > Math.abs(delta_max)) {
-                    delta_max = delta.y;
-                }
-                if (Math.abs(delta.z) > Math.abs(delta_max)) {
-                    delta_max = delta.z;
-                }
-
-                const scale = ZOOM_CURVE.evaluate(limit_position);
-
-                this.distance_delta += delta_max * 0.01 * scale * this.distanceLimits.span;
-            });
-
-    }
-
-    /**
-     *
-     * @return {number}
-     */
-    get #movement_speed() {
-
-        const t = clamp01(this.distanceLimits.normalizeValue(this.distance));
-        const zoom_scale = lerp(1, 2, t);
-
-        return this.movement_speed_scale * zoom_scale;
-
-    }
-
-    /**
-     *
-     * @param {number} time_delta
-     */
-    #process_keyboard_state(time_delta) {
-
-        const keyboard = this.keyboard;
-
-        const z = (keyboard.keys.w.is_down ? 1 : 0) + (keyboard.keys.s.is_down ? -1 : 0);
-        const x = (keyboard.keys.a.is_down ? 1 : 0) + (keyboard.keys.d.is_down ? -1 : 0);
-
-        const movement_speed = this.#movement_speed;
-
-        const local_offset_vector = new Vector3(x, 0, z);
-
-        if (local_offset_vector.isZero()) {
-            // no displacement
-            return;
-        }
-
-        const target_vector_length =
-            local_offset_vector.length()
-            * movement_speed
-            * time_delta;
-
-        local_offset_vector.normalize();
-
-        const global_offset_vector = new Vector3();
-
-        v3_matrix4_rotate(
-            global_offset_vector, 0,
-            local_offset_vector.x, local_offset_vector.y, local_offset_vector.z,
-            this.camera.transform
-        );
-
-        global_offset_vector.multiplyScalar(target_vector_length);
-
-        this.pan_offset.add(global_offset_vector);
-    }
-
-
-    update() {
-        const t_now = current_time_in_seconds();
-
-        const time_delta = t_now - this.#last_update_time;
-
-        this.#process_keyboard_state(time_delta);
-
-        this.#last_update_time = t_now;
-
-
-        const camera_transform = this.camera.transform;
-
-        if (!t64_equals_components(this.#last_recorded_transform, camera_transform)) {
-
-            // camera changed outside our control, update target
-            this.from_transform(camera_transform);
-
-        } else {
-
-            this.distance += this.distance_delta;
-            this.distance = clamp(this.distance, this.distanceLimits.min, this.distanceLimits.max);
-
-            this.spherical[0] += this.rotation_delta[0];
-            this.spherical[1] += this.rotation_delta[1];
-
-
-            const EPS = 0.000001;
-            this.spherical[0] = Math.max(EPS, Math.min(Math.PI - EPS, this.spherical[0]));
-
-            const phi = this.spherical[0];
-            const theta = this.spherical[1];
-            const radius = this.distance;
-
-            const sinPhiRadius = Math.sin(phi) * radius;
-
-            const offset = new Vector3(
-                sinPhiRadius * Math.sin(theta),
-                Math.cos(phi) * radius,
-                sinPhiRadius * Math.cos(theta)
-            );
-
-            this.target.add(this.pan_offset);
-
-            scratch_transform.copy(camera_transform);
-
-            scratch_transform.setTranslation(
-                this.target.x + offset.x,
-                this.target.y + offset.y,
-                this.target.z + offset.z
-            );
-
-
-            scratch_transform.lookAt(this.target);
-
-            // write out in one operation
-            camera_transform.copy(scratch_transform);
-
-        }
-
-        // reset
-        this.rotation_delta[0] = 0;
-        this.rotation_delta[1] = 0;
-
-        this.distance_delta = 0;
-
-        this.pan_offset.set(0, 0, 0);
-
-        this.#last_recorded_transform.copy(camera_transform);
-    }
-}
+export { OrbitalCameraController } from "./orbital/OrbitalCameraController.js";

package/src/shade/renderer/deferred/indirect/chunk_lpv_2d_cache_sample_irradiance.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_lpv_2d_cache_sample_irradiance.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/deferred/indirect/chunk_lpv_2d_cache_sample_irradiance.js"],"names":[],"mappings":"AAeA,kDAaG;AAEH,kDAgDE;AAEF,6DAwBO;6BAvGsB,mCAAmC;0BAYtC,oCAAoC"}
+{"version":3,"file":"chunk_lpv_2d_cache_sample_irradiance.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/deferred/indirect/chunk_lpv_2d_cache_sample_irradiance.js"],"names":[],"mappings":"AAeA,kDAaG;AAEH,kDAgDE;AAEF,6DA2BO;6BA1GsB,mCAAmC;0BAYtC,oCAAoC"}

package/src/shade/renderer/deferred/indirect/chunk_lpv_2d_cache_sample_irradiance.js

@@ -97,6 +97,9 @@ fn lpv_2d_cache_sample_irradiance(
     );
         
     // TODO apply convolution to specular component as well, see https://github.com/TheRealMJP/BakingLab/blob/c3868af50d72afc13cdfe513a1e0c6a4fafdac8c/BakingLab/Mesh.hlsl#L336
+    if (coord.cell == INVALID_TET) {
+        return vec3(0.0);
+    }
     return lpv_mesh_interpolate_probe_irradiance(normal, coord.barycentric, coord.cell);
 }
 `, [

package/src/shade/renderer/deferred/indirect/chunk_lpv_sample_light.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_lpv_sample_light.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/deferred/indirect/chunk_lpv_sample_light.js"],"names":[],"mappings":"AAmCA;;GAEG;AACH,qCAFU,SAAS,CAsDjB;0BA9DwB,oCAAoC"}
+{"version":3,"file":"chunk_lpv_sample_light.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/deferred/indirect/chunk_lpv_sample_light.js"],"names":[],"mappings":"AAoCA;;GAEG;AACH,qCAFU,SAAS,CA0DjB;0BAnEwB,oCAAoC"}

package/src/shade/renderer/deferred/indirect/chunk_lpv_sample_light.js

@@ -26,7 +26,8 @@ import {
     chunk_sh3_color_get_radiance_with_GGX
 } from "../../shader/chunk/spherical_harmonics/chunk_sh3_color_get_radiance_with_GGX.js";
 import { chunk_sh3_convolve_with_GGX } from "../../shader/chunk/spherical_harmonics/chunk_sh3_convolve_with_GGX.js";
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { INVALID_TET_DECLARATION } from "../../shader/chunk/light/lpv/INVALID_TET_DECLARATION.js";
 import { LPV_SAMPLE_COORDINATES } from "./chunk_lpv_2d_cache_sample_irradiance.js";
 import {
     LPV_ATLAS_RADIANCE_RESOURCE,
@@ -46,6 +47,9 @@ fn lpv_sample_light(
     roughness: f32,
 ) -> mat2x3<f32> {
     
+    if (coord.cell == INVALID_TET) {
+        return mat2x3(vec3(0.0), vec3(0.0));
+    }
     let radiance_sh = lpv_mesh_interpolation_probe_sh(
          coord.barycentric, coord.cell
     );
@@ -80,6 +84,7 @@ fn lpv_sample_light(
     );
 }
     `, [
+        INVALID_TET_DECLARATION,
         RECIPROCAL_PI_DECLARATION,
         LPV_SAMPLE_COORDINATES.declaration_chunk,
         chunk_lpv_mesh_interpolate_radiance_via_atlas,

package/src/shade/renderer/dynamic/shader_dynamic_mesh_avboit_splat.js

@@ -113,7 +113,7 @@ fn fs_main(in : DynamicMeshAVBOITVertexOut, @builtin(sample_mask) sample_mask :
 
     // in.clip is @builtin(position): .xy the low-resolution pixel
     let texel = vec2<u32>(in.clip.xy);
-    let column = (texel.y * warp.voxel_width + texel.x) * warp.physical_count;
+    let column = texel.y * warp.voxel_width + texel.x;
 
     // linear splat between the two slices around the fragment
     let c = p - 0.5;

package/src/shade/renderer/fluid/GPUFluidCascade.d.ts

@@ -110,8 +110,8 @@ export const GPU_FLUID_CASCADE_GROWTH_EXPONENT_LIMIT: number;
  * transients: the pass creates them in the frame graph, which pools them, so the steps of every
  * cascade of one resolution share one set of memory. The pressure solve keeps its level buffers itself (`GPUFluidPressureSolve`).
  *
- * At 64×32×64 a step dispatches the ghosts, 4 MAC passes, the solve's 4 weight passes and 10 a
- * V-cycle: 29 at {@link GPU_FLUID_CASCADE_V_CYCLES}, and the curl with confinement.
+ * At 64×32×64 a step dispatches the ghosts, 4 MAC passes, and 10 passes a
+ * V-cycle: 25 at {@link GPU_FLUID_CASCADE_V_CYCLES}, and the curl with confinement.
  *
  * A face with a solid cell on either side is pinned: every pass carries its value in A through, so A
  * holds the wall's velocity there. Whoever writes the solid flags writes that velocity too: the

package/src/shade/renderer/fluid/GPUFluidCascade.d.ts.map

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

package/src/shade/renderer/fluid/GPUFluidCascade.js

@@ -202,8 +202,8 @@ function restrict_value() {
  * transients: the pass creates them in the frame graph, which pools them, so the steps of every
  * cascade of one resolution share one set of memory. The pressure solve keeps its level buffers itself (`GPUFluidPressureSolve`).
  *
- * At 64×32×64 a step dispatches the ghosts, 4 MAC passes, the solve's 4 weight passes and 10 a
- * V-cycle: 29 at {@link GPU_FLUID_CASCADE_V_CYCLES}, and the curl with confinement.
+ * At 64×32×64 a step dispatches the ghosts, 4 MAC passes, and 10 passes a
+ * V-cycle: 25 at {@link GPU_FLUID_CASCADE_V_CYCLES}, and the curl with confinement.
  *
  * A face with a solid cell on either side is pinned: every pass carries its value in A through, so A
  * holds the wall's velocity there. Whoever writes the solid flags writes that velocity too: the
@@ -1176,12 +1176,14 @@ export class GPUFluidCascade {
         }
 
         mac.record_advect(encoder, velocity, forward, advected, solid, forcing, confinement, parent, ghosts);
-        mac.record_divergence(encoder, advected, solid, rhs);
+        const level0_words = this.#solve.level0_words(encoder.device, this.#resolution);
+        mac.record_divergence(encoder, advected, solid, rhs, level0_words);
 
         const inputs = this.#solve_inputs;
         inputs.rhs = rhs;
         inputs.solid = solid;
         inputs.ghost_pressure = ghosts.pressure;
+        inputs.level0_weights_ready = true;
 
         if (record.arm === GPUFluidCascadePressureArm.VCycles) {
             inputs.cycles = record.count;
@@ -1194,6 +1196,7 @@ export class GPUFluidCascade {
         inputs.rhs = null;
         inputs.solid = null;
         inputs.ghost_pressure = null;
+        inputs.level0_weights_ready = false;
 
         mac.record_gradient(encoder, advected, this.#pressure, solid, velocity, ghosts);