@woosh/meep-engine 3.0.0 → 3.0.1

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

@@ -1,234 +1,234 @@
-import { m4_invert } from "../../../core/geom/3d/mat4/m4_invert.js";
-import { m4_multiply } from "../../../core/geom/3d/mat4/m4_multiply.js";
-import { mat4 } from "gl-matrix";
-import { slice_flat_array } from "../util/slice_flat_array.js";
-import { queue_typed_buffer_update } from "../shader/type/queue_typed_buffer_update.js";
-import { GPUTypedBuffer } from "../buffer/GPUTypedBuffer.js";
-import { CAMERA_UNIFORM_STRUCT } from "./CAMERA_UNIFORM_STRUCT.js";
-import { compute_device_depth_to_view_space_depth_params } from "./compute_device_depth_to_view_space_depth_params.js";
-
-let id_counter = 0;
-
-export class GPUCameraContext {
-
-    #id = id_counter++;
-
-    get id() {
-        return this.#id;
-    }
-
-    /**
-     * @returns {GPUBuffer}
-     */
-    get gpu_buffer() {
-        return this.buffer.buffer;
-    }
-
-    /**
-     * @type {GPUTypedBuffer}
-     */
-    buffer;
-
-    /**
-     * @type {GPUDevice}
-     */
-    #device
-
-    /**
-     * @type {Camera}
-     */
-    #camera
-
-
-    /**
-     * Final view projection matrix will be offset by this amount in NDC units
-     * @type {Float32Array}
-     */
-    #view_offset = new Float32Array([0, 0]);
-
-    /**
-     *
-     * @type {Float32Array}
-     */
-    #view_projection_matrix = new Float32Array(16);
-
-    get view_projection_matrix() {
-        return this.#view_projection_matrix;
-    }
-
-    /**
-     *
-     * @param {number} x
-     * @param {number} y
-     */
-    setViewportOffset(x, y) {
-        this.#view_offset[0] = x;
-        this.#view_offset[1] = y;
-    }
-
-    /**
-     *
-     * @param {Camera} v
-     */
-    set camera(v) {
-        this.#camera = v;
-    }
-
-    /**
-     *
-     * @return {Camera}
-     */
-    get camera() {
-        return this.#camera;
-    }
-
-    /**
-     *
-     * @param {GPUDevice} device
-     * @param {Camera} camera
-     */
-    constructor(device, camera) {
-        this.#device = device;
-        this.#camera = camera;
-        this.initialize();
-    }
-
-    clone() {
-        const r = new GPUCameraContext(this.#device, this.#camera.clone());
-
-        r.copy(this);
-
-        return r;
-    }
-
-    /**
-     *
-     * @param {GPUCameraContext} other
-     * @param {ShadeGPUCommandContext} [command_ctx]
-     */
-    copy(other, command_ctx) {
-        this.#camera.copy(other.camera);
-
-        const device = this.#device;
-
-
-        const source = other.buffer.buffer;
-        const destination = this.buffer.buffer;
-
-
-        if (command_ctx === undefined) {
-            const encoder = device.createCommandEncoder();
-
-            encoder.copyBufferToBuffer(
-                source, 0,
-                destination, 0,
-                destination.size
-            );
-
-            device.queue.submit([encoder.finish()]);
-
-        } else {
-
-            command_ctx.copyBufferToBuffer(
-                source, 0,
-                destination, 0,
-                destination.size
-            );
-
-        }
-
-    }
-
-    initialize() {
-
-        this.buffer = GPUTypedBuffer.create({
-            device: this.#device,
-            label: `camera ${this.#id}`,
-            type: CAMERA_UNIFORM_STRUCT,
-            usage: GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC
-        });
-    }
-
-    destroy() {
-        this.buffer.destroy();
-    }
-
-    update() {
-        this.#write_update();
-    }
-
-    /**
-     *
-     */
-    #write_update() {
-
-        const camera = this.#camera;
-        camera.update();
-
-        const projection_matrix = new Float64Array(16);
-        projection_matrix.set(camera.projection_matrix);
-
-        // Signs are chosen so a positive offset shifts rendered content in the +UV direction
-        // (right/down), which is what the temporal consumers (TAA/NSS un-jitter,
-        // chunk_unjitter_uv) assume. The perspective divide negates whatever is added here:
-        // m[11] == -1 makes clip.w = -z_view, so adding c at m[8]/m[9] shifts NDC by -c —
-        // hence "-=" for x (NDC x aligns with UV x) and "+=" for y (NDC y is UV-flipped,
-        // the two negations cancel).
-        projection_matrix[8] -= this.#view_offset[0];
-        projection_matrix[9] += this.#view_offset[1];
-
-        // build view-projection matrix
-        const view_projection_matrix = this.#view_projection_matrix;
-        m4_multiply(view_projection_matrix, projection_matrix, camera.view_matrix);
-
-        const device = this.#device;
-        const queue = device.queue;
-
-        const transform_matrix = camera.transform.matrix;
-
-
-        const transform_inverse = mat4.create();
-        m4_invert(transform_inverse, transform_matrix);
-
-        const projection_matrix_inverse = mat4.create();
-        m4_invert(projection_matrix_inverse, projection_matrix);
-
-
-        const view_projection_matrix_inverse = mat4.create();
-        m4_invert(view_projection_matrix_inverse, view_projection_matrix);
-
-
-        const device_depth_to_view_space = new Float32Array(4);
-        compute_device_depth_to_view_space_depth_params(
-            device_depth_to_view_space,
-            camera,
-        );
-
-        const view_matrix_inverse = mat4.create();
-        m4_invert(view_matrix_inverse, camera.view_matrix);
-
-        queue_typed_buffer_update(
-            queue,
-            this.buffer,
-            {
-                view_matrix: camera.view_matrix,
-                view_matrix_inverse: view_matrix_inverse,
-                transform: transform_matrix,
-                transform_inverse,
-                projection_matrix,
-                projection_matrix_inverse,
-                view_projection_matrix,
-                view_projection_matrix_inverse,
-                frustum: slice_flat_array(
-                    camera.frustum,
-                    0,
-                    4,
-                    6
-                ),
-                device_depth_to_view_space,
-                clip_near_far: [camera.near, camera.far]
-            }
-        );
-
-    }
+import { m4_allocate } from "../../../core/geom/3d/mat4/m4_allocate.js";
+import { m4_invert } from "../../../core/geom/3d/mat4/m4_invert.js";
+import { m4_multiply } from "../../../core/geom/3d/mat4/m4_multiply.js";
+import { slice_flat_array } from "../util/slice_flat_array.js";
+import { queue_typed_buffer_update } from "../shader/type/queue_typed_buffer_update.js";
+import { GPUTypedBuffer } from "../buffer/GPUTypedBuffer.js";
+import { CAMERA_UNIFORM_STRUCT } from "./CAMERA_UNIFORM_STRUCT.js";
+import { compute_device_depth_to_view_space_depth_params } from "./compute_device_depth_to_view_space_depth_params.js";
+
+let id_counter = 0;
+
+export class GPUCameraContext {
+
+    #id = id_counter++;
+
+    get id() {
+        return this.#id;
+    }
+
+    /**
+     * @returns {GPUBuffer}
+     */
+    get gpu_buffer() {
+        return this.buffer.buffer;
+    }
+
+    /**
+     * @type {GPUTypedBuffer}
+     */
+    buffer;
+
+    /**
+     * @type {GPUDevice}
+     */
+    #device
+
+    /**
+     * @type {Camera}
+     */
+    #camera
+
+
+    /**
+     * Final view projection matrix will be offset by this amount in NDC units
+     * @type {Float32Array}
+     */
+    #view_offset = new Float32Array([0, 0]);
+
+    /**
+     *
+     * @type {Float32Array}
+     */
+    #view_projection_matrix = new Float32Array(16);
+
+    get view_projection_matrix() {
+        return this.#view_projection_matrix;
+    }
+
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     */
+    setViewportOffset(x, y) {
+        this.#view_offset[0] = x;
+        this.#view_offset[1] = y;
+    }
+
+    /**
+     *
+     * @param {Camera} v
+     */
+    set camera(v) {
+        this.#camera = v;
+    }
+
+    /**
+     *
+     * @return {Camera}
+     */
+    get camera() {
+        return this.#camera;
+    }
+
+    /**
+     *
+     * @param {GPUDevice} device
+     * @param {Camera} camera
+     */
+    constructor(device, camera) {
+        this.#device = device;
+        this.#camera = camera;
+        this.initialize();
+    }
+
+    clone() {
+        const r = new GPUCameraContext(this.#device, this.#camera.clone());
+
+        r.copy(this);
+
+        return r;
+    }
+
+    /**
+     *
+     * @param {GPUCameraContext} other
+     * @param {ShadeGPUCommandContext} [command_ctx]
+     */
+    copy(other, command_ctx) {
+        this.#camera.copy(other.camera);
+
+        const device = this.#device;
+
+
+        const source = other.buffer.buffer;
+        const destination = this.buffer.buffer;
+
+
+        if (command_ctx === undefined) {
+            const encoder = device.createCommandEncoder();
+
+            encoder.copyBufferToBuffer(
+                source, 0,
+                destination, 0,
+                destination.size
+            );
+
+            device.queue.submit([encoder.finish()]);
+
+        } else {
+
+            command_ctx.copyBufferToBuffer(
+                source, 0,
+                destination, 0,
+                destination.size
+            );
+
+        }
+
+    }
+
+    initialize() {
+
+        this.buffer = GPUTypedBuffer.create({
+            device: this.#device,
+            label: `camera ${this.#id}`,
+            type: CAMERA_UNIFORM_STRUCT,
+            usage: GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC
+        });
+    }
+
+    destroy() {
+        this.buffer.destroy();
+    }
+
+    update() {
+        this.#write_update();
+    }
+
+    /**
+     *
+     */
+    #write_update() {
+
+        const camera = this.#camera;
+        camera.update();
+
+        const projection_matrix = new Float64Array(16);
+        projection_matrix.set(camera.projection_matrix);
+
+        // Signs are chosen so a positive offset shifts rendered content in the +UV direction
+        // (right/down), which is what the temporal consumers (TAA/NSS un-jitter,
+        // chunk_unjitter_uv) assume. The perspective divide negates whatever is added here:
+        // m[11] == -1 makes clip.w = -z_view, so adding c at m[8]/m[9] shifts NDC by -c —
+        // hence "-=" for x (NDC x aligns with UV x) and "+=" for y (NDC y is UV-flipped,
+        // the two negations cancel).
+        projection_matrix[8] -= this.#view_offset[0];
+        projection_matrix[9] += this.#view_offset[1];
+
+        // build view-projection matrix
+        const view_projection_matrix = this.#view_projection_matrix;
+        m4_multiply(view_projection_matrix, projection_matrix, camera.view_matrix);
+
+        const device = this.#device;
+        const queue = device.queue;
+
+        const transform_matrix = camera.transform.matrix;
+
+
+        const transform_inverse = m4_allocate();
+        m4_invert(transform_inverse, transform_matrix);
+
+        const projection_matrix_inverse = m4_allocate();
+        m4_invert(projection_matrix_inverse, projection_matrix);
+
+
+        const view_projection_matrix_inverse = m4_allocate();
+        m4_invert(view_projection_matrix_inverse, view_projection_matrix);
+
+
+        const device_depth_to_view_space = new Float32Array(4);
+        compute_device_depth_to_view_space_depth_params(
+            device_depth_to_view_space,
+            camera,
+        );
+
+        const view_matrix_inverse = m4_allocate();
+        m4_invert(view_matrix_inverse, camera.view_matrix);
+
+        queue_typed_buffer_update(
+            queue,
+            this.buffer,
+            {
+                view_matrix: camera.view_matrix,
+                view_matrix_inverse: view_matrix_inverse,
+                transform: transform_matrix,
+                transform_inverse,
+                projection_matrix,
+                projection_matrix_inverse,
+                view_projection_matrix,
+                view_projection_matrix_inverse,
+                frustum: slice_flat_array(
+                    camera.frustum,
+                    0,
+                    4,
+                    6
+                ),
+                device_depth_to_view_space,
+                clip_near_far: [camera.near, camera.far]
+            }
+        );
+
+    }
 }

package/src/shade/renderer/loader/usd/parse_usda.js

@@ -712,7 +712,7 @@ function parse_attribute_value(value_type, raw) {
     }
 
     // Quaternion types — stored in USD's native (w, x, y, z) order.
-    // Conversion to gl-matrix's (x, y, z, w) is done in usd_compose_transform
+    // Conversion to the engine's (x, y, z, w) is done in usd_compose_transform
     // when the quaternion is consumed for matrix composition.
     // @see https://openusd.org/release/api/class_gf_quatf.html — GfQuatf real-part-first layout
     if (value_type.startsWith("quat")) {

package/src/shade/renderer/loader/usd/usd_build_scene.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"usd_build_scene.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/loader/usd/usd_build_scene.js"],"names":[],"mappings":"AA+BA;;;;GAIG;AAGH;;;;;;;;;;GAUG;AACH;QAJmB,MAAM,GAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,MAAM,MAAQ;KAAE;aACpD,eAAe,GACb,MAAM,EAAE,CAkEpB;;;;;iBAhFa,IAAI,MAAM,EAAE,UAAU,CAAC;;;;iBACvB,OAAO,2BAA2B,EAAE,oBAAoB;;uBAR/C,uBAAuB"}
+{"version":3,"file":"usd_build_scene.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/loader/usd/usd_build_scene.js"],"names":[],"mappings":"AAkCA;;;;GAIG;AAGH;;;;;;;;;;GAUG;AACH;QAJmB,MAAM,GAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,MAAM,MAAQ;KAAE;aACpD,eAAe,GACb,MAAM,EAAE,CAqEpB;;;;;iBAnFa,IAAI,MAAM,EAAE,UAAU,CAAC;;;;iBACvB,OAAO,2BAA2B,EAAE,oBAAoB;;uBAR/C,uBAAuB"}