@woosh/meep-engine 2.41.0 → 2.42.1

package/engine/graphics/geometry/MikkT/NormalizeSafe.js

@@ -0,0 +1,21 @@
+import { Length } from "./Length.js";
+import { vec3 } from "gl-matrix";
+
+/**
+ *
+ * @param {vec3} out
+ * @param {vec3} input
+ */
+export function NormalizeSafe(out, input) {
+
+    const len = Length(input);
+
+    if (len !== 0) {
+        const m = 1 / len;
+
+        vec3.scale(out, input, m)
+
+    } else {
+        vec3.copy(out, input);
+    }
+}

package/engine/graphics/geometry/MikkT/NotZero.js

@@ -0,0 +1,10 @@
+import { EPSILON } from "../../../../core/math/MathUtils.js";
+
+/**
+ *
+ * @param {number} v
+ * @returns {boolean}
+ */
+export function NotZero(v) {
+    return Math.abs(v) > EPSILON;
+}

package/engine/graphics/geometry/MikkT/QuickSort.js

@@ -0,0 +1,54 @@
+import { assert } from "../../../../core/assert.js";
+
+/**
+ *
+ * @param {number[]|ArrayLike<number>|Uint32Array|Int32Array} pSortBuffer
+ * @param {number} iLeft
+ * @param {number} iRight
+ * @param {number} uSeed
+ * @returns {void}
+ */
+export function QuickSort(pSortBuffer, iLeft, iRight, uSeed) {
+    let iL, iR, n, index, iMid, iTmp;
+
+    // Random
+    let t = uSeed & 31;
+    t = (uSeed << t) | (uSeed >> (32 - t));
+    uSeed = uSeed + t + 3;
+    uSeed = uSeed >>> 0; // make unsigned
+    // Random end
+
+    iL = iLeft;
+    iR = iRight;
+    n = (iR - iL) + 1;
+
+    assert.greaterThanOrEqual(n , 0);
+
+    index = (uSeed % n);
+
+    iMid = pSortBuffer[index + iL];
+
+
+    do {
+        while (pSortBuffer[iL] < iMid)
+            ++iL;
+        while (pSortBuffer[iR] > iMid)
+            --iR;
+
+        if (iL <= iR) {
+
+            iTmp = pSortBuffer[iL];
+            pSortBuffer[iL] = pSortBuffer[iR];
+            pSortBuffer[iR] = iTmp;
+
+            ++iL;
+            --iR;
+        }
+    }
+    while (iL <= iR);
+
+    if (iLeft < iR)
+        QuickSort(pSortBuffer, iLeft, iR, uSeed);
+    if (iL < iRight)
+        QuickSort(pSortBuffer, iL, iRight, uSeed);
+}

package/engine/graphics/geometry/MikkT/QuickSortEdges.js

@@ -0,0 +1,71 @@
+import { array_swap } from "../../../../core/collection/array/array_swap.js";
+import { assert } from "../../../../core/assert.js";
+
+/**
+ *
+ * @param {number[]} pSortBuffer
+ * @param {number} iLeft
+ * @param {number} iRight
+ * @param {number} channel
+ * @param {number} uSeed
+ * @returns {void}
+ */
+export function QuickSortEdges(pSortBuffer, iLeft, iRight, channel, uSeed) {
+    let t;
+    let iL, iR, n, index, iMid;
+
+    // early out
+    const iElems = iRight - iLeft + 1;
+
+    if (iElems < 2) {
+        return;
+    } else if (iElems === 2) {
+
+        if (pSortBuffer[iLeft * 3 + channel] > pSortBuffer[iRight * 3 + channel]) {
+
+            array_swap(pSortBuffer, iLeft * 3, pSortBuffer, iRight * 3, 3); // swap elements
+
+        }
+
+        return;
+    }
+
+    // Random
+    t = uSeed & 31;
+    t = (uSeed << t) | (uSeed >> (32 - t));
+    uSeed = uSeed + t + 3;
+
+    uSeed = uSeed >>> 0; // make unsigned
+    // Random end
+
+    iL = iLeft;
+    iR = iRight;
+    n = (iR - iL) + 1;
+
+    assert.greaterThanOrEqual(n, 0);
+
+    index = (uSeed % n);
+
+    iMid = pSortBuffer[(index + iL) * 3 + channel];
+
+    do {
+        while (pSortBuffer[iL * 3 + channel] < iMid)
+            ++iL;
+        while (pSortBuffer[iR * 3 + channel] > iMid)
+            --iR;
+
+        if (iL <= iR) {
+
+            array_swap(pSortBuffer, iL * 3, pSortBuffer, iR * 3, 3); // do swap
+
+            ++iL;
+            --iR;
+        }
+    }
+    while (iL <= iR);
+
+    if (iLeft < iR)
+        QuickSortEdges(pSortBuffer, iLeft, iR, channel, uSeed);
+    if (iL < iRight)
+        QuickSortEdges(pSortBuffer, iL, iRight, channel, uSeed);
+}

