@woosh/meep-engine 2.33.1 → 2.33.5

package/engine/ecs/animation/TwoBoneInverseKinematicsSolver.js

@@ -1,5 +1,5 @@
 import { assert } from "../../../core/assert.js";
-import Vector3, { v3_dot, v3Length_i } from "../../../core/geom/Vector3.js";
+import Vector3, { v3_dot, v3_length } from "../../../core/geom/Vector3.js";
 import { clamp } from "../../../core/math/clamp.js";
 import { inverseLerp } from "../../../core/math/inverseLerp.js";
 import Quaternion from "../../../core/geom/Quaternion.js";
@@ -41,7 +41,7 @@ function computeInteriorAngle(a, b, c) {
     const d_ab_z = a.z - b.z;
 
     //normalize AB delta vector
-    const d_ab_length = v3Length_i(d_ab_x, d_ab_y, d_ab_z);
+    const d_ab_length = v3_length(d_ab_x, d_ab_y, d_ab_z);
 
     const nd_ab_x = d_ab_x / d_ab_length;
     const nd_ab_y = d_ab_y / d_ab_length;
@@ -53,7 +53,7 @@ function computeInteriorAngle(a, b, c) {
     const d_cb_z = c.z - b.z;
 
     //normalize CB delta vector
-    const d_cb_length = v3Length_i(d_cb_x, d_cb_y, d_cb_z);
+    const d_cb_length = v3_length(d_cb_x, d_cb_y, d_cb_z);
 
     const nd_cb_x = d_cb_x / d_cb_length;
     const nd_cb_y = d_cb_y / d_cb_length;
@@ -266,7 +266,7 @@ export class TwoBoneInverseKinematicsSolver extends IKSolver {
         //check if current effector position is above the contact point
         const dot_contact_side = v3_dot(directionX, directionY, directionZ, delta_contact_c_x, delta_contact_c_y, delta_contact_c_z);
 
-        const delta_contact_c_length = v3Length_i(delta_contact_c_x, delta_contact_c_y, delta_contact_c_z);
+        const delta_contact_c_length = v3_length(delta_contact_c_x, delta_contact_c_y, delta_contact_c_z);
 
         let influence;
 

package/engine/graphics/GraphicsEngine.d.ts

@@ -1,4 +1,4 @@
-import {PerspectiveCamera, RenderTarget, Scene, WebGLRenderer} from "three";
+import {PerspectiveCamera, Scene, WebGLRenderer, WebGLRenderTarget} from "three";
 import {RenderLayerManager} from "./render/layers/RenderLayerManager";
 import Vector3 from "../../core/geom/Vector3";
 import Vector2 from "../../core/geom/Vector2";
@@ -17,7 +17,7 @@ export class GraphicsEngine {
     public needDraw: boolean
     public autoDraw: boolean
 
-    render(renderTarget?: RenderTarget): void
+    render(renderTarget?: WebGLRenderTarget): void
 
     normalizeViewportPoint(input: Vector3 | Vector2, result: Vector2 | Vector3): void
 

package/engine/graphics/GraphicsEngine.js

@@ -4,14 +4,11 @@
 
 
 import {
-    CubeTextureLoader,
     Group,
     LinearEncoding,
     NoToneMapping,
-    PMREMGenerator,
     Raycaster as ThreeRaycaster,
     Scene as ThreeScene,
-    sRGBEncoding,
     Vector3 as ThreeVector3,
     VSMShadowMap,
     WebGLRenderer,
@@ -36,27 +33,13 @@ import { renderTextureToScreenQuad } from "./render/utils/renderTextureToScreenQ
 import { globalMetrics } from "../metrics/GlobalMetrics.js";
 import { MetricsCategory } from "../metrics/MetricsCategory.js";
 import Vector1 from "../../core/geom/Vector1.js";
-import { noop } from "../../core/function/Functions.js";
 import { NormalFrameBuffer } from "./render/buffer/buffers/NormalFrameBuffer.js";
 import { MaterialManager } from "./material/manager/MaterialManager.js";
 import { CoalesceTextures } from "./material/manager/compilers/CoalesceTextures.js";
 import { ShadowMapRenderer } from "./shadows/ShadowMapRenderer.js";
 import { CameraViewManager } from "./render/view/CameraViewManager.js";
 import { StandardFrameBuffers } from "./StandardFrameBuffers.js";
-
-/**
- *
- * @param {String} path
- * @param {String} format
- * @returns {String[]}
- */
-export function buildCubeURLs(path, format) {
-    return [
-        path + "posx" + format, path + "negx" + format,
-        path + "posy" + format, path + "negy" + format,
-        path + "posz" + format, path + "negz" + format
-    ];
-}
+import { load_environment_map } from "./texture/cubemap/load_environment_map.js";
 
 /**
  *
@@ -259,54 +242,21 @@ GraphicsEngine.prototype.getRenderer = function () {
 
 /**
  *
- * @param {string[]} paths
- * @return {Promise<THREE.CubeTexture>}
- */
-function load_cube_texture(paths) {
-    const cubeTextureLoader = new CubeTextureLoader();
-    return new Promise((resolve, reject) => {
-
-        cubeTextureLoader.load(
-            paths,
-            texture => {
-
-
-                resolve(texture);
-            },
-            noop,
-            reject
-        );
-    });
-}
-
-/**
- *
- * @param {string[]} paths URLs to faces of the cubemap
- * @returns {Promise<void>}
+ * @param {string[]|string} paths URLs to faces of the cubemap
+ * @returns {Promise<Texture>}
  */
 GraphicsEngine.prototype.loadEnvironmentMap = async function (paths) {
 
-    /**
-     *
-     * @type {THREE.CubeTexture}
-     */
-    const cube_texture = await load_cube_texture(paths);
-
-    cube_texture.encoding = sRGBEncoding;
-
-    // generate pre-filtered cubemap
-    const pmremGenerator = new PMREMGenerator(this.renderer);
-    pmremGenerator.compileCubemapShader();
-
-    const cube_rt = pmremGenerator.fromCubemap(cube_texture);
-
-    // cleanup
-    cube_texture.dispose();
-    pmremGenerator.dispose();
+    const { filtered } = await load_environment_map({
+        path: paths,
+        renderer: this.renderer,
+        original: false,
+        filtered: true
+    });
 
-    // assign environment
-    this.scene.environment = cube_rt.texture;
+    this.scene.environment = filtered;
 
+    return filtered;
 }
 
 GraphicsEngine.prototype.updateSize = function () {
@@ -618,11 +568,19 @@ GraphicsEngine.prototype.renderOpaque = function () {
  * Renders assets that (may) contain transparent fragments
  */
 GraphicsEngine.prototype.renderTransparent = function () {
+    const scene = this.scene;
+
+    const _background = scene.background;
+    scene.background = null;
+
     this.prepareRenderPass(RenderPassType.Transparent);
 
     const renderer = this.renderer;
 
-    renderer.render(this.scene, this.camera);
+    renderer.render(scene, this.camera);
+
+    // restore background
+    scene.background = _background;
 
     // TODO render transparent objects into a buffer, to be able to apply post-fx
 };

package/engine/graphics/filter/FlipArrayInPlace.js

@@ -0,0 +1,25 @@
+/**
+ * @param {Uint8Array} input
+ * @param {number} width
+ * @param {number} height
+ * @param {number} channel_count
+ */
+export function flipArrayInPlace(input, width, height, channel_count = 4) {
+    const rowLength = width * channel_count;
+    let t, x0, x1;
+    let i = 0;
+    const l = height >> 1;
+
+    for (; i < l; i++) {
+        //swap lines
+        const k = (height - i - 1) * rowLength;
+        const m = i * rowLength;
+        for (let j = 0; j < rowLength; j++) {
+            x0 = m + j;
+            x1 = k + j;
+            t = input[x0];
+            input[x0] = input[x1];
+            input[x1] = t;
+        }
+    }
+}

package/engine/graphics/filter/FlipArrayViaCanvas.js

@@ -0,0 +1,13 @@
+function flipArrayViaCanvas(input, width, height) {
+    const canvas = document.createElement("canvas");
+    const c = canvas.getContext('2d');
+    const imageData = c.createImageData(width, height);
+    imageData.data.set(input);
+    c.putImageData(imageData, 0, 0);
+    c.translate(0, height);
+    c.scale(1, -1);
+    c.drawImage(canvas, 0, 0);
+    const imgd = c.getImageData(0, 0, width, height);
+
+    return imgd.data;
+}

package/engine/graphics/filter/ImageFilter.js

@@ -3,59 +3,25 @@
  */
 
 
-import {
-    LinearFilter,
-    Mesh,
-    OrthographicCamera,
-    PlaneBufferGeometry,
-    Scene,
-    ShaderMaterial,
-    WebGLRenderTarget
-} from 'three';
-
-export function flipArrayInPlace(input, width, height) {
-    const rowLength = width * 4;
-    let t, x0, x1;
-    let i = 0;
-    const l = height >> 1;
-    for (; i < l; i++) {
-        //swap lines
-        const k = (height - i - 1) * rowLength;
-        const m = i * rowLength;
-        for (let j = 0; j < rowLength; j++) {
-            x0 = m + j;
-            x1 = k + j;
-            t = input[x0];
-            input[x0] = input[x1];
-            input[x1] = t;
-        }
-    }
-}
-
-function flipArrayViaCanvas(input, width, height) {
-    const canvas = document.createElement("canvas");
-    const c = canvas.getContext('2d');
-    const imageData = c.createImageData(width, height);
-    imageData.data.set(input);
-    c.putImageData(imageData, 0, 0);
-    c.translate(0, height);
-    c.scale(1, -1);
-    c.drawImage(canvas, 0, 0);
-    const imgd = c.getImageData(0, 0, width, height);
-
-    return imgd.data;
-}
+import { LinearFilter, Mesh, OrthographicCamera, Scene, ShaderMaterial, WebGLRenderTarget } from 'three';
+import { FULL_SCREEN_TRIANGLE_GEOMETRY } from "../geometry/FULL_SCREEN_TRIANGLE_GEOMETRY.js";
 
 /**
  *
  * @param {WebGLRenderer} renderer
  * @param {number} width
  * @param {number} height
- * @param processShader
+ * @param {{vertexShader:string,fragmentShader:string, uniforms?:Object, defines?:Object}} processShader
  * @param {Uint8Array} [destination]
  * @return {{array: Uint8Array, renderer: WebGLRenderer}}
  */
-function processTexture(renderer, width, height, processShader, destination) {
+function processTexture(
+    renderer,
+    width,
+    height,
+    processShader,
+    destination
+) {
     if (destination === undefined) {
         destination = new Uint8Array(width * height * 4);
     }
@@ -72,9 +38,10 @@ function processTexture(renderer, width, height, processShader, destination) {
     material.lights = false;
     material.fog = false;
 
-    const quad = new Mesh(new PlaneBufferGeometry(2, 2), material);
+    const quad = new Mesh(FULL_SCREEN_TRIANGLE_GEOMETRY, material);
 
     scene.add(quad);
+
     //render
     const renderTargetOptions = {
         generateMipmaps: false,
@@ -82,28 +49,30 @@ function processTexture(renderer, width, height, processShader, destination) {
         stencilBuffer: false,
         depthBuffer: false
     };
+
     const renderTarget = new WebGLRenderTarget(width, height, renderTargetOptions);
 
+    const __rt = renderer.getRenderTarget(); // remember old renderer state
+
     renderer.setRenderTarget(renderTarget);
 
     renderer.render(scene, camera);
 
     const gl = renderer.getContext();
+
     //void readPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, ArrayBufferView? pixels)
     gl.readPixels(0, 0, width, height, gl.RGBA, gl.UNSIGNED_BYTE, destination);
 
-    renderer.setRenderTarget(null);
+    // restore renderer state
+    renderer.setRenderTarget(__rt);
 
-    //reorder lines in the buffer to make Y axis match
-
-    //uint8Array = flipArrayViaCanvas(uint8Array, width, height);
-    //
+    // cleanup resources
     renderTarget.dispose();
     material.dispose();
+
     return {
         array: destination,
         graphics: renderer
-        //renderTarget: renderTarget
     };
 }
 

package/engine/graphics/geometry/bvh/buffered/BVHGeometryRaycaster.js

@@ -1,4 +1,4 @@
-import Vector3, { v3Length_i } from "../../../../../core/geom/Vector3.js";
+import Vector3, { v3_length } from "../../../../../core/geom/Vector3.js";
 
 import { Vector3 as ThreeVector3 } from 'three';
 import { rayTriangleIntersection } from "../../../../../core/geom/GeometryMath.js";
@@ -60,7 +60,7 @@ function bindGeometryFaceNormal(indices, normals, index) {
     const nsZ = (naZ + nbZ + ncZ);
 
     //normalize
-    const l = v3Length_i(nsX, nsY, nsZ);
+    const l = v3_length(nsX, nsY, nsZ);
     const m = 1 / l;
 
     const nx = nsX * m;