@woosh/meep-engine 2.108.0 → 2.108.3

package/src/engine/graphics/sh3/gi/material/MaterialTransformer.d.ts

@@ -0,0 +1,24 @@
+export class MaterialTransformer extends AbstractMaterialTransformer {
+    /**
+     *
+     * @param {LightProbeVolume} volume
+     */
+    constructor({ volume }: LightProbeVolume);
+    /**
+     *
+     * @param {number} v
+     */
+    set intensity(arg: number);
+    /**
+     *
+     * @return {number}
+     */
+    get intensity(): number;
+    update_bounds(): void;
+    update_lookup(): void;
+    update(): void;
+    transform(source: any): any;
+    #private;
+}
+import { AbstractMaterialTransformer } from "../../../material/manager/AbstractMaterialTransformer.js";
+//# sourceMappingURL=MaterialTransformer.d.ts.map

package/src/engine/graphics/sh3/gi/material/MaterialTransformer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MaterialTransformer.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/sh3/gi/material/MaterialTransformer.js"],"names":[],"mappings":"AA0CA;IAsHI;;;OAGG;IACH,0CAMC;IAlBD;;;OAGG;IACH,2BAEC;IAdD;;;OAGG;IACH,wBAEC;IAsBD,sBAIC;IAED,sBA2CC;IAED,eAuCC;IAED,4BA2BC;;CACJ;4CA9R2C,0DAA0D"}

package/src/engine/graphics/sh3/gi/material/MaterialTransformer.js