package/engine/graphics/geometry/MikkT/SSubGroup.js

@@ -0,0 +1,15 @@
+export class SSubGroup {
+    constructor() {
+        /**
+         *
+         * @type {number}
+         */
+        this.iNrFaces = 0;
+
+        /**
+         * *int
+         * @type {Int32Array|null}
+         */
+        this.pTriMembers = null;
+    }
+}

package/engine/graphics/geometry/MikkT/STSpace.js

@@ -0,0 +1,36 @@
+import { vec3 } from "gl-matrix";
+import { allocate_v3 } from "../../ecs/mesh-v2/allocate_v3.js";
+
+export class STSpace {
+    constructor() {
+        /**
+         *
+         * @type {vec3|Float32Array}
+         */
+        this.vOs = allocate_v3();
+        /**
+         *
+         * @type {vec3|Float32Array}
+         */
+        this.vOt = allocate_v3();
+
+        this.fMagS = 0;
+        this.fMagT = 0;
+
+        this.iCounter = 0;	// this is to average back into quads.
+        this.bOrient = false;
+    }
+
+    /**
+     *
+     * @param {STSpace} other
+     */
+    copy(other) {
+        vec3.copy(this.vOs, other.vOs);
+        this.fMagS = other.fMagS;
+        vec3.copy(this.vOt, other.vOt);
+        this.fMagT = other.fMagT;
+        this.iCounter = other.iCounter;
+        this.bOrient = other.bOrient;
+    }
+}

package/engine/graphics/geometry/MikkT/constants/GROUP_WITH_ANY.js

@@ -0,0 +1 @@
+export const GROUP_WITH_ANY = 4;

package/engine/graphics/geometry/MikkT/constants/INTERNAL_RND_SORT_SEED.js

@@ -0,0 +1 @@
+export const INTERNAL_RND_SORT_SEED = 39871946;

package/engine/graphics/geometry/MikkT/constants/MARK_DEGENERATE.js

@@ -0,0 +1 @@
+export const MARK_DEGENERATE = 1;

package/engine/graphics/geometry/MikkT/constants/ORIENT_PRESERVING.js

@@ -0,0 +1 @@
+export const ORIENT_PRESERVING = 8;

package/engine/graphics/geometry/MikkT/constants/QUAD_ONE_DEGEN_TRI.js

@@ -0,0 +1 @@
+export const QUAD_ONE_DEGEN_TRI = 2;

package/engine/graphics/geometry/MikkT/m_getNormal.js

@@ -0,0 +1,16 @@
+import { array_copy } from "../../../../core/collection/array/copyArray.js";
+
+/**
+ *
+ * @param {SMikkTSpaceContext} pContext
+ * @param {number[]|{0:number,1:number,2:number}} fvNormOut
+ * @param {number} iFace
+ * @param {number} iVert
+ * @returns {void}
+ */
+export function m_getNormal(pContext, fvNormOut, iFace, iVert) {
+    // figure out which vertex it is
+    const vertex_index = pContext.geometry_buffer_index[iFace * 3 + iVert];
+
+    array_copy(pContext.geometry_buffer_vertex_normal, vertex_index * 3, fvNormOut, 0, 3);
+}

