@woosh/meep-engine 2.108.2 → 2.108.4

package/src/core/math/factorial.js

@@ -0,0 +1,15 @@
+/**
+ * Compute factorial of X
+ * @param {number} x
+ * @return {number}
+ */
+export function factorial(x) {
+
+    let result = 1;
+
+    for (let i = x; i > 0; --i) {
+        result *= i;
+    }
+
+    return result;
+}

package/src/core/math/factorial.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=factorial.spec.d.ts.map

package/src/core/math/factorial.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factorial.spec.d.ts","sourceRoot":"","sources":["../../../../src/core/math/factorial.spec.js"],"names":[],"mappings":""}

package/src/core/math/factorial.spec.js

@@ -0,0 +1,9 @@
+import { factorial } from "./factorial.js";
+
+test("basics",()=>{
+
+    expect(factorial(1)).toBe(1);
+
+    expect(factorial(5)).toBe(120);
+
+});

package/src/core/model/DebouncedObservedBoolean.d.ts

@@ -17,7 +17,7 @@ export class DebouncedObservedBoolean extends ObservedBoolean {
     constructor(source: ObservedBoolean, time: number, mode?: DebouncedObservedBooleanMode | number);
     __source: ObservedBoolean;
     time: number;
-    __timeout: NodeJS.Timeout;
+    __timeout: NodeJS.Timer;
     mode: number;
     link(): void;
     unlink(): void;

package/src/core/model/DebouncedObservedBoolean.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DebouncedObservedBoolean.d.ts","sourceRoot":"","sources":["../../../../src/core/model/DebouncedObservedBoolean.js"],"names":[],"mappings":"2CAYU,MAAM;;;;;;AAQhB;;GAEG;AACH;IACI;;;;;OAKG;IACH,oBAJW,eAAe,QACf,MAAM,SACN,4BAA4B,GAAC,MAAM,EAY7C;IAPG,0BAAsB;IAEtB,aAAgB;IAEhB,0BAAqB;IAErB,aAAgB;IAGpB,aAGC;IAED,eAGC;IAGD;;;OAGG;IACH,uBAKC;IAED;;OAEG;IACH,0BAOC;IAED;;;OAGG;IACH,OAFW,OAAO,QAYjB;IANO,aAAgB;IAQxB;;;;;OAKG;IACH,6BAYC;IAED,gBAEC;CAEJ;4BAhH2B,sBAAsB"}
+{"version":3,"file":"DebouncedObservedBoolean.d.ts","sourceRoot":"","sources":["../../../../src/core/model/DebouncedObservedBoolean.js"],"names":[],"mappings":"2CAYU,MAAM;;;;;;AAQhB;;GAEG;AACH;IACI;;;;;OAKG;IACH,oBAJW,eAAe,QACf,MAAM,SACN,4BAA4B,GAAC,MAAM,EAY7C;IAPG,0BAAsB;IAEtB,aAAgB;IAEhB,wBAAqB;IAErB,aAAgB;IAGpB,aAGC;IAED,eAGC;IAGD;;;OAGG;IACH,uBAKC;IAED;;OAEG;IACH,0BAOC;IAED;;;OAGG;IACH,OAFW,OAAO,QAYjB;IANO,aAAgB;IAQxB;;;;;OAKG;IACH,6BAYC;IAED,gBAEC;CAEJ;4BAhH2B,sBAAsB"}

package/src/core/model/node-graph/node/NodeDescription.d.ts

@@ -1,13 +1,15 @@
-import {Port} from "./Port";
 import {DataType} from "../DataType";
+import {Port} from "./Port";
 import {PortDirection} from "./PortDirection";
 
 export class NodeDescription {
 
-    readonly inPorts:Port[]
-    readonly outPorts:Port[]
+    readonly inPorts: Port[]
+    readonly outPorts: Port[]
 
     getPorts(): Port[]
 
-    createPort(type: DataType, name:string,direction:PortDirection): number
+    createPort(type: DataType, name: string, direction: PortDirection): number
+
+    toJSON(): any
 }

package/src/engine/asset/loaders/material/computeTextureEquality.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"computeTextureEquality.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/asset/loaders/material/computeTextureEquality.js"],"names":[],"mappings":"AAKA;;;;;GAKG;AACH,gEAFa,OAAO,CAoDnB;AAGD;;;;;GAKG;AACH,sCAJW,8DAAM,EAAE,GAAC;IAAC,KAAK,EAAC,MAAM,CAAC;IAAC,MAAM,EAAC,MAAM,CAAA;CAAC,KACtC,8DAAM,EAAE,GAAC;IAAC,KAAK,EAAC,MAAM,CAAC;IAAC,MAAM,EAAC,MAAM,CAAA;CAAC,GACpC,OAAO,CAwDnB"}
+{"version":3,"file":"computeTextureEquality.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/asset/loaders/material/computeTextureEquality.js"],"names":[],"mappings":"AAMA;;;;;GAKG;AACH,gEAFa,OAAO,CAoDnB;AAGD;;;;;GAKG;AACH,sCAJW,8DAAM,EAAE,GAAC;IAAC,KAAK,EAAC,MAAM,CAAC;IAAC,MAAM,EAAC,MAAM,CAAA;CAAC,KACtC,8DAAM,EAAE,GAAC;IAAC,KAAK,EAAC,MAAM,CAAC;IAAC,MAAM,EAAC,MAAM,CAAA;CAAC,GACpC,OAAO,CA8DnB"}

