@woosh/meep-engine 2.134.4 → 2.135.0

package/src/engine/graphics/composit/CompositLayer.js

@@ -1,254 +1,254 @@
-import {
-    AddEquation,
-    CustomBlending,
-    Mesh,
-    OneFactor,
-    OneMinusSrcAlphaFactor,
-    RedFormat,
-    RGBAFormat,
-    ShaderMaterial
-} from "three";
-import Vector2 from "../../../core/geom/Vector2.js";
-import { assert } from "../../../core/assert.js";
-import { blendingType2three } from "../texture/sampler/blendingType2Three.js";
-import { ScreenSpaceQuadShader } from "../shaders/ScreenSpaceQuadShader.js";
-import { BlendingType } from "../texture/sampler/BlendingType.js";
-import { FULL_SCREEN_TRIANGLE_GEOMETRY } from "../geometry/FULL_SCREEN_TRIANGLE_GEOMETRY.js";
-import Signal from "../../../core/events/signal/Signal.js";
-
-/**
- *
- * @param {Material} material
- * @param {BlendingType} blending
- */
-function assignMaterialBlending(material, blending) {
-
-    if (blending === BlendingType.MultiplyAdd) {
-        material.blending = CustomBlending;
-        material.blendEquation = AddEquation;
-        material.blendSrc = OneFactor;
-        material.blendDst = OneMinusSrcAlphaFactor;
-    } else {
-        const threeBlending = blendingType2three(blending);
-
-        material.blending = threeBlending;
-    }
-
-}
-
-export class CompositLayer {
-    /**
-     *
-     * @param {THREE.WebGLRenderTarget} renderTarget
-     * @param {BlendingType} blending
-     * @param {number} renderTargetScale
-     */
-    constructor({
-                    renderTarget,
-                    blending,
-                    renderTargetScale = 1
-                }) {
-        /**
-         * Human-readable name, useful for debugging
-         * @type {string}
-         */
-        this.name = "";
-
-        /**
-         *
-         * @type {BlendingType}
-         */
-        this.__blending = blending;
-        /**
-         *
-         * @type {WebGLRenderTarget}
-         */
-        this.renderTarget = renderTarget;
-
-        /**
-         *
-         * @type {number}
-         */
-        this.renderTargetScale = renderTargetScale;
-
-        this.object = new Mesh(FULL_SCREEN_TRIANGLE_GEOMETRY, this.buildMaterial());
-
-        /**
-         * Which compositing stage this layer belongs to, stages are rendered independently
-         * @type {number}
-         */
-        this.stage = 0;
-
-        this.size = new Vector2();
-
-        /**
-         *
-         * @type {boolean}
-         */
-        this.__enabled = true;
-
-        /**
-         * Layers are composited in order from lowest to highest
-         * @type {number}
-         */
-        this.__order = 0;
-
-        this.on = {
-            preRender: new Signal()
-        };
-    }
-
-    get blending() {
-        return this.__blending;
-    }
-
-    set blending(v) {
-        if (v === this.__blending) {
-            return;
-        }
-
-        this.__blending = v;
-
-        assignMaterialBlending(this.object.material, v);
-    }
-
-    /**
-     *
-     * @param {number} v
-     */
-    set order(v) {
-        this.__order = v;
-
-        this.object.renderOrder = v;
-    }
-
-    /**
-     *
-     * @return {number}
-     */
-    get order() {
-        return this.__order;
-    }
-
-    /**
-     *
-     * @param {number} v
-     */
-    set enabled(v) {
-        if (!this.__enabled && v) {
-            this.enable();
-        } else if (this.__enabled && !v) {
-            this.disable();
-        }
-    }
-
-    /**
-     *
-     * @returns {boolean}
-     */
-    get enabled() {
-        return this.__enabled;
-    }
-
-    enable() {
-        if (!this.__enabled) {
-            this.__enabled = true;
-            this.object.visible = true;
-        }
-    }
-
-    disable() {
-        if (this.__enabled) {
-            this.__enabled = false;
-            this.object.visible = false;
-        }
-    }
-
-    /**
-     *
-     * @param {number} x
-     * @param {number} y
-     */
-    setSize(x, y) {
-        this.size.set(x, y);
-        this.updateRenderTargetSize();
-    }
-
-    updateRenderTargetSize() {
-
-        if (this.renderTarget !== null) {
-            const scale = this.renderTargetScale;
-
-            const size = this.size;
-
-            const width = size.x * scale;
-            const height = size.y * scale;
-
-            this.renderTarget.setSize(width, height);
-        }
-    }
-
-    /**
-     *
-     * @param {number} scale
-     */
-    setRenderTargetScale(scale) {
-        assert.isNumber(scale, 'v');
-        assert.isFiniteNumber(scale, 'v');
-
-        this.renderTargetScale = scale;
-
-        this.updateRenderTargetSize();
-    }
-
-    /**
-     * Override screen-space material of the layer. This allows you to render directly into the output buffer, bypassing the need to create an intermediate buffer
-     * NOTE: Please make sure you know what you're doing if you use this method
-     * @param {Material} material
-     */
-    setCustomMaterial(material) {
-        assignMaterialBlending(material, this.blending);
-
-        // override material
-        this.object.material = material;
-    }
-
-
-    buildMaterial() {
-
-
-        const uniforms = {
-            tTexture: {
-                type: 't',
-                value: this.renderTarget.texture
-            }
-        };
-
-        // determine swizzle for the material
-        let swizzle;
-        const texture_format = this.renderTarget.texture.format;
-        if (texture_format === RedFormat) {
-            swizzle = ['r', 'r', 'r', 1];
-        } else if (texture_format === RGBAFormat) {
-            swizzle = ['r', 'g', 'b', 'a'];
-        } else {
-            throw new Error('Unsupported format');
-        }
-
-        const material = new ShaderMaterial({
-            uniforms,
-            vertexShader: ScreenSpaceQuadShader.vertexShader(),
-            fragmentShader: ScreenSpaceQuadShader.fragmentShader(swizzle),
-            lights: false,
-            fog: false,
-            depthTest: false,
-            depthWrite: false,
-            transparent: true,
-            vertexColors: false
-        });
-
-        assignMaterialBlending(material, this.blending);
-
-        return material;
-    }
-}
+import {
+    AddEquation,
+    CustomBlending,
+    Mesh,
+    OneFactor,
+    OneMinusSrcAlphaFactor,
+    RedFormat,
+    RGBAFormat,
+    ShaderMaterial
+} from "three";
+import Vector2 from "../../../core/geom/Vector2.js";
+import { assert } from "../../../core/assert.js";
+import { blendingType2three } from "../texture/sampler/blendingType2Three.js";
+import { ScreenSpaceQuadShader } from "../shaders/ScreenSpaceQuadShader.js";
+import { BlendingType } from "../texture/sampler/BlendingType.js";
+import { FULL_SCREEN_TRIANGLE_GEOMETRY } from "../geometry/FULL_SCREEN_TRIANGLE_GEOMETRY.js";
+import Signal from "../../../core/events/signal/Signal.js";
+
+/**
+ *
+ * @param {Material} material
+ * @param {BlendingType} blending
+ */
+function assignMaterialBlending(material, blending) {
+
+    if (blending === BlendingType.MultiplyAdd) {
+        material.blending = CustomBlending;
+        material.blendEquation = AddEquation;
+        material.blendSrc = OneFactor;
+        material.blendDst = OneMinusSrcAlphaFactor;
+    } else {
+        const threeBlending = blendingType2three(blending);
+
+        material.blending = threeBlending;
+    }
+
+}
+
+export class CompositLayer {
+    /**
+     *
+     * @param {THREE.WebGLRenderTarget} renderTarget
+     * @param {BlendingType} blending
+     * @param {number} renderTargetScale
+     */
+    constructor({
+                    renderTarget,
+                    blending,
+                    renderTargetScale = 1
+                }) {
+        /**
+         * Human-readable name, useful for debugging
+         * @type {string}
+         */
+        this.name = "";
+
+        /**
+         *
+         * @type {BlendingType}
+         */
+        this.__blending = blending;
+        /**
+         *
+         * @type {WebGLRenderTarget}
+         */
+        this.renderTarget = renderTarget;
+
+        /**
+         *
+         * @type {number}
+         */
+        this.renderTargetScale = renderTargetScale;
+
+        this.object = new Mesh(FULL_SCREEN_TRIANGLE_GEOMETRY, this.buildMaterial());
+
+        /**
+         * Which compositing stage this layer belongs to, stages are rendered independently
+         * @type {number}
+         */
+        this.stage = 0;
+
+        this.size = new Vector2();
+
+        /**
+         *
+         * @type {boolean}
+         */
+        this.__enabled = true;
+
+        /**
+         * Layers are composited in order from lowest to highest
+         * @type {number}
+         */
+        this.__order = 0;
+
+        this.on = {
+            preRender: new Signal()
+        };
+    }
+
+    get blending() {
+        return this.__blending;
+    }
+
+    set blending(v) {
+        if (v === this.__blending) {
+            return;
+        }
+
+        this.__blending = v;
+
+        assignMaterialBlending(this.object.material, v);
+    }
+
+    /**
+     *
+     * @param {number} v
+     */
+    set order(v) {
+        this.__order = v;
+
+        this.object.renderOrder = v;
+    }
+
+    /**
+     *
+     * @return {number}
+     */
+    get order() {
+        return this.__order;
+    }
+
+    /**
+     *
+     * @param {number} v
+     */
+    set enabled(v) {
+        if (!this.__enabled && v) {
+            this.enable();
+        } else if (this.__enabled && !v) {
+            this.disable();
+        }
+    }
+
+    /**
+     *
+     * @returns {boolean}
+     */
+    get enabled() {
+        return this.__enabled;
+    }
+
+    enable() {
+        if (!this.__enabled) {
+            this.__enabled = true;
+            this.object.visible = true;
+        }
+    }
+
+    disable() {
+        if (this.__enabled) {
+            this.__enabled = false;
+            this.object.visible = false;
+        }
+    }
+
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     */
+    setSize(x, y) {
+        this.size.set(x, y);
+        this.updateRenderTargetSize();
+    }
+
+    updateRenderTargetSize() {
+
+        if (this.renderTarget !== null) {
+            const scale = this.renderTargetScale;
+
+            const size = this.size;
+
+            const width = size.x * scale;
+            const height = size.y * scale;
+
+            this.renderTarget.setSize(width, height);
+        }
+    }
+
+    /**
+     *
+     * @param {number} scale
+     */
+    setRenderTargetScale(scale) {
+        assert.isNumber(scale, 'v');
+        assert.isFinite(scale, 'v');
+
+        this.renderTargetScale = scale;
+
+        this.updateRenderTargetSize();
+    }
+
+    /**
+     * Override screen-space material of the layer. This allows you to render directly into the output buffer, bypassing the need to create an intermediate buffer
+     * NOTE: Please make sure you know what you're doing if you use this method
+     * @param {Material} material
+     */
+    setCustomMaterial(material) {
+        assignMaterialBlending(material, this.blending);
+
+        // override material
+        this.object.material = material;
+    }
+
+
+    buildMaterial() {
+
+
+        const uniforms = {
+            tTexture: {
+                type: 't',
+                value: this.renderTarget.texture
+            }
+        };
+
+        // determine swizzle for the material
+        let swizzle;
+        const texture_format = this.renderTarget.texture.format;
+        if (texture_format === RedFormat) {
+            swizzle = ['r', 'r', 'r', 1];
+        } else if (texture_format === RGBAFormat) {
+            swizzle = ['r', 'g', 'b', 'a'];
+        } else {
+            throw new Error('Unsupported format');
+        }
+
+        const material = new ShaderMaterial({
+            uniforms,
+            vertexShader: ScreenSpaceQuadShader.vertexShader(),
+            fragmentShader: ScreenSpaceQuadShader.fragmentShader(swizzle),
+            lights: false,
+            fog: false,
+            depthTest: false,
+            depthWrite: false,
+            transparent: true,
+            vertexColors: false
+        });
+
+        assignMaterialBlending(material, this.blending);
+
+        return material;
+    }
+}