package/engine/graphics/geometry/MikkT/m_getNumFaces.js

@@ -0,0 +1,8 @@
+/**
+ * Returns the number of faces (triangles/quads) on the mesh to be processed.
+ * @param {SMikkTSpaceContext} pContext
+ * @returns {number}
+ */
+export function m_getNumFaces(pContext) {
+    return pContext.geometry_buffer_index.length / 3;
+}

package/engine/graphics/geometry/MikkT/m_getNumVerticesOfFace.js

@@ -0,0 +1,11 @@
+/**
+ * Returns the number of vertices on face number iFace
+ * iFace is a number in the range {0, 1, ..., getNumFaces()-1}
+ * @param {SMikkTSpaceContext} pContext
+ * @param {number} iFace
+ * @returns {number}
+ */
+function m_getNumVerticesOfFace(pContext, iFace) {
+    // only support triangles
+    return 3;
+}

package/engine/graphics/geometry/MikkT/m_getPosition.js

@@ -0,0 +1,20 @@
+/**
+ *
+ * @param {SMikkTSpaceContext} pContext
+ * @param {number[]|{0:number,1:number,2:number}} fvPosOut
+ * @param {number} iFace
+ * @param {number} iVert
+ * @returns {void}
+ */
+export function m_getPosition(pContext, fvPosOut, iFace, iVert) {
+    // figure out which vertex it is
+    const vertex_index = pContext.geometry_buffer_index[iFace * 3 + iVert];
+
+    const position = pContext.geometry_buffer_vertex_position;
+
+    const position_offset = vertex_index * 3;
+
+    fvPosOut[0] = position[position_offset];
+    fvPosOut[1] = position[position_offset + 1];
+    fvPosOut[2] = position[position_offset + 2];
+}

package/engine/graphics/geometry/MikkT/m_getTexCoord.js

@@ -0,0 +1,16 @@
+import { array_copy } from "../../../../core/collection/array/copyArray.js";
+
+/**
+ *
+ * @param {SMikkTSpaceContext} pContext
+ * @param {number[]|{0:number,1:number}} fvTexcOut
+ * @param {number} iFace
+ * @param {number} iVert
+ * @returns {void}
+ */
+export function m_getTexCoord(pContext, fvTexcOut, iFace, iVert) {
+    // figure out which vertex it is
+    const vertex_index = pContext.geometry_buffer_index[iFace * 3 + iVert];
+
+    array_copy(pContext.geometry_buffer_vertex_uv, vertex_index * 2, fvTexcOut, 0, 3);
+}

package/engine/graphics/geometry/MikkT/m_setTSpace.js

@@ -0,0 +1,35 @@
+/**
+ *
+ * @param {SMikkTSpaceContext} pContext
+ * @param {number[]} tangent
+ * @param {number[]} bi_tangent
+ * @param {number} fMagS
+ * @param {number} fMagT
+ * @param {boolean} bi_tangent_preserves_orientation
+ * @param {number} iFace
+ * @param {number} iVert
+ * @returns {void}
+ */
+export function m_setTSpace(
+    pContext,
+    tangent,
+    bi_tangent,
+    fMagS,
+    fMagT,
+    bi_tangent_preserves_orientation,
+    iFace,
+    iVert
+) {
+
+    // figure out which vertex it is
+    const vertex_index = pContext.geometry_buffer_index[iFace * 3 + iVert];
+
+    const tangent_destination = pContext.geometry_buffer_vertex_tangent;
+    const tangent_address = vertex_index * 4;
+
+    // for logic explanation, see https://github.com/gltf-rs/mikktspace/blob/6275cc4f15cff8be29819fb34ae8be3b9129dae1/src/lib.rs#L33
+    tangent_destination[tangent_address] = tangent[0];
+    tangent_destination[tangent_address + 1] = tangent[1];
+    tangent_destination[tangent_address + 2] = tangent[2];
+    tangent_destination[tangent_address + 3] = bi_tangent_preserves_orientation ? 1 : -1;
+}