package/src/engine/asset/loaders/material/computeTextureEquality.js

@@ -1,5 +1,6 @@
-import { computeImageBitmapEquality } from "./computeImageBitmapEquality.js";
 import { fastArrayEquals } from "../../../../core/collection/array/fastArrayEquals.js";
+import { isTypedArray } from "../../../../core/collection/array/typed/isTypedArray.js";
+import { computeImageBitmapEquality } from "./computeImageBitmapEquality.js";
 
 //
 
@@ -120,6 +121,12 @@ export function textureImagesEqual(a, b) {
 
     }
 
+    if (isTypedArray(a.data) && isTypedArray(b.data)) {
+        if (!textureMipmapEqual(a, b)) {
+            return false;
+        }
+    }
+
     // assume equivalent
     return true;
 }

package/src/engine/graphics/ecs/mesh-v2/render/adapters/AbstractRenderAdapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AbstractRenderAdapter.d.ts","sourceRoot":"","sources":["../../../../../../../../src/engine/graphics/ecs/mesh-v2/render/adapters/AbstractRenderAdapter.js"],"names":[],"mappings":"AA0BA;IAGQ;;;;OAIG;IACH,0BAHU,MAAM,CAGO;IAEvB;;;;OAIG;IACH,qBAHU,MAAM,QAAQ,EAAE,CAGP;IAGvB;;OAEG;IACH,yBAEC;IAED;;;;;;OAMG;IACH,gBALW,MAAM,cAAc,YACpB,MAAM,QAAQ,kBACd,MAAM,GACJ,MAAM,CAIlB;IAED;;;;OAIG;IACH,iCAFa,OAAO,CAInB;IAED;;;;OAIG;IACH,yBAFa,IAAI,CAIhB;IAGD;;;;OAIG;IACH,sBAHW,MAAM,aAAa,0BAK7B;IAED,kBAEC;IAED,cAEC;IAED;;;;OAIG;IACH,YAFY,SAAS,CAIpB;IAED;;OAEG;IACH,iEAEC;IAED;;OAEG;IACH,2BAEC;IAED,gBAEC;IAGL;;;OAGG;IACH,wCAFU,OAAO,CAE4C;CAN5D"}
+{"version":3,"file":"AbstractRenderAdapter.d.ts","sourceRoot":"","sources":["../../../../../../../../src/engine/graphics/ecs/mesh-v2/render/adapters/AbstractRenderAdapter.js"],"names":[],"mappings":"AA4BA;IAGQ;;;;OAIG;IACH,0BAHU,MAAM,CAGO;IAEvB;;;;OAIG;IACH,qBAHU,MAAM,QAAQ,EAAE,CAGP;IAGvB;;OAEG;IACH,yBAEC;IAED;;;;;;OAMG;IACH,gBALW,MAAM,cAAc,YACpB,MAAM,QAAQ,kBACd,MAAM,GACJ,MAAM,CAIlB;IAED;;;;OAIG;IACH,iCAFa,OAAO,CAInB;IAED;;;;OAIG;IACH,yBAFa,IAAI,CAIhB;IAGD;;;;OAIG;IACH,sBAHW,MAAM,aAAa,0BAK7B;IAED,kBAEC;IAED,cAEC;IAED;;;;OAIG;IACH,YAFY,SAAS,CAIpB;IAED;;OAEG;IACH,iEAEC;IAED;;OAEG;IACH,2BAEC;IAED,gBAEC;IAGL;;;OAGG;IACH,wCAFU,OAAO,CAE4C;CAN5D"}

