@woosh/meep-engine 2.42.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/impostors/octahedral/ImpostorBaker.js

@@ -16,6 +16,7 @@ import { HemiOctahedralUvEncoder } from "./grid/HemiOctahedralUvEncoder.js";
 import { prepare_bake_material } from "./bake/prepare_bake_material.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 {
 
@@ -133,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;
 
@@ -336,7 +337,7 @@ export class ImpostorBaker {
 
         r.capture_type = type;
         r.sphere_radius = bounding_sphere[3];
-        vec3.copy(r.offset,bounding_sphere);
+        vec3.copy(r.offset, bounding_sphere);
 
         console.timeEnd('bake');
 

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

@@ -28,7 +28,7 @@ import { TransformAttachmentSystem } from "../../../ecs/transform-attachment/Tra
 import { BehaviorComponent } from "../../../intelligence/behavior/ecs/BehaviorComponent.js";
 import Vector3 from "../../../../core/geom/Vector3.js";
 import { BehaviorSystem } from "../../../intelligence/behavior/ecs/BehaviorSystem.js";
-import { RotationBehavior } from "../../../../../model/game/util/behavior/RotationBehavior.js";
+import { RotationBehavior } from "../../../intelligence/behavior/util/RotationBehavior.js";
 
 /**
  *
@@ -47,9 +47,9 @@ async function main(engine) {
     baker.renderer = renderer;
 
 
-    const path = 'data/models/LowPolyTownshipSet/Small_house/Small_house.gltf';
+    // const path = 'data/models/LowPolyTownshipSet/Small_house/Small_house.gltf';
     // const path = 'data/models/LowPolyTownshipSet/Barrel/model.gltf';
-    // const path = 'data/models/LowPolyTownshipSet/Town_Hall/model.gltf';
+    const path = 'data/models/LowPolyTownshipSet/Town_Hall/model.gltf';
     // const path = 'data/models/RTS_Buildings_Humans/18/Building_R_18_out/Building_R_18.gltf';
     // const path = 'data/models/MOBA and Tower Defense/Tree_01.gltf';
     // const path = 'data/models/samples/transform-hierarchy.glb';
@@ -88,14 +88,14 @@ async function main(engine) {
     //     }
     // );
 
-    // console.profile('bake');
+    console.profile('bake');
     const id = baker.bake({
         objects,
         frames: 16,
         resolution: 2048,
         type: ImpostorCaptureType.FullSphere
     });
-    // console.profileEnd('bake');
+    console.profileEnd('bake');
 
     console.log(id);
 

package/engine/graphics/render/forward_plus/LightManager.js

@@ -403,10 +403,11 @@ export class LightManager {
     /**
      *
      * @param {number} size
+     * @returns {boolean}
      * @private
      */
     __ensure_lookup_size(size) {
-        this.__lookup_data.resize(size);
+        return this.__lookup_data.resize(size);
     }
 
     /**
@@ -451,8 +452,11 @@ export class LightManager {
      *
      * @private
      */
-    __request_update_visible_bvh() {
+    __handle_light_dimensions_change() {
+        // internal BVH needs to be rebuilt
         this.__visible_bvh_needs_update = true;
+        // when dimensions change, typically data will need to be re-written to the GPU, things like light positions or projection matrix
+        this.__light_data_needs_update = true;
     }
 
     /**
@@ -465,7 +469,7 @@ export class LightManager {
 
         const light = data.light;
 
-        light.onDimensionChanged(this.__request_update_visible_bvh, this);
+        light.onDimensionChanged(this.__handle_light_dimensions_change, this);
 
         if (light instanceof Decal) {
             const ref = this.__decal_patch_references.acquire(light.texture_diffuse);
@@ -494,7 +498,7 @@ export class LightManager {
         this.__light_data_needs_update = true;
 
         const light = data.light;
-        light.offDimensionChanged(this.__request_update_visible_bvh, this);
+        light.offDimensionChanged(this.__handle_light_dimensions_change, this);
 
         if (light instanceof Decal) {
             const ref = this.__decal_references.get(light);
@@ -959,11 +963,14 @@ export class LightManager {
         // Post-fact lookup texture resize, this frame will be wrong, but next one should be ok
         const current_lookup_size = this.__lookup_data.size;
 
-        this.__ensure_lookup_size(assignment_count);
+        const lookup_memory_resized = this.__ensure_lookup_size(assignment_count);
 
         const cluster_resized = this.__set_cluster_addressable_bit_range(Math.max(0, Math.log2(lookup_address_offset)));
 
-        if (current_lookup_size < assignment_count || cluster_resized) {
+        if (
+            (lookup_memory_resized && current_lookup_size < assignment_count)
+            || cluster_resized
+        ) {
             this.__update_cluster_texture();
 
             // re-do assignment
@@ -1137,6 +1144,9 @@ export class LightManager {
             this.__sort_visible_light();
 
             this.__write_light_data_texture();
+
+            // clear flag
+            this.__light_data_needs_update = false;
         }
         // console.timeEnd('__write_light_data_texture');
 

package/engine/graphics/render/forward_plus/data/TextureBackedMemoryRegion.js

@@ -90,7 +90,7 @@ export class TextureBackedMemoryRegion {
         this.__data_type = DataType.Uint8;
     }
 
-    get concrete_type(){
+    get concrete_type() {
         return this.__data_type;
     }
 
@@ -234,6 +234,7 @@ export class TextureBackedMemoryRegion {
     /**
      *
      * @param {number} size
+     * @returns {boolean} whether container was resized or not
      */
     resize(size) {
         assert.isNonNegativeInteger(size, 'size');
@@ -252,11 +253,16 @@ export class TextureBackedMemoryRegion {
             //Over-provision to prevent thrashing
             this.__height = Math.ceil(target_height * GROW_FACTOR);
             this.needsRebuild = true;
+            return true;
         } else if (current_height * SHRINK_FACTOR > target_height) {
             // texture too large, lets shrink it down
             this.__height = target_height;
             this.needsRebuild = true;
+            return true;
         }
+
+        // no actual container change
+        return false;
     }
 
     /**

package/engine/graphics/render/forward_plus/materials/FP_SHADER_CHUNK_ACCUMULATION.js

@@ -64,13 +64,23 @@ export const FP_SHADER_CHUNK_ACCUMULATION = `
                           // we fade out decals when the projection angle to the surface gets too steep
                           // 0.7 is cos(45deg) and 0.5 is cos(60deg), dot returns cos of angle between two normals
                           float decal_surface_angle_fade = smoothstep(-0.5,-0.7,decal_surface_dot);
+                          
+                          if(decal_surface_angle_fade <= 0.0){
+                            continue;
+                          }
                          
-                          vec2 decal_uv = (local_position.xy + 0.5)*light_data_4.zw + light_data_4.xy;
+                          vec2 decal_local_uv = (local_position.xy + 0.5);
+                          vec2 decal_uv = decal_local_uv*light_data_4.zw + light_data_4.xy;
                                             
-                          vec4 decal_color = texture(fp_t_decal_atlas, decal_uv);
+                          vec4 decal_color = texture2D(fp_t_decal_atlas,decal_uv, -0.2);
                           
+                          // compute decal alpha
                           float decal_alpha = decal_color.a * decal_surface_angle_fade;
-        
+                          
+                          if(decal_alpha < 0.003){
+                            continue;
+                          }
+                          
                           material.diffuseColor = material.diffuseColor*(1.0-decal_alpha) + decal_color.xyz*decal_alpha;
                    } 
                           

package/engine/graphics/render/forward_plus/materials/FP_SHADER_CHUNK_PREAMBLE.js

@@ -6,6 +6,7 @@ export const FP_SHADER_CHUNK_PREAMBLE = `precision mediump usampler3D;
     uniform usampler2D fp_t_light_lookup;
     uniform sampler2D fp_t_light_data;
     uniform sampler2D fp_t_decal_atlas;
+    uniform vec2 fp_t_decal_atlas_resolution;    
     
     uniform vec3 fp_v3_light_cluster_resolution;
     
@@ -23,5 +24,5 @@ export const FP_SHADER_CHUNK_PREAMBLE = `precision mediump usampler3D;
     #define texture2DProjGradEXT textureProjGrad
     #define textureCubeGradEXT textureGrad
     
-    uniform vec2 fp_resolution;
+    uniform vec2 fp_resolution;    
 `;