package/engine/graphics/geometry/MikkT/m_setTSpaceBasic.js

@@ -0,0 +1,22 @@
+/**
+ * either (or both) of the two setTSpace callbacks can be set.
+ * The call-back m_setTSpaceBasic() is sufficient for basic normal mapping.
+ *
+ * This function is used to return the tangent and fSign to the application.
+ * fvTangent is a unit length vector.
+ * For normal maps it is sufficient to use the following simplified version of the bitangent which is generated at pixel/vertex level.
+ * bitangent = fSign * cross(vN, tangent);
+ * Note that the results are returned unindexed. It is possible to generate a new index list
+ * But averaging/overwriting tangent spaces by using an already existing index list WILL produce INCRORRECT results.
+ * DO NOT! use an already existing index list.
+ *
+ * @param {SMikkTSpaceContext} pContext
+ * @param {number[]} fvTangent
+ * @param {number} fSign
+ * @param {number} iFace
+ * @param {number} iVert
+ * @returns {void}
+ */
+function m_setTSpaceBasic(pContext, fvTangent, fSign, iFace, iVert) {
+    throw new Error('Not supported');
+}

package/engine/graphics/geometry/MikkT/malloc.js

@@ -0,0 +1,16 @@
+/**
+ * Mimics C malloc somewhat, allocates an array of class instances of fixed size
+ * @template T
+ * @param {constructor<T>} Klass
+ * @param {number} count
+ * @returns {T[]}
+ */
+export function malloc(Klass, count) {
+    const r = new Array(count);
+
+    for (let i = 0; i < count; i++) {
+        r[i] = new Klass();
+    }
+
+    return r;
+}

package/engine/graphics/geometry/MikkT/v3_scale_dot_sub_normalize.js

@@ -0,0 +1,52 @@
+import { vec3 } from "gl-matrix";
+import { v3_length } from "../../../../core/geom/v3_length.js";
+import { v3_dot } from "../../../../core/geom/v3_dot.js";
+
+/**
+ * executes following formula: v1 - v0*( dot(v0,v1) )
+ * @param {vec3} out
+ * @param {vec3} v0
+ * @param {vec3} v1
+ */
+export function v3_scale_dot_sub_normalize(out, v0, v1) {
+    const v0x = v0[0];
+    const v0y = v0[1];
+    const v0z = v0[2];
+
+    const v1x = v1[0];
+    const v1y = v1[1];
+    const v1z = v1[2];
+
+    // dot product
+    const _dot = v3_dot(v0x, v0y, v0z, v1x, v1y, v1z);
+
+    // scale
+    const _x0 = v0x * _dot;
+    const _y0 = v0y * _dot;
+    const _z0 = v0z * _dot;
+
+    // subtract
+    const _x1 = v1x - _x0;
+    const _z1 = v1z - _z0;
+    const _y1 = v1y - _y0;
+
+    // "safe" normalization
+    const len = v3_length(_x1, _y1, _z1);
+
+    if (len !== 0) {
+
+        const m = 1 / len;
+
+        out[0] = _x1 * m;
+        out[1] = _y1 * m;
+        out[2] = _z1 * m;
+
+    } else {
+
+        out[0] = _x1;
+        out[1] = _y1;
+        out[2] = _z1;
+
+    }
+
+}

package/engine/graphics/geometry/buffered/computeGeometryEquality.js

@@ -1,4 +1,4 @@
-import { isArrayEqualStrict } from "../../../../core/collection/array/isArrayEqualStrict.d.ts";
+import { isArrayEqualStrict } from "../../../../core/collection/array/isArrayEqualStrict.js";
 import { is_typed_array_equals } from "../../../../core/collection/array/typed/is_typed_array_equals.js";
 
 

package/engine/graphics/geometry/buffered/computeGeometryHash.js

@@ -1,5 +1,5 @@
 import { computeBufferAttributeHash } from "./computeBufferAttributeHash.js";