package/src/engine/graphics/ecs/mesh-v2/render/adapters/AbstractRenderAdapter.js

@@ -1,4 +1,6 @@
-import { array_quick_sort_by_comparator } from "../../../../../../core/collection/array/arrayQuickSort.js";
+import {
+    array_quick_sort_by_comparator
+} from "../../../../../../core/collection/array/array_quick_sort_by_comparator.js";
 
 /**
  *

package/src/engine/graphics/filter/sampler2d_flipY_in_place.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @param {Uint8Array} input
+ * @param {number} width
+ * @param {number} height
+ * @param {number} channel_count
+ */
+export function sampler2d_flipY_in_place(input: Uint8Array, width: number, height: number, channel_count?: number): void;
+//# sourceMappingURL=sampler2d_flipY_in_place.d.ts.map

package/src/engine/graphics/filter/sampler2d_flipY_in_place.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sampler2d_flipY_in_place.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics/filter/sampler2d_flipY_in_place.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,gDALW,UAAU,SACV,MAAM,UACN,MAAM,kBACN,MAAM,QAyBhB"}

package/src/engine/graphics/filter/{FlipArrayInPlace.js → sampler2d_flipY_in_place.js}

@@ -4,7 +4,7 @@
  * @param {number} height
  * @param {number} channel_count
  */
