@woosh/meep-engine 2.33.38 → 2.33.42

package/engine/graphics/render/forward_plus/debug/buildLightClusterWidget.js

@@ -55,7 +55,9 @@ export function buildLightClusterWidget(lm, camera) {
         domElement: renderer.domElement,
         update() {
             render_cam.updateProjectionMatrix();
-            m.uniforms.map.value = lm.getTextureClusters().clone();
+            const t = lm.getTextureClusters().clone();
+            t.needsUpdate = true;
+            m.uniforms.map.value = t;
             m.uniforms.cameraPos.value.copy(render_cam.position)
 
             renderer.render(group, render_cam);

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

@@ -8,25 +8,38 @@ export const FP_SHADER_CHUNK_ACCUMULATION = `
         for(uint i=0u; i < cluster_metadata.y; i++){
             uint lookup_index = cluster_metadata.x + i;
 
-            uint light_address = texelFetch(fp_t_light_lookup, address_to_data_texture_coordinates(lookup_index), 0 ).r;
+            uint light_descriptor = texelFetch(fp_t_light_lookup, address_to_data_texture_coordinates(lookup_index), 0 ).r;
 
-            vec4 light_data_0 = texelFetch(fp_t_light_data, address_to_data_texture_coordinates(light_address), 0);
-            vec4 light_data_1 = texelFetch(fp_t_light_data, address_to_data_texture_coordinates(light_address+1u), 0);
+            uint type = (light_descriptor) & 0x3u;
+            uint light_address = light_descriptor >> 2;
+            
 
-            vec3 light_position = light_data_0.xyz;
-            float light_radius = light_data_0.w;
-
-            vec3 light_color = light_data_1.xyz;
-            float light_intensity = light_data_1.w;
-
-            PointLight pointlight;
-
-            pointlight.position = light_position;
-            pointlight.distance = light_radius;
-            pointlight.color = light_color*light_intensity;
-            pointlight.decay = 1.0;
-
-            fp_getPointDirectLightIrradiance( pointlight, directLight, vViewPosition );
-            RE_Direct( directLight, geometry, material, reflectedLight );
+            if(type == 0u){
+                   // point light
+                   
+                   vec4 light_data_0 = texelFetch(fp_t_light_data, address_to_data_texture_coordinates(light_address), 0);
+                   vec4 light_data_1 = texelFetch(fp_t_light_data, address_to_data_texture_coordinates(light_address+1u), 0);
+       
+                   vec3 light_position = light_data_0.xyz;
+                   float light_radius = light_data_0.w;
+       
+                   vec3 light_color = light_data_1.xyz;
+                   float light_intensity = light_data_1.w;
+       
+                   PointLight pointlight;
+       
+                   pointlight.position = light_position;
+                   pointlight.distance = light_radius;
+                   pointlight.color = light_color*light_intensity;
+                   pointlight.decay = 1.0;
+       
+                   fp_getPointDirectLightIrradiance( pointlight, directLight, vViewPosition );
+                   RE_Direct( directLight, geometry, material, reflectedLight );
+            
+            }else if(type == 3u){
+                   // decal
+                   
+                   
+            }
         }
        `;

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

@@ -9,6 +9,7 @@ const three_chunk_accummulation_mark = '#include <lights_fragment_end>';
 
 const accumulation_pars = `
         vec3 clip_v = vec3( vec2(gl_FragCoord.x, gl_FragCoord.y) / fp_resolution, convert_depth_to_linear(gl_FragCoord.z));
+        clip_v.x = 1.0 - clip_v.x;
        ${FP_SHADER_CHUNK_ACCUMULATION}
     `;
 

package/engine/graphics/render/forward_plus/model/AbstractLight.js

@@ -0,0 +1,50 @@
+export class AbstractLight {
+
+    /**
+     *
+     * @param {function} f
+     * @param {*} [thisArg]
+     * @returns {void}
+     */
+    onDimensionChanged(f, thisArg) {
+        throw new Error('Not Implemented');
+    }
+
+    /**
+     *
+     * @param {function} f
+     * @param {*} [thisArg]
+     * @returns {void}
+     */
+    offDimensionChanged(f, thisArg) {
+        throw new Error('Not Implemented');
+    }
+
+    /**
+     *
+     * @param {number[]} result
+     * @returns {void}
+     */
+    getCenter(result) {
+        throw new Error('Not Implemented');
+    }
+
+    /**
+     *
+     * @param {AABB3} result
+     * @returns {void}
+     */
+    getAABB(result) {
+        throw new Error('Not Implemented');
+    }
+
+    /**
+     *
+     * @param {number[]|Float32Array|Float64Array} destination
+     * @param {number} address
+     * @returns {number} number of records written, measured in destination array slots
+     */
+    toArray(destination, address) {
+        throw new Error('Not Implemented');
+    }
+}

package/engine/graphics/render/forward_plus/model/Decal.js

@@ -0,0 +1,68 @@
+import { AbstractLight } from "./AbstractLight.js";
+import { aabb3_matrix4_project_by_corners } from "../../../../../core/geom/3d/aabb/aabb3_matrix4_project_by_corners.js";
+import { aabb3_build_corners } from "../../../../../core/geom/3d/aabb/aabb3_build_corners.js";
+import { array_copy } from "../../../../../core/collection/array/copyArray.js";
+
+export class Decal extends AbstractLight {
+    constructor() {
+        super();
+
+        /**
+         * Transform matrix, initial volume is a unit cube
+         * @type {number[]|Float32Array|mat4[]}
+         */
+        this.transform = new Float32Array(16);
+
+        /**
+         *
+         * @type {Sampler2D}
+         */
+        this.texture_diffuse = null;
+
+        /**
+         * Order in which decal should be applied, higher priority decals will be drawn first
+         * NOTE: not implemented yet
+         * @type {number}
+         */
+        this.draw_priority = 0;
+    }
+
+    onDimensionChanged(f, thisArg) {
+        // TODO implement
+    }
+
+    offDimensionChanged(f, thisArg) {
+        // TODO implement
+    }
+
+    getCenter(result) {
+        // extract translation portion of the matrix
+        result[0] = this.transform[12];
+        result[1] = this.transform[13];
+        result[2] = this.transform[14];
+    }
+
+    getAABB(result) {
+        const corners = [];
+        aabb3_build_corners(corners, 0, -0.5, -0.5, -0.5, 0.5, 0.5, 0.5);
+
+        const aabb_array = new Float32Array(6);
+        aabb3_matrix4_project_by_corners(aabb_array, corners, this.transform);
+
+        result.readFromArray(aabb_array, 0);
+    }
+
+    toArray(destination, address) {
+        array_copy(this.transform, 0, destination, address, 16);
+
+        return 16;
+    }
+}
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+Decal.prototype.isDecal = true;
+
+Decal.prototype.ENCODED_SLOT_COUNT = 16;

package/engine/graphics/render/forward_plus/{PointLight.js → model/PointLight.js}

@@ -1,10 +1,16 @@
-import Vector3 from "../../../../core/geom/Vector3.js";
-import { Color } from "../../../../core/color/Color.js";
-import Vector1 from "../../../../core/geom/Vector1.js";
-import { mortonEncode_magicbits } from "../../../../core/geom/3d/morton/mortonEncode_magicbits.js";
+import Vector3 from "../../../../../core/geom/Vector3.js";
+import { Color } from "../../../../../core/color/Color.js";
+import Vector1 from "../../../../../core/geom/Vector1.js";
+import { AbstractLight } from "./AbstractLight.js";
 
-export class PointLight {
+export class PointLight extends AbstractLight {
     constructor() {
+        super();
+
+        /**
+         * @readonly
+         * @type {Vector3}
+         */
         this.position = new Vector3();
 
         /**
@@ -13,6 +19,10 @@ export class PointLight {
          */
         this.radius = new Vector1(1);
 
+        /**
+         * @readonly
+         * @type {Color}
+         */
         this.color = new Color(1, 1, 1);
 
         /**
@@ -22,12 +32,8 @@ export class PointLight {
         this.intensity = new Vector1(1);
     }
 
-    /**
-     *
-     * @returns {number}
-     */
-    computeMortonCode() {
-        return mortonEncode_magicbits(this.position.x, this.position.y, this.position.z);
+    getCenter(result) {
+        this.position.writeToArray(result, 0);
     }
 
     /**
@@ -95,3 +101,5 @@ export class PointLight {
  * @type {boolean}
  */
 PointLight.prototype.isPointLight = true;
+
+PointLight.prototype.ENCODED_SLOT_COUNT = 16;

package/engine/graphics/render/forward_plus/{SpotLight.js → model/SpotLight.js}

@@ -1,11 +1,13 @@
-import Vector3 from "../../../../core/geom/Vector3.js";
-import Vector1 from "../../../../core/geom/Vector1.js";
-import { Color } from "../../../../core/color/Color.js";
-import { computeConeBoundingBox } from "../../../../core/geom/3d/cone/computeConeBoundingBox.js";
-import { mortonEncode_magicbits } from "../../../../core/geom/3d/morton/mortonEncode_magicbits.js";
+import Vector3 from "../../../../../core/geom/Vector3.js";
+import Vector1 from "../../../../../core/geom/Vector1.js";
+import { Color } from "../../../../../core/color/Color.js";
+import { computeConeBoundingBox } from "../../../../../core/geom/3d/cone/computeConeBoundingBox.js";
+import { AbstractLight } from "./AbstractLight.js";
 
-export class SpotLight {
+export class SpotLight extends AbstractLight {
     constructor() {
+        super();
+
         /**
          *
          * @type {Vector3}
@@ -49,12 +51,18 @@ export class SpotLight {
         this.penumbra = new Vector1(0.4);
     }
 
-    /**
-     *
-     * @returns {number}
-     */
-    computeMortonCode() {
-        return mortonEncode_magicbits(this.position.x, this.position.y, this.position.z);
+    getCenter(result) {
+        // find center of the cone (mid point along the cone length)
+
+        const d = this.direction;
+
+        const m = this.distance.getValue() * 0.5;
+
+        const p = this.position;
+
+        result[0] = p.x + d.x * m;
+        result[1] = p.y + d.y * m;
+        result[2] = p.z + d.z * m;
     }
 
     /**

package/engine/graphics/render/forward_plus/plugin/ptototypeFPPlugin.js

@@ -223,7 +223,8 @@ function makeLight(position, radius, color, intensity = 1) {
     const mesh_center_1 = new ThreeMesh(sphere_geometry, new MeshBasicMaterial({
         color: color_uint,
         transparent: true,
-        opacity: 0.06
+        opacity: 0.06,
+        writeDepth: false
     }));
     mesh_center_1.scale.setScalar(0.3);
     mesh_center_1.matrixAutoUpdate = false;
@@ -737,7 +738,7 @@ function setup_scene_3(engine, ecd) {
                                     1,
                                     1,
                                     1,
-                                    0.1,
+                                    0.0,
 
                                     1,
                                     1,
@@ -937,7 +938,7 @@ function setup_scene_2(engine, ecd) {
 
     const random = seededRandom(0);
 
-    for (let i = 0; i < 10; i++) {
+    for (let i = 0; i < 100; i++) {
 
         const builder = makeLight([
                 randomFloatBetween(random, -20, 20) + offset.x,
@@ -968,7 +969,7 @@ function setup_scene_2(engine, ecd) {
             .build(ecd);
     }
 
-    for (let i = 0; i < 200; i++) {
+    for (let i = 0; i < 0; i++) {
 
         const builder = makeLight([
                 randomFloatBetween(random, -10, 10) + offset.x,
@@ -1130,7 +1131,7 @@ function main(engine) {
     engine.graphics.renderer.setClearColor('rgba(99,99,99,1)');
 
     setup_scene_3(engine, ecd);
-    // setup_scene_1(engine, ecd);
+    // setup_scene_2(engine, ecd);
 
     // engine.graphics.loadEnvironmentMap(buildCubeURLs('data/textures/cubemaps/hip_miramar/32/', '.png'));
 

package/engine/graphics/render/forward_plus/{prototypeLightManager.js → prototype/prototypeLightManager.js}

@@ -3,6 +3,7 @@ import {
     HemisphereLight,
     Line,
     LineBasicMaterial,
+    LineSegments,
     Mesh,
     MeshBasicMaterial,
     OctahedronBufferGeometry,
@@ -13,35 +14,40 @@ import {
     Vector2,
     WebGLRenderer
 } from "three";
-import { min2 } from "../../../../core/math/min2.js";
-import { seededRandom } from "../../../../core/math/random/seededRandom.js";
-import { PointLight } from "./PointLight.js";
-import { makeHelperSphereGeometry } from "../../../../editor/process/symbolic/makeHelperSphereGeometry.js";
+import { min2 } from "../../../../../core/math/min2.js";
+import { seededRandom } from "../../../../../core/math/random/seededRandom.js";
+import { PointLight } from "../model/PointLight.js";
+import { makeHelperSphereGeometry } from "../../../../../editor/process/symbolic/makeHelperSphereGeometry.js";
 import { OrbitControls } from "three/examples/jsm/controls/OrbitControls.js";
-import { MouseEvents } from "../../../input/devices/events/MouseEvents.js";
-import { RingBuffer } from "../../../../core/collection/RingBuffer.js";
-import { query_bvh_frustum_from_objects } from "./query/query_bvh_frustum_from_objects.js";
-import { prettyPrint } from "../../../../core/NumberFormat.js";
-import { FPlusDebugMaterial } from "./materials/FPlusDebugMaterial.js";
-import { parseColor } from "../../../../core/color/ColorUtils.js";
-import { buildLightClusterWidget } from "./debug/buildLightClusterWidget.js";
-import domify from "../../../../view/DOM.js";
-import { createScreenGrid } from "./debug/createScreenGrid.js";
-import { createLayerSwitcher } from "./debug/createLayerSwitcher.js";
-import { FPlusStandardMaterial } from "./materials/FPlusStandardMaterial.js";
-import { LightManager } from "./LightManager.js";
-import ButtonView from "../../../../view/elements/button/ButtonView.js";
+import { MouseEvents } from "../../../../input/devices/events/MouseEvents.js";
+import { RingBuffer } from "../../../../../core/collection/RingBuffer.js";
+import { query_bvh_frustum_from_objects } from "../query/query_bvh_frustum_from_objects.js";
+import { prettyPrint } from "../../../../../core/NumberFormat.js";
+import { FPlusDebugMaterial } from "../materials/FPlusDebugMaterial.js";
+import { parseColor } from "../../../../../core/color/ColorUtils.js";
+import { buildLightClusterWidget } from "../debug/buildLightClusterWidget.js";
+import domify from "../../../../../view/DOM.js";
+import { createScreenGrid } from "../debug/createScreenGrid.js";
+import { createLayerSwitcher } from "../debug/createLayerSwitcher.js";
+import { FPlusStandardMaterial } from "../materials/FPlusStandardMaterial.js";
+import { LightManager } from "../LightManager.js";
+import ButtonView from "../../../../../view/elements/button/ButtonView.js";
 import { GLTFLoader } from "three/examples/jsm/loaders/GLTFLoader.js";
-import { traverseMaterialTextures } from "../../../asset/loaders/material/traverseMaterialTextures.js";
-import Vector3 from "../../../../core/geom/Vector3.js";
-import { MetricCollection } from "../../../development/performance/MetricCollection.js";
-import { MetricStatistics } from "../../../development/performance/MetricStatistics.js";
-import { SpotLight } from "./SpotLight.js";
-import { randomFloatBetween } from "../../../../core/math/random/randomFloatBetween.js";
-import Signal from "../../../../core/events/signal/Signal.js";
+import { traverseMaterialTextures } from "../../../../asset/loaders/material/traverseMaterialTextures.js";
+import Vector3 from "../../../../../core/geom/Vector3.js";
+import { MetricCollection } from "../../../../development/performance/MetricCollection.js";
+import { MetricStatistics } from "../../../../development/performance/MetricStatistics.js";
+import { SpotLight } from "../model/SpotLight.js";
+import { randomFloatBetween } from "../../../../../core/math/random/randomFloatBetween.js";
+import Signal from "../../../../../core/events/signal/Signal.js";
 import SimplexNoise from "simplex-noise";
 import Stats from "three/examples/jsm/libs/stats.module.js";
-import { threeUpdateTransform } from "../../util/threeUpdateTransform.js";
+import { threeUpdateTransform } from "../../../util/threeUpdateTransform.js";
+import { Decal } from "../model/Decal.js";
+import { mat4 } from "gl-matrix";
+import { Sampler2D } from "../../../texture/sampler/Sampler2D.js";
+import { makeHelperBoxGeometry } from "../../../../../editor/process/symbolic/makeHelperBoxGeometry.js";
+import { array_copy } from "../../../../../core/collection/array/copyArray.js";
 
 const on_render = new Signal();
 
@@ -50,6 +56,7 @@ const lm = new LightManager();
 const camera = new PerspectiveCamera(30);
 camera.position.z = 1;
 
+camera.layers.enable(1);
 camera.layers.enable(3);
 camera.layers.enable(4);
 // camera.layers.enable(1);
@@ -62,6 +69,7 @@ camera.updateProjectionMatrix();
 camera.updateMatrixWorld(true);
 
 // lm.setTileMapResolution(32,32,32);
+// lm.setTileMapResolution(2, 2, 2);
 lm.setTileMapResolution(24, 14, 8);
 // lm.setTileMapResolution(16, 8, 10);
 
@@ -300,6 +308,41 @@ function addPointLight({
     }
 }
 
+/**
+ *
+ * @param {number[]} position
+ * @param {number[]} scale
+ * @param {number[]} [rotation] Quaternion
+ * @param {Sampler2D} sampler
+ * @param {THREE.Scene} scene
+ * @param {LightManager} light_manager
+ */
+function addDecal({
+                      position,
+                      scale,
+                      rotation = [0, 0, 0, 1],
+                      sampler,
+                      scene,
+                      light_manager
+                  }) {
+    const decal = new Decal();
+
+    mat4.fromRotationTranslationScale(decal.transform, rotation, position, scale);
+    decal.texture_diffuse = sampler;
+
+    const vis = new LineSegments(makeHelperBoxGeometry(), new LineBasicMaterial({ color: 0xFFFFFF }));
+
+    vis.layers.set(1);
+
+    vis.matrixAutoUpdate = false;
+    vis.matrixWorldNeedsUpdate = false;
+    array_copy(decal.transform, 0, vis.matrixWorld.elements, 0, 16);
+
+    scene.add(vis);
+
+    light_manager.addLight(decal);
+}
+
 const box_geometry = new TorusKnotBufferGeometry(1, 0.3, 128, 128);
 const debug_material = new FPlusDebugMaterial();
 
@@ -406,6 +449,35 @@ function prepare_scene_2() {
     camera.lookAt(0, 0, -5);
 }
 
+function prepare_scene_decal_0() {
+    addPointLight({
+            position: [
+                1.5, 0, -4
+            ], radius: 1.5, color: 0xFF0000, intensity: 1
+        }
+    );
+
+    const sampler = new Sampler2D(new Uint8Array([255, 255, 255, 255]), 4, 1, 1);
+    addDecal({
+        position: [
+            -1.5, 0, -4
+        ],
+        scale: [
+            1.5, 1.5, 1.5
+        ],
+        sampler: sampler,
+        scene,
+        light_manager: lm
+    });
+
+    addKnot([0, 0, -5], 1, [0, 0, 0]);
+
+    camera.near = 1;
+    camera.far = 7;
+
+    camera.lookAt(0, 0, -5);
+}
+
 
 function prepare_scene_5() {
 
@@ -760,6 +832,9 @@ function draw_camera_view_planes() {
     });
 }
 
+// prepare_scene_2();
+// prepare_scene_decal_0();
+// prepare_scene_2();
 prepare_scene_0();
 animate();
 

package/engine/graphics/render/forward_plus/query/query_bvh_frustum_from_texture.js

@@ -28,6 +28,7 @@ export function query_bvh_frustum_from_texture(
 
     let stackPointer = 1;
     let result = 0;
+    let plane_address;
 
     /**
      * After performing empirical tests, stack-based depth-first traversal turns out faster than using a queue
@@ -55,9 +56,7 @@ export function query_bvh_frustum_from_texture(
             const n_y1 = data_view.getFloat32(node_address + 16);
             const n_z1 = data_view.getFloat32(node_address + 20);
 
-            for (let j = 0; j < 6; j++) {
-
-                const plane_address = j * 4;
+            for (plane_address = 0; plane_address < 24; plane_address += 4) {
 
                 const plane_normal_x = planes[plane_address];
                 const plane_normal_y = planes[plane_address + 1];
@@ -84,41 +83,51 @@ export function query_bvh_frustum_from_texture(
             const left_index = (node_index << 1) + 1;
             const right_index = left_index + 1;
 
-            if (left_index < last_valid_index) {
-                stack[stackPointer] = left_index;
-                stackPointer++;
-            }
-
+            // left node ends up on top of the stack, which aligns with the desired access sequence
             if (right_index < last_valid_index) {
-                stack[stackPointer] = right_index;
-                stackPointer++;
+                stack[stackPointer++] = right_index;
+                // micro-optimization, since we know that right node is valid and left appears before that, left is valid too
+                stack[stackPointer++] = left_index;
+            } else if (left_index < last_valid_index) {
+                stack[stackPointer++] = left_index;
             }
 
 
         } else {
             // leaf node
             const leaf_index = node_index - binary_node_count;
+
             const node_address = leaf_index * BVH_LEAF_NODE_SIZE + binary_node_count * BVH_BINARY_NODE_SIZE;
 
-            const light_index = data_view.getUint32(node_address + 24);
+            const light_descriptor = data_view.getUint32(node_address + 24);
+
+            const light_type = light_descriptor & 3;
+            const light_texel_index = light_descriptor >> 2;
 
-            const light_address = light_index * 8;
+            const light_address = light_texel_index * 4;
 
-            // TODO figure out light type from address
+            if (light_type === 0) {
+                // Point light
 
+                const light_x = source_data[light_address];
+                const light_y = source_data[light_address + 1];
+                const light_z = source_data[light_address + 2];
 
-            const light_x = source_data[light_address];
-            const light_y = source_data[light_address + 1];
-            const light_z = source_data[light_address + 2];
+                const radius = source_data[light_address + 3];
 
-            const radius = source_data[light_address + 3];
+                if (!point_light_inside_volume(light_x, light_y, light_z, radius, points, planes)) {
+                    continue;
+                }
+            } else if (light_type === 3) {
+                // decal
+                debugger;
 
-            if (!point_light_inside_volume(light_x, light_y, light_z, radius, points, planes)) {
-                continue;
+            } else {
+                throw new Error('Unsupported light type');
             }
 
             // write to output
-            destination[destination_offset + result] = light_index;
+            destination[destination_offset + result] = light_descriptor;
 
             result++;
         }

package/engine/graphics/render/visibility/IncrementalDeltaSet.d.ts

@@ -14,4 +14,6 @@ export class IncrementalDeltaSet<T> {
     initializeUpdate(): void
 
     finalizeUpdate(): void
+
+    sort(f: (T) => number, ctx?: any): void
 }

package/engine/graphics/render/visibility/IncrementalDeltaSet.js

@@ -74,6 +74,7 @@ export class IncrementalDeltaSet {
      *
      * @param {function(T):number} score_function
      * @param {*} [score_context]
+     * @returns {void}
      */
     sort(score_function, score_context) {
         arrayQuickSort(this.elements, score_function, score_context, 0, this.size - 1);

package/engine/graphics/texture/atlas/AbstractTextureAtlas.js

@@ -0,0 +1,19 @@
+export class AbstractTextureAtlas {
+    /**
+     *
+     * @param {Sampler2D} sampler
+     * @returns {AtlasPatch}
+     */
+    add(sampler) {
+        throw new Error('Not Implemented');
+    }
+
+    /**
+     *
+     * @param {AtlasPatch} patch
+     * @returns {boolean}
+     */
+    remove(patch) {
+        throw new Error('Not Implemented')
+    }
+}