-import { computeStringHash } from "../../../../core/primitives/strings/computeStringHash.d.ts";
+import { computeStringHash } from "../../../../core/primitives/strings/computeStringHash.js";
 
 /**
  *

package/engine/graphics/impostors/octahedral/ImpostorBaker.js

@@ -3,7 +3,7 @@ import { assert } from "../../../../core/assert.js";
 import { isPowerOfTwo } from "../../../../core/math/isPowerOrTwo.js";
 import { Mesh, OrthographicCamera, Scene, Vector4, WebGLMultipleRenderTargets } from "three";
 import { ImpostorDescription } from "./ImpostorDescription.js";
-import { mat4 } from "gl-matrix";
+import { mat4, vec3 } from "gl-matrix";
 import { BakeShaderStandard } from "./shader/BakeShaderStandard.js";
 import { Sampler2D } from "../../texture/sampler/Sampler2D.js";
 import Signal from "../../../../core/events/signal/Signal.js";
@@ -14,8 +14,9 @@ import { UvEncoder } from "./grid/UvEncoder.js";
 import { OctahedralUvEncoder } from "./grid/OctahedralUvEncoder.js";
 import { HemiOctahedralUvEncoder } from "./grid/HemiOctahedralUvEncoder.js";
 import { prepare_bake_material } from "./bake/prepare_bake_material.js";
-import { compute_bounding_sphere } from "./bake/compute_bounding_sphere.js";
 import { collectIteratorValueToArray } from "../../../../core/collection/IteratorUtils.js";
+import { compute_bounding_sphere } from "./bake/compute_bounding_sphere.js";
+import { buffer_geometry_ensure_tangents } from "../../geometry/MikkT/buffer_geometry_ensure_tangents.js";
 
 export class ImpostorBaker {
 
@@ -37,20 +38,22 @@ export class ImpostorBaker {
 
     /**
      *
-     * @param {number} distance
+     * @param {number[]|vec4} bounding_sphere
      * @param {{mesh:ShadedGeometry, transform:mat4}[]} objects
      * @param {number} resolution
      * @param {number} frames
      * @param {UvEncoder} encoder
      */
     bake_internal({
-                      distance,
+                      bounding_sphere,
                       objects,
                       resolution,
                       frames,
                       encoder
                   }) {
 
+        const distance = bounding_sphere[3];
+
         assert.isNumber(distance, 'distance');
         assert.isNonNegativeInteger(resolution, 'resolution');
         assert.isNonNegativeInteger(frames, 'frames');
@@ -66,7 +69,6 @@ export class ImpostorBaker {
         rt.texture[1].name = 'normal+depth';
         rt.texture[2].name = 'orm'; // Occlusion, Roughness, Metalness
 
-
         const renderer = this._renderer;
 
         // remember render state
@@ -74,6 +76,7 @@ export class ImpostorBaker {
         const _vp = new Vector4();
         renderer.getViewport(_vp);
         const _autoClear = renderer.autoClear;
+        const _pixelRatio = renderer.getPixelRatio();
 
         const gl = this._renderer.getContext();
 
@@ -90,6 +93,7 @@ export class ImpostorBaker {
         renderer.setRenderTarget(rt);
         renderer.setClearColor(0xFFFFFF, 0);
         renderer.clearColor();
+        renderer.setPixelRatio(1);
 
         const frame_width = resolution / frames;
         const frame_height = resolution / frames;
@@ -122,6 +126,7 @@ export class ImpostorBaker {
             keyEqualityFunction: computeMaterialEquality
         });
 
+        const max_anisotropic_filtering_level = renderer.capabilities.getMaxAnisotropy();
 
         for (let k = 0; k < object_count; k++) {
             const object = objects[k];
@@ -129,7 +134,7 @@ export class ImpostorBaker {
             const source_mesh = object.mesh;
 
             // ensure tangents are generated
-            // buffer_geometry_ensure_tangents(source_mesh.geometry);
+            buffer_geometry_ensure_tangents(source_mesh.geometry);
 
             const source_material = source_mesh.material;
 
@@ -139,7 +144,14 @@ export class ImpostorBaker {
                 const bake_material = new BakeShaderStandard();
 
                 // prepare bake material to match the source material
-                prepare_bake_material(bake_material, source_material, cleanup_signal);
+                prepare_bake_material({
+                    bake_material: bake_material,
+                    source_material: source_material,
+                    cleanup_signal: cleanup_signal,
+                    anisotropy: max_anisotropic_filtering_level
+                });
+
+                bake_material.uniforms.uAtlasResolution.value.set(resolution, resolution);
 
                 cleanup_signal.addOne(bake_material.dispose, bake_material);
 
@@ -183,9 +195,9 @@ export class ImpostorBaker {
                 encoder.uv_to_unit(unit_sphere_direction, [octahedron_u, octahedron_v]);
 
                 // offset by the radius of the sphere
-                const camera_px = distance * unit_sphere_direction[0];
-                const camera_py = distance * unit_sphere_direction[1];
-                const camera_pz = distance * unit_sphere_direction[2];
+                const camera_px = distance * unit_sphere_direction[0] + bounding_sphere[0];
+                const camera_py = distance * unit_sphere_direction[1] + bounding_sphere[1];
+                const camera_pz = distance * unit_sphere_direction[2] + bounding_sphere[2];
 
                 // console.log(`UV:${octahedron_u.toFixed(2)},${octahedron_v.toFixed(2)}\t V3:${unit_sphere_direction.map(n => n.toFixed(2)).join(', ')}`);
 
@@ -203,7 +215,7 @@ export class ImpostorBaker {
                     camera_pz
                 );
 
-                cam.lookAt(0, 0, 0);
+                cam.lookAt(bounding_sphere[0], bounding_sphere[1], bounding_sphere[2]);
                 cam.updateProjectionMatrix();
 
                 // update materials
@@ -237,6 +249,7 @@ export class ImpostorBaker {
         renderer.setRenderTarget(_rt);
         renderer.setViewport(_vp);
         renderer.autoClear = _autoClear;
+        renderer.setPixelRatio(_pixelRatio);
         if (_enabled_antialias) {
             gl.enable(gl.SAMPLE_ALPHA_TO_COVERAGE);
         }
@@ -302,7 +315,7 @@ export class ImpostorBaker {
             throw new Error('No renderer attached. Renderer is required for baking.');
         }
 
-        const objects_radius = compute_bounding_sphere(objects);
+        const bounding_sphere = compute_bounding_sphere(objects);
 
         // we need to compute bounding sphere around origin of the object
         let encoder;
@@ -318,12 +331,13 @@ export class ImpostorBaker {
             resolution,
             frames,
             objects,
-            distance: objects_radius,
+            bounding_sphere,
             encoder
         });
 
         r.capture_type = type;
-        r.sphere_radius = objects_radius;
+        r.sphere_radius = bounding_sphere[3];
+        vec3.copy(r.offset, bounding_sphere);
 
         console.timeEnd('bake');
 

package/engine/graphics/impostors/octahedral/ImpostorDescription.js

@@ -27,6 +27,12 @@ export class ImpostorDescription {
      */
     sphere_radius = 0;
 
+    /**
+     * Baking offset
+     * @type {number[]}
+     */
+    offset = [0, 0, 0];
+
     /**
      * Actual baked data
      * @type {Sampler2D|null}

package/engine/graphics/impostors/octahedral/README.md

@@ -22,6 +22,7 @@ This is inherently a deferred rendering technique, where an impostor asset is re
 ---
 references:
 
+- [2021] [Rendering a Sphere on a Quad](https://bgolus.medium.com/rendering-a-sphere-on-a-quad-13c92025570c) by Ben Golus
 - [2018] [Octahedral Impostors](https://shaderbits.com/blog/octahedral-impostors) by Ryan Brucks
 - [2018] https://github.com/xraxra/IMP
 - [2018] https://github.com/wojtekpil/Godot-Octahedral-Impostors