-export function flipArrayInPlace(input, width, height, channel_count = 4) {
+export function sampler2d_flipY_in_place(input, width, height, channel_count = 4) {
     const row_size = width * channel_count;
     let t, x0, x1;
     let i = 0;

package/src/engine/graphics/geometry/bvh/buffered/bvh32_set_leaf_from_triangle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bvh32_set_leaf_from_triangle.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/geometry/bvh/buffered/bvh32_set_leaf_from_triangle.js"],"names":[],"mappings":"AAGA;;;;;;;;GAQG;AACH,mFANW,MAAM,YACN,MAAM,EAAE,GAAC,YAAY,WACrB,MAAM,WACN,MAAM,WACN,MAAM,QA8BhB"}
+{"version":3,"file":"bvh32_set_leaf_from_triangle.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/geometry/bvh/buffered/bvh32_set_leaf_from_triangle.js"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,mFANW,MAAM,YACN,MAAM,EAAE,GAAC,YAAY,WACrB,MAAM,WACN,MAAM,WACN,MAAM,QAQhB"}

package/src/engine/graphics/geometry/bvh/buffered/bvh32_set_leaf_from_triangle.js

@@ -1,5 +1,4 @@
-import { max3 } from "../../../../../core/math/max3.js";
-import { min3 } from "../../../../../core/math/min3.js";
+import { aabb3_compute_from_triangle } from "../../../../../core/geom/3d/aabb3_compute_from_triangle.js";
 
 /**
  *
@@ -11,31 +10,10 @@ import { min3 } from "../../../../../core/math/min3.js";
  * @param {number} c_index
  */
 export function bvh32_set_leaf_from_triangle(bvh, triangle_index, vertices, a_index, b_index, c_index) {
-    const a = a_index * 3;
-    const b = b_index * 3;
-    const c = c_index * 3;
 
-    // read actual positions of each vertex
-    const aX = vertices[a];
-    const aY = vertices[a + 1];
-    const aZ = vertices[a + 2];
+    const address = bvh.getLeafAddress(triangle_index);
+    aabb3_compute_from_triangle(bvh.__data_float32, address, vertices, a_index, b_index, c_index);
+    bvh.__data_uint32[address + 6] = triangle_index;
 
-    const bX = vertices[b];
-    const bY = vertices[b + 1];
-    const bZ = vertices[b + 2];
+}
 
-    const cX = vertices[c];
-    const cY = vertices[c + 1];
-    const cZ = vertices[c + 2];
-
-    // compute bounds of the triangle
-    const x0 = min3(aX, bX, cX);
-    const y0 = min3(aY, bY, cY);
-    const z0 = min3(aZ, bZ, cZ);
-
-    const x1 = max3(aX, bX, cX);
-    const y1 = max3(aY, bY, cY);
-    const z1 = max3(aZ, bZ, cZ);
-
-    bvh.setLeafData(triangle_index, triangle_index, x0, y0, z0, x1, y1, z1)
-}

package/src/engine/graphics/render/Lines.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Lines.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics/render/Lines.js"],"names":[],"mappings":"AAuBA;IAGQ,cAAc;IACd,iBAAkB;IAElB;;;OAGG;IACH,UAFU,cAAc,GAAC,IAAI,CAEe;IAE5C,sDAAoE;IASxE;;;OAGG;IACH,YAFW,MAAM,QAOhB;IAED;;;OAGG;IACH,mBAFW,MAAM,QAWhB;IAED;;;;;OAKG;IACH,kDA2BC;IAED,cAUC;IAED,gBAGC;CACJ;+BAvH8B,kCAAkC;kCAFC,OAAO;6BAAP,OAAO"}
+{"version":3,"file":"Lines.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics/render/Lines.js"],"names":[],"mappings":"AA+BA;IAGQ,cAAc;IACd,iBAAkB;IAElB;;;OAGG;IACH,UAFU,cAAc,GAAC,IAAI,CAEe;IAE5C,sDAAoE;IASxE;;;OAGG;IACH,YAFW,MAAM,QAOhB;IAED;;;OAGG;IACH,mBAFW,MAAM,QAWhB;IAED;;;;;OAKG;IACH,kDA2BC;IAED,cAUC;IAED,gBAGC;CACJ;+BA/H8B,kCAAkC;kCAFC,OAAO;6BAAP,OAAO"}

package/src/engine/graphics/render/Lines.js

@@ -1,9 +1,17 @@
 import { DynamicDrawUsage, LineBasicMaterial, LineSegments } from "three";
-import { array_copy } from "../../../core/collection/array/array_copy.js";
-import { BufferGeometry } from "three/src/core/BufferGeometry.js";
 import { Float32BufferAttribute } from "three/src/core/BufferAttribute.js";
+import { BufferGeometry } from "three/src/core/BufferGeometry.js";
+import { assert } from "../../../core/assert.js";
+import { array_copy } from "../../../core/collection/array/array_copy.js";
 
+/**
+ *
+ * @param {number} capacity
+ * @return {BufferGeometry}
+ */
 function buildGeometry(capacity) {
+    assert.isNonNegativeInteger(capacity, 'capacity');
+
     const geometry = new BufferGeometry();
 
     geometry.dynamic = true;

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"}