@@ -0,0 +1,293 @@
+import { DataTexture3D, NearestFilter, RedIntegerFormat, UnsignedIntType, Vector3 } from "three";
+import { BinaryDataType } from "../../../../../core/binary/type/BinaryDataType.js";
+import { AABB3 } from "../../../../../core/geom/3d/aabb/AABB3.js";
+import { aabb3_from_v3_array } from "../../../../../core/geom/3d/aabb/aabb3_from_v3_array.js";
+import { AttributeSpec } from "../../../geometry/AttributeSpec.js";
+import { composeCompile } from "../../../material/composeCompile.js";
+import { AbstractMaterialTransformer } from "../../../material/manager/AbstractMaterialTransformer.js";
+import { isLitMaterial } from "../../../render/forward_plus/plugin/isLitMaterial.js";
+import { AttributeDataTexture } from "../../../texture/AttributeDataTexture.js";
+import { vector_buffer_to_attribute_texture } from "../../lpv/probe_volume_to_textures.js";
+import { tetrahedral_mesh_to_texture } from "../tetrahedral_mesh_to_texture.js";
+import { build_fragment_shader } from "./build_fragment_shader.js";
+import { build_vertex_shader } from "./build_vertex_shader.js";
+
+const PROPERTY_TRANSFORMER_MARKER = '@light-probe-volume-material-transformer';
+
+
+function createLookupTexture(resolution) {
+
+    const lookup = new DataTexture3D(
+        new Uint32Array(resolution * resolution * resolution),
+        resolution,
+        resolution,
+        resolution
+    );
+
+    lookup.name = "Tetrahedron Lookup";
+
+    lookup.flipY = false;
+    lookup.generateMipmaps = false;
+    lookup.magFilter = NearestFilter;
+    lookup.minFilter = NearestFilter;
+
+    lookup.type = UnsignedIntType;
+    lookup.format = RedIntegerFormat;
+    lookup.internalFormat = "R32UI";
+
+    lookup.needsUpdate = true;
+
+    return lookup;
+}
+
+export class MaterialTransformer extends AbstractMaterialTransformer {
+
+    /**
+     *
+     * @type {LightProbeVolume|null}
+     */
+    #volume = null;
+
+    #mesh_lookup = createLookupTexture(32);
+    #mesh_bounds = new AABB3();
+
+    #textures = {
+        vertex: new AttributeDataTexture(
+            AttributeSpec.fromJSON({
+                name: "vertex",
+                type: BinaryDataType.Uint32,
+                itemSize: 4,
+                normalized: false
+            }),
+            256, 1
+        ),
+        neighbour: new AttributeDataTexture(
+            AttributeSpec.fromJSON({
+                name: "neighbour",
+                type: BinaryDataType.Uint32,
+                itemSize: 4,
+                normalized: false
+            }),
+            256, 1
+        ),
+        positions: new AttributeDataTexture(
+            AttributeSpec.fromJSON({
+                name: "positions",
+                type: BinaryDataType.Float32,
+                itemSize: 3,
+                normalized: false
+            }),
+            256, 1
+        ),
+        harmonics: new AttributeDataTexture(
+            AttributeSpec.fromJSON({
+                name: "harmonics",
+                type: BinaryDataType.Float32,
+                itemSize: 3,
+                normalized: false
+            }),
+            256, 9
+        )
+    };
+
+    #uniforms = {
+        lpv_t_mesh_vertices: {
+            type: "t",
+            value: this.#textures.vertex.texture
+        },
+        lpv_t_mesh_neighbours: {
+            type: "t",
+            value: this.#textures.neighbour.texture
+        },
+        lpv_t_probe_positions: {
+            type: "t",
+            value: this.#textures.positions.texture
+        },
+        lpv_t_probe_data: {
+            type: "t",
+            value: this.#textures.harmonics.texture
+        },
+        lpv_t_mesh_lookup: {
+            type: "t",
+            value: this.#mesh_lookup
+        },
+        lpv_v3_bounds_min: {
+            value: new Vector3(),
+        },
+        lpv_v3_bounds_max: {
+            value: new Vector3(),
+        },
+        lpv_u_mesh_tet_count: {
+            value: 0
+        },
+        lpv_f_intensity: {
+            value: 1
+        }
+    };
+
+    #uniform_version = -1;
+
+    /**
+     *
+     * @param {{uniforms, glslVersion, defines, vertexShader, fragmentShader}} shader
+     */
+    #onBeforeCompile = (shader) => {
+        Object.assign(shader.uniforms, this.#uniforms);
+
+        console.log(this.#uniforms)
+
+        shader.vertexShader = build_vertex_shader(shader.vertexShader);
+        shader.fragmentShader = build_fragment_shader(shader.fragmentShader);
+    };
+
+    #materials = [];
+
+    /**
+     *
+     * @return {number}
+     */
+    get intensity() {
+        return this.#uniforms.lpv_f_intensity.value;
+    }
+
+    /**
+     *
+     * @param {number} v
+     */
+    set intensity(v) {
+        this.#uniforms.lpv_f_intensity.value = v;
+    }
+
+    /**
+     *
+     * @param {LightProbeVolume} volume
+     */
+    constructor({
+                    volume
+                }) {
+        super();
+
+        this.#volume = volume;
+    }
+
+    update_bounds() {
+
+        aabb3_from_v3_array(this.#mesh_bounds, this.#volume.points, this.#volume.count * 3);
+
+    }
+
+    update_lookup() {
+        this.update_bounds();
+
+        const bounds = this.#mesh_bounds;
+
+        const lookup = this.#mesh_lookup;
+
+        const image = lookup.image;
+
+        const res_z = image.depth;
+        const res_y = image.height;
+        const res_x = image.width;
+
+        const volume = this.#volume;
+
+        let last_tet = 0;
+
+        for (let z = 0; z < res_z; z++) {
+            for (let y = 0; y < res_y; y++) {
+                for (let x = 0; x < res_x; x++) {
+
+                    // convert pixel position to world coordinate
+                    const n_x = (x + 0.5) / res_x
+                    const n_y = (y + 0.5) / res_y
+                    const n_z = (z + 0.5) / res_z
+
+                    const w_x = n_x * bounds.getExtentsX() + bounds.x0;
+                    const w_y = n_y * bounds.getExtentsY() + bounds.y0;
+                    const w_z = n_z * bounds.getExtentsZ() + bounds.z0;
+
+                    const tet = volume.mesh.findTetraContainingPoint(w_x, w_y, w_z, volume.points, last_tet);
+
+                    if (tet !== -1) {
+                        last_tet = tet;
+                    }
+
+                    image.data[z * res_y * res_x + y * res_x + x] = last_tet;
+
+                }
+            }
+        }
+
+        lookup.needsUpdate = true;
+    }
+
+    update() {
+        const lpv = this.#volume;
+
+        if (lpv === null) {
+            return;
+        }
+
+        if (this.#uniform_version === lpv.version) {
+            return;
+        }
+
+        this.update_lookup();
+
+        this.#uniforms.lpv_u_mesh_tet_count.value = lpv.mesh.count;
+
+        this.#uniforms.lpv_v3_bounds_min.value.set(
+            this.#mesh_bounds.x0, this.#mesh_bounds.y0, this.#mesh_bounds.z0
+        );
+        this.#uniforms.lpv_v3_bounds_max.value.set(
+            this.#mesh_bounds.x1, this.#mesh_bounds.y1, this.#mesh_bounds.z1
+        );
+
+        this.#uniform_version = lpv.version;
+
+        console.time('prepareTextures');
+
+        vector_buffer_to_attribute_texture(this.#textures.positions, lpv.points, lpv.count, 3);
+        vector_buffer_to_attribute_texture(this.#textures.harmonics, lpv.harmonics, lpv.count * 9, 3);
+        tetrahedral_mesh_to_texture(
+            this.#textures.vertex, this.#textures.neighbour, lpv.mesh
+        );
+
+        console.timeEnd('prepareTextures');
+
+        for (let i = 0; i < this.#materials.length; i++) {
+            const material = this.#materials[i];
+
+            // material.uniformsNeedUpdate = true;
+        }
+    }
+
+    transform(source) {
+        if (source.hasOwnProperty(PROPERTY_TRANSFORMER_MARKER)) {
+            // already transformed
+
+            if (source[PROPERTY_TRANSFORMER_MARKER] !== this) {
+                throw new Error('The material is already transformed, but is associated with a different transformer instance');
+            } else {
+                return source;
+            }
+
+        }
+
+
+        let result = source;
+
+        if (isLitMaterial(source)) {
+
+            result.clone();
+
+            result.onBeforeCompile = composeCompile(source.onBeforeCompile, this.#onBeforeCompile);
+
+            result[PROPERTY_TRANSFORMER_MARKER] = this;
+
+            this.#materials.push(result);
+        }
+
+        return result;
+    }
+}

package/src/engine/graphics/sh3/gi/material/build_fragment_shader.d.ts

@@ -0,0 +1,6 @@
+/**
+ *
+ * @param {string} source
+ */
+export function build_fragment_shader(source: string): string;
+//# sourceMappingURL=build_fragment_shader.d.ts.map

package/src/engine/graphics/sh3/gi/material/build_fragment_shader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build_fragment_shader.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/sh3/gi/material/build_fragment_shader.js"],"names":[],"mappings":"AAsDA;;;GAGG;AACH,8CAFW,MAAM,UAchB"}

package/src/engine/graphics/sh3/gi/material/build_fragment_shader.js

@@ -0,0 +1,71 @@
+import { insert_after } from "../../../../../core/primitives/strings/insert_after.js";
+
+const PREAMBLE = `
+
+        uniform float lpv_f_intensity;
+        
+        varying vec3[9] lpv_values;
+        
+        // vec3 shGetIrradianceAt( in vec3 normal, in vec3 shCoefficients[ 9 ] ) {
+        //     // normal is assumed to have unit length
+        //     float x = normal.x, y = normal.y, z = normal.z;
+        //    
+        //     // band 0
+        //     vec3 result = shCoefficients[ 0 ] * 0.886227;
+        //    
+        //     // band 1
+        //     result -= shCoefficients[ 1 ] * 2.0 * 0.511664 * y;
+        //     result += shCoefficients[ 2 ] * 2.0 * 0.511664 * z;
+        //     result -= shCoefficients[ 3 ] * 2.0 * 0.511664 * x;
+        //    
+        //     // band 2
+        //     result += shCoefficients[ 4 ] * 2.0 * 0.429043 * x * y;
+        //     result -= shCoefficients[ 5 ] * 2.0 * 0.429043 * y * z;
+        //     result += shCoefficients[ 6 ] * ( 0.743125 * z * z - 0.247708 );
+        //     result -= shCoefficients[ 7 ] * 2.0 * 0.429043 * x * z;
+        //     result += shCoefficients[ 8 ] * 0.429043 * ( x * x - y * y );
+        //    
+        //     return result;
+        // }
+        //
+        // vec3 inverseTransformDirection( in vec3 normal, in mat4 matrix ) {
+        //
+        //     // matrix is assumed to be orthogonal
+        //    
+        //     return normalize( ( vec4( normal, 0.0 ) * matrix ).xyz );
+        //
+        // }
+        //
+        // vec3 lpv_getLightProbeIrradiance( const in vec3 lightProbe[ 9 ], const in vec3 normal ) {
+        //
+        //     vec3 worldNormal = inverseTransformDirection( normal, viewMatrix );
+        //
+        //     vec3 irradiance = shGetIrradianceAt( worldNormal, lightProbe );
+        //
+        //     return irradiance;
+        //
+        // }
+`;
+
+const ACCUMULATION = `
+    irradiance += getLightProbeIrradiance(lpv_values, geometryNormal )* lpv_f_intensity;
+`;
+
+
+/**
+ *
+ * @param {string} source
+ */
+export function build_fragment_shader(source) {
+
+    let result = PREAMBLE + source;
+
+
+    result = insert_after(
+        result,
+        '#include <lights_fragment_begin>',
+        ACCUMULATION
+    );
+
+    return result;
+}

package/src/engine/graphics/sh3/gi/material/build_vertex_shader.d.ts

@@ -0,0 +1,6 @@
+/**
+ *
+ * @param {string} source
+ */
+export function build_vertex_shader(source: string): string;
+//# sourceMappingURL=build_vertex_shader.d.ts.map

package/src/engine/graphics/sh3/gi/material/build_vertex_shader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build_vertex_shader.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/sh3/gi/material/build_vertex_shader.js"],"names":[],"mappings":"AA+OA;;;GAGG;AACH,4CAFW,MAAM,UAchB"}

package/src/engine/graphics/sh3/gi/material/build_vertex_shader.js

@@ -0,0 +1,256 @@
+import { insert_after } from "../../../../../core/primitives/strings/insert_after.js";
+
+const PREAMBLE = `
+    #ifndef LPV_SHADER_CHUNK_PREAMBLE
+        #define LPV_SHADER_CHUNK_PREAMBLE
+        
+        precision highp usampler2D;
+        precision highp usampler3D;
+        
+        uniform usampler2D lpv_t_mesh_vertices;
+        uniform usampler2D lpv_t_mesh_neighbours;
+        uniform usampler3D lpv_t_mesh_lookup;
+        
+        uniform sampler2D lpv_t_probe_positions;
+        uniform sampler2D lpv_t_probe_data;
+        
+        uniform uint lpv_u_mesh_tet_count;
+        uniform vec3 lpv_v3_bounds_min;
+        uniform vec3 lpv_v3_bounds_max;
+        
+        varying vec3[9] lpv_values;
+        
+        #define SEARCH_STEP_LIMIT 64u
+        #define INVALID_TET 1073741823u
+        
+        ivec2 lpv_index_to_256_coordinate(uint index){
+        
+            uint pixel_x = index % 256u;
+            uint pixel_y = index / 256u; 
+            
+            return ivec2(int(pixel_x), int(pixel_y));
+        }
+        
+        uvec4 lpv_mesh_getVertices(uint tet_index){
+            ivec2 p = lpv_index_to_256_coordinate(tet_index);
+                    
+            return texelFetch(lpv_t_mesh_vertices, p, 0);
+            
+        }
+        
+        uvec4 lpv_mesh_getNeighbours(uint tet_index){
+            ivec2 p = lpv_index_to_256_coordinate(tet_index);
+            
+            return texelFetch(lpv_t_mesh_neighbours, p, 0);
+        }
+        
+        vec3[9] lpv_probe_getData(uint probe_index){
+            
+            
+            int slot = int( probe_index % 256u );
+            int column = int(probe_index / 256u); 
+            
+            int offset_x = int(slot * 9);
+            
+            vec3[9] result;
+            
+            for(int i=0; i<9; i++){
+                result[i] = texelFetch(lpv_t_probe_data, ivec2(offset_x + i, column),0).rgb;
+            }
+            
+            return result;
+        }
+        
+        vec3 lpv_probe_getPosition(uint probe_index){
+            return texelFetch(lpv_t_probe_positions, lpv_index_to_256_coordinate(probe_index), 0).rgb;
+        }
+        
+        mat3 lpv_mesh_makeMatrix(vec3 p0, vec3 p1, vec3 p2, vec3 p3){
+        
+            return inverse(
+                mat3(
+                    p0 - p3,
+                    p1 - p3,
+                    p2 - p3
+                )
+            );
+        
+        }
+        
+        vec4 lpv_mesh_getBarycentricCoordinates(uint tet_index, vec3 position){
+            uvec4 vertices = lpv_mesh_getVertices(tet_index);
+               
+            vec3 p0 = lpv_probe_getPosition(vertices[0]);
+            vec3 p1 = lpv_probe_getPosition(vertices[1]);
+            vec3 p2 = lpv_probe_getPosition(vertices[2]);
+            vec3 p3 = lpv_probe_getPosition(vertices[3]);
+        
+            mat3 matrix = lpv_mesh_makeMatrix(p0, p1, p2, p3);
+            
+            vec3 mult = matrix * (position - p3);
+            
+            return vec4(mult, 1.0 - mult.x - mult.y - mult.z);
+        }
+        
+        void lpv_getTetrahedron(
+            in vec3 position ,
+            in uint tet_guess,
+            out uint tet_index,
+            out vec4 weights
+        ){
+            uint came_from = 0u;
+            
+            tet_index = tet_guess;
+                    
+            for(uint i=0u; i < SEARCH_STEP_LIMIT; i++){
+            
+                weights = lpv_mesh_getBarycentricCoordinates(tet_index, position);
+            
+                if(weights.x >= 0.0 && weights.y >= 0.0 && weights.z >= 0.0 && weights.w >= 0.0){
+                    return;
+                }
+                
+                uvec4 neighbors = lpv_mesh_getNeighbours(tet_index);
+                
+                uint next_tet;
+                
+                // Otherwise find the smallest barycentric coord and move in that direction
+                if (weights.x < weights.y && weights.x < weights.z && weights.x < weights.w) {
+                    next_tet = neighbors[0];
+                } else if (weights.y < weights.z && weights.y < weights.w) {
+                    next_tet = neighbors[1];
+                } else if (weights.z < weights.w) {
+                    next_tet = neighbors[2];
+                } else {
+                    next_tet = neighbors[3];
+                }
+                
+                if(next_tet == came_from){
+                    // numerical instability caused us to oscillate on the boundary
+                    return;
+                }
+                
+                came_from = tet_index;  
+                tet_index = next_tet;
+            }
+        
+            tet_index = INVALID_TET;
+        }
+        
+        vec3[9] lpv_interpolate_probes(vec4 weights, uint tet_index){
+            
+            uvec4 vertices = lpv_mesh_getVertices(tet_index);
+            
+            vec3[9] probe0 = lpv_probe_getData(vertices[0]);
+            vec3[9] probe1 = lpv_probe_getData(vertices[1]);
+            vec3[9] probe2 = lpv_probe_getData(vertices[2]);
+            vec3[9] probe3 = lpv_probe_getData(vertices[3]);
+        
+            vec3[9] result;
+            
+            for(int i=0; i< 9; i++){
+                
+                result[i] = probe0[i]* weights[0]
+                            + probe1[i]* weights[1]
+                            + probe2[i]* weights[2]
+                            + probe3[i]* weights[3];
+            
+            }
+            
+            return result;
+        }
+        
+        vec4 lpv_bias_weight_by_normal(const in vec3 position, const in vec3 normal, const in uint tet_index, const in vec4 weights){
+            
+            uvec4 vertices = lpv_mesh_getVertices(tet_index);
+            
+            vec4 result = weights;
+            
+            for(int i = 0; i< 4; i++){
+                vec3 p = lpv_probe_getPosition(vertices[i]) - position;
+                
+                if(dot(normal, p) <= 0.0){
+                    // behind the surface, bias to 0
+                    result[i] = 0.0;
+                }
+            }
+            
+            float total_weight = result.x + result.y + result.z + result.w;
+            
+            // needs to add up to 1
+            result = result / total_weight;
+            
+            return result;
+        }
+        
+        uint lpv_guess_initial_tet(vec3 position){
+            
+            vec3 lpv_mesh_bounds_min = lpv_v3_bounds_min;
+            vec3 lpv_mesh_bounds_max = lpv_v3_bounds_max;
+            
+            vec3 lookup_coordinates = (position - lpv_mesh_bounds_min) / (lpv_mesh_bounds_max - lpv_mesh_bounds_min) ;
+           
+            return textureLod( lpv_t_mesh_lookup, lookup_coordinates, 0.0 ).r;
+        
+        }
+        
+    #endif
+`;
+
+
+const SHADER_CHUNK_ACCUMULATION = `
+    {
+        // lookup nearby tet
+        vec3 lpv_mesh_bounds_min = lpv_v3_bounds_min;
+        vec3 lpv_mesh_bounds_max = lpv_v3_bounds_max;
+        vec3 lookup_coordinates = (worldPosition.xyz - lpv_mesh_bounds_min) / (lpv_mesh_bounds_max - lpv_mesh_bounds_min) ;
+        
+        uint nearest_tet = lpv_guess_initial_tet( worldPosition.xyz );
+    
+        uint tet;
+        vec4 weights;
+        lpv_getTetrahedron(worldPosition.xyz, nearest_tet, tet, weights);
+        
+        
+        if(tet == INVALID_TET){
+            lpv_values = vec3[](
+                vec3(0.0, 0.0, 0.0),
+                vec3(0.0, 0.0, 0.0),
+                vec3(0.0, 0.0, 0.0),
+                
+                vec3(0.0, 0.0, 0.0),
+                vec3(0.0, 0.0, 0.0),
+                vec3(0.0, 0.0, 0.0),
+            
+                vec3(0.0, 0.0, 0.0),
+                vec3(0.0, 0.0, 0.0),
+                vec3(0.0, 0.0, 0.0)
+            );
+        }else{
+            
+	        vec3 worldNormal = normalize(inverseTransformDirection( normalize(normal), viewMatrix ));
+            
+            //weights = lpv_bias_weight_by_normal(worldPosition.xyz, normal, tet, weights);
+        
+            lpv_values = lpv_interpolate_probes(weights, tet);
+        }
+    }
+`
+
+/**
+ *
+ * @param {string} source
+ */
+export function build_vertex_shader(source) {
+    let result = PREAMBLE + source;
+
+    result = insert_after(
+        result,
+        '#include <fog_vertex>',
+        SHADER_CHUNK_ACCUMULATION
+    );
+
+    // console.log(result)
+
+    return result;
+}

package/src/engine/graphics/sh3/gi/tetrahedral_mesh_to_texture.js

@@ -31,9 +31,6 @@ export function tetrahedral_mesh_to_texture(
     vertices.resize(tetrahedron_count);
     neighbours.resize(tetrahedron_count);
 
-    vertices.build()
-    neighbours.build();
-
     const vertices_data = vertices.data;
     const neighbours_data = neighbours.data;
 
@@ -44,8 +41,11 @@ export function tetrahedral_mesh_to_texture(
         for (let j = 0; j < 4; j++) {
             vertices_data[i4 + j] = mesh.getVertexIndex(i, j);
 
-            neighbours_data[i4 + j] = mesh.getNeighbour(i, j);
+            neighbours_data[i4 + j] = mesh.getNeighbour(i, j) >>> 2;
         }
 
     }
+
+    vertices.texture.needsUpdate = true;
+    neighbours.texture.needsUpdate = true;
 }