package/src/engine/graphics/ecs/mesh-v2/sg_hierarchy_compute_bounding_box_via_parent_entity.js

@@ -21,7 +21,7 @@ export function sg_hierarchy_compute_bounding_box_via_parent_entity(result, root
         if (sg !== undefined) {
             sg.getBoundingBox(scratch_aabb3);
 
-            result.expandToFit(scratch_aabb3);
+            result.union(scratch_aabb3);
         }
     }
 

package/src/engine/graphics/ecs/path/tube/build/build_geometry_linear.js

@@ -37,7 +37,7 @@ export function build_geometry_linear(
     if (scratch_array_0[1] !== 0) {
         path.sample_linear(scratch_v3, segment_start * path_length);
 
-        scratch_v3.writeToArray(points, points_added * 3);
+        scratch_v3.toArray(points, points_added * 3);
         points_added++;
 
         // offset first sampled point, we're already past it
@@ -54,7 +54,7 @@ export function build_geometry_linear(
         //add end
         path.sample_linear(scratch_v3, segment_end * path_length);
 
-        scratch_v3.writeToArray(points, points_added * 3);
+        scratch_v3.toArray(points, points_added * 3);
         points_added++;
     }
 

package/src/engine/graphics/material/optimization/MaterialOptimizationContext.js

@@ -612,7 +612,7 @@ export class MaterialOptimizationContext {
                 atlas_sampler,
                 source_sampler,
                 0, 0,
-                patch.x0, patch.y0, patch.getWidth(), patch.getHeight()
+                patch.x0, patch.y0, patch.width, patch.height
             );
         }
     }
@@ -853,8 +853,8 @@ export class MaterialOptimizationContext {
             matrix3.setUvTransform(
                 patch.x0 / atlas_width,
                 patch.y0 / atlas_height,
-                patch.getWidth() / atlas_width,
-                patch.getHeight() / atlas_height,
+                patch.width / atlas_width,
+                patch.height / atlas_height,
                 0,
                 0, 0
             );