@woosh/meep-engine 2.107.0 → 2.108.0

package/src/engine/asset/loaders/image/png/PNGReader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PNGReader.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/asset/loaders/image/png/PNGReader.js"],"names":[],"mappings":"AAsDA;;;;GAIG;AACH,iCAHW,WAAW,QAqBrB;;IAvBD;;;;OAIG;IACH,mBAHW,WAAW,EAqBrB;IAhBG,UAAU;IAEV,kBAAkC;IAElC,SAAoB;IAEpB,kBAAoB;IAEpB,qBAAgC;IAGhC;;;OAGG;IACH,aAFU,OAAO,CAEO;IAG5B;;;;OAIG;IACH,kBAHW,MAAM,GACL,UAAU,CAQrB;IAED;;OAEG;IACH,qBAmBC;IAFG,mBAAoB;IAIxB;;;;;;;;;OASG;IACH,eAFa,MAAM,CA4ElB;IAGD;;;OAGG;IACH,kBAFW,UAAU,QAOpB;IAED;;;OAGG;IACH,kBAFW,UAAU,QAapB;IAED;;;;OAIG;IACH,kBAFW,UAAU;;;;;MAiCpB;IAGD;;;;OAIG;IACH,kBAFW,UAAU;;;MA6BpB;IAED;;;OAGG;IACH,kBAFW,UAAU,QASpB;IACD;;;;OAIG;IACH,kBAFW,UAAU,QAqBpB;IAED;;;;;;;;;;;OAWG;IACH,6BAWC;IAED;;;OAGG;IACH,6BAEC;IAED;;OAEG;IACH,6BAGC;IAED;;;OAGG;IACH,kBAFW,UAAU,QAIpB;IAED;;OAEG;IACH,mBACC;IAED;;OAEG;IACH,qBAwBC;IAID,+BAuFC;IAED;;;OAGG;IACH,qBAFW,UAAU,SAIpB;IAKD;;;;OAIG;IACH,oGAYC;IAED;;;;;OAKG;IACH,mGAYC;IAED;;;;OAIG;IACH,wGA+BC;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,sGA8CC;IAED;;;;;;;;;;;;OAYG;IACH,SAFa,GAAG,CAqBf;;oBA1rBmB,UAAU;6BAJD,4CAA4C"}
+{"version":3,"file":"PNGReader.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/asset/loaders/image/png/PNGReader.js"],"names":[],"mappings":"AAsDA;;;;GAIG;AACH,iCAHW,WAAW,QA0CrB;;IA5CD;;;;OAIG;IACH,mBAHW,WAAW,EA0CrB;IAtCG;;;OAGG;IACH,GAFU,MAAM,CAEN;IAEV;;;OAGG;IACH,OAFU,UAAU,CAEc;IAElC;;;OAGG;IACH,KAFU,GAAG,CAEO;IAEpB,kBAAoB;IAEpB;;;OAGG;IACH,QAFU,YAAY,CAEU;IAGhC;;;OAGG;IACH,aAFU,OAAO,CAEO;IAExB;;;OAGG;IACH,QAFU,UAAU,CAEW;IAGnC;;;;OAIG;IACH,kBAHW,MAAM,GACL,UAAU,CAQrB;IAED;;OAEG;IACH,qBAkBC;IAED;;;;;;;;;OASG;IACH,eAFa,MAAM,CA4ElB;IAGD;;;OAGG;IACH,kBAFW,UAAU,QAOpB;IAED;;;OAGG;IACH,kBAFW,UAAU,QAapB;IAED;;;;OAIG;IACH,kBAFW,UAAU;;;;;MAiCpB;IAGD;;;;OAIG;IACH,kBAFW,UAAU;;;MA6BpB;IAED;;;OAGG;IACH,kBAFW,UAAU,QASpB;IACD;;;;OAIG;IACH,kBAFW,UAAU,QAqBpB;IAED;;;;;;;;;;;OAWG;IACH,6BAWC;IAED;;;OAGG;IACH,6BAEC;IAED;;OAEG;IACH,6BAGC;IAED;;;OAGG;IACH,kBAFW,UAAU,QAIpB;IAED;;OAEG;IACH,mBACC;IAED;;OAEG;IACH,qBAwBC;IAID;;OAEG;IACH,oBAFW,UAAU,QAyFpB;IAED;;;OAGG;IACH,qBAFW,UAAU,SAIpB;IAKD;;;;OAIG;IACH,oGAYC;IAED;;;;;OAKG;IACH,mGAYC;IAED;;;;OAIG;IACH,wGA+BC;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,sGA8CC;IAED;;;OAGG;IACH,SAFa,GAAG,CAqBf;;oBAxsBmB,UAAU;6BAJD,4CAA4C"}

package/src/engine/asset/loaders/image/png/PNGReader.js

@@ -35,10 +35,10 @@ function inflate(encoded_chunk) {
  * @return {number}
  */
 function readUInt32(buffer, offset) {
-    return (buffer[offset] << 24) +
-        (buffer[offset + 1] << 16) +
-        (buffer[offset + 2] << 8) +
-        (buffer[offset + 3]);
+    return (buffer[offset] << 24)
+        | (buffer[offset + 1] << 16)
+        | (buffer[offset + 2] << 8)
+        | (buffer[offset + 3]);
 }
 
 
@@ -58,15 +58,30 @@ function readUInt8(buffer, offset) {
  * @constructor
  */
 export function PNGReader(bytes) {
-    // current pointer
+    /**
+     * current pointer
+     * @type {number}
+     */
     this.i = 0;
-    // bytes buffer
+
+    /**
+     * bytes buffer
+     * @type {Uint8Array}
+     */
     this.bytes = new Uint8Array(bytes);
-    // Output object
+
+    /**
+     * Output object
+     * @type {PNG}
+     */
     this.png = new PNG();
 
     this.dataChunks = [];
 
+    /**
+     *
+     * @type {BinaryBuffer}
+     */
     this.buffer = new BinaryBuffer();
     this.buffer.fromArrayBuffer(bytes);
 
@@ -75,6 +90,12 @@ export function PNGReader(bytes) {
      * @type {boolean}
      */
     this.crc_enabled = false;
+
+    /**
+     *
+     * @type {Uint8Array}
+     */
+    this.header = new Uint8Array(8);
 }
 
 /**
@@ -101,7 +122,7 @@ PNGReader.prototype.decodeHeader = function () {
 
     const buffer = this.buffer;
 
-    const header = new Uint8Array(8);
+    const header = this.header;
 
     buffer.readBytes(header, 0, 8)
 
@@ -110,7 +131,6 @@ PNGReader.prototype.decodeHeader = function () {
         throw new Error('invalid PNGReader file (bad signature)');
     }
 
-    this.header = header;
 
 };
 
@@ -426,6 +446,9 @@ PNGReader.prototype.decodePixels = function () {
 
 // Different interlace methods
 
+/**
+ * @param {Uint8Array} data
+ */
 PNGReader.prototype.interlaceNone = function (data) {
 
     const png = this.png;
@@ -674,34 +697,25 @@ PNGReader.prototype.unFilterPaeth = function (scanline, scanline_offset, pixels,
 
 /**
  * Parse the PNG file
- *
- * reader.parse(options, callback)
- * OR
- * reader.parse(callback)
- *
- * OPTIONS:
- *    option  | type     | default
- *    ----------------------------
- *    data      boolean    true    should it read the pixel data
  * @returns {PNG}
  */
 PNGReader.prototype.parse = function () {
 
     this.decodeHeader();
 
-    while (this.buffer.position < this.buffer.length) {
+    for (; ;) {
+
         const type = this.decodeChunk();
-        // stop after IHDR chunk, or after IEND
-        // if (type === 'IHDR' && options.data === false || type === 'IEND') break;
+
         if (type === 'IEND') {
+            // reached the end
             break;
         }
-    }
 
-    const png = this.png;
+    }
 
     this.decodePixels();
 
-    return png;
+    return this.png;
 
 };

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

@@ -129,3 +129,5 @@ export const TextureAttachmentsByMaterialType = {
         })
     ]
 };
+
+TextureAttachmentsByMaterialType.MeshPhysicalMaterial = TextureAttachmentsByMaterialType.MeshStandardMaterial;

package/src/engine/graphics/GraphicsEngine.js

@@ -573,7 +573,7 @@ export class GraphicsEngine {
         const camera = this.camera;
 
         if (scene.children.indexOf(camera) < 0) {
-            console.log("added camera");
+            // console.log("added camera");
             scene.add(camera);
         }
 

package/src/engine/graphics/ecs/light/LightSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"LightSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/ecs/light/LightSystem.js"],"names":[],"mappings":";AAiBA;IACI;;;;;OAKG;IACH,2CAsFC;IA1EG,kDAAsC;IAGtC,6DAEC;IAGD,eAAoB;IACpB,WAA2B;IAC3B,aAAwB;IAExB;;;;OAIG;IACH,mBAA0B;IAE1B;;;;OAIG;IACH,wBAA2B;IAE3B,gBAAkB;IAElB;;;;OAIG;IACH,kBAAoC;IAGpC;;;;OAIG;IACH,2BAA8B;IAC9B;;;;OAIG;IACH,iBAAoB;IAGpB;;;;OAIG;IACH,4BAAgD;IAqBpD,mCAEC;IAED;;;;OAIG;IACH,uBAHW,MAAM,SACN,MAAM,GAAC,MAAM,GAAC,OAAO,QAkB/B;IAED;;;;OAIG;IACH,4BAHW,KAAK,UACL,MAAM,QAMhB;IAED,mFASC;IAED,2EAWC;IAGD,4CAOC;IAED;;;;;OAKG;IACH,wCAmCC;IAED;;;;;;OAMG;IACH,sCAwBC;CACJ;sCA/PqC,8CAA8C;0BAC1D,qCAAqC;sBAKzC,YAAY;4CAPU,uDAAuD"}
+{"version":3,"file":"LightSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/ecs/light/LightSystem.js"],"names":[],"mappings":"AAuQA;;;;;GAKG;AACH,2DAHW,MAAM,SACN,KAAK,QAwCf;;uBA5SsB,qBAAqB;sBAGtB,YAAY;AAOlC;IACI;;;;;OAKG;IACH,2CAsFC;IA1EG,kDAAsC;IAGtC,6DAEC;IAGD,eAAoB;IACpB,WAA2B;IAC3B,aAAwB;IAExB;;;;OAIG;IACH,mBAA0B;IAE1B;;;;OAIG;IACH,wBAA2B;IAE3B,gBAAkB;IAElB;;;;OAIG;IACH,kBAAoC;IAGpC;;;;OAIG;IACH,2BAA8B;IAC9B;;;;OAIG;IACH,iBAAoB;IAGpB;;;;OAIG;IACH,4BAAgD;IAqBpD,mCAEC;IAED;;;;OAIG;IACH,uBAHW,MAAM,SACN,MAAM,GAAC,MAAM,GAAC,OAAO,QAkB/B;IAED;;;;OAIG;IACH,4BAHW,KAAK,UACL,MAAM,QAMhB;IAED,mFASC;IAED,2EAWC;IAGD,4CAOC;IAED;;;;;OAKG;IACH,wCAmCC;IAED;;;;;;OAMG;IACH,sCAwBC;CACJ;sCA/PqC,8CAA8C;0BAC1D,qCAAqC;4CAFnB,uDAAuD"}

package/src/engine/graphics/ecs/light/LightSystem.js

@@ -215,7 +215,7 @@ class LightSystem extends AbstractContextSystem {
 
                 l.castShadow = true;
 
-                updateShadowMap(this.__camera_object, l, this.__graphics);
+                three_update_shadow_camera_extents(this.__camera_object, l, this.__graphics);
 
             } else {
 
@@ -266,9 +266,8 @@ const scratch_aabb3 = new AABB3();
  * @author Alex Goldring 02.06.2016 (Komrade)
  * @param {Camera} camera
  * @param {Light} light
- * @param {GraphicsEngine} graphics
  */
-function updateShadowMap(camera, light, graphics) {
+export function three_update_shadow_camera_extents(camera, light) {
 
 
     // Fit shadow camera's ortho frustum to camera frustum

package/src/engine/graphics/ecs/light/binding/three/ThreeLightBinding.d.ts

@@ -1,3 +1,9 @@
+/**
+ *
+ * @param {LightShadow} shadow
+ * @param {number} resolution
+ */
+export function three_set_shadow_resolution(shadow: LightShadow, resolution: number): void;
 export class ThreeLightBinding extends LightBinding {
     /**
      *

package/src/engine/graphics/ecs/light/binding/three/ThreeLightBinding.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ThreeLightBinding.d.ts","sourceRoot":"","sources":["../../../../../../../../src/engine/graphics/ecs/light/binding/three/ThreeLightBinding.js"],"names":[],"mappings":"AAwEA;IAKQ;;;;OAIG;IACH,iBAAoB;IAEpB;;;;OAIG;IACH,qBAAwB;IAExB;;;;OAIG;IACH,qBAAiC;IAGrC,qBAYC;IAED,uBAcC;IAED;;;;OAIG;IACH,yBAEC;IAYD,+BAEC;IAUD,yBAuBC;IAED,2BAgBC;IAED,iCA0BC;IAGD,2BA0CC;IA8CD,mCA6BC;CAEJ;6BAzV4B,oBAAoB"}
+{"version":3,"file":"ThreeLightBinding.d.ts","sourceRoot":"","sources":["../../../../../../../../src/engine/graphics/ecs/light/binding/three/ThreeLightBinding.js"],"names":[],"mappings":"AAwEA;;;;GAIG;AACH,6EAFW,MAAM,QAgBhB;AAED;IAKQ;;;;OAIG;IACH,iBAAoB;IAEpB;;;;OAIG;IACH,qBAAwB;IAExB;;;;OAIG;IACH,qBAAiC;IAGrC,qBAYC;IAED,uBAcC;IAED;;;;OAIG;IACH,yBAEC;IAYD,+BAEC;IAUD,yBAuBC;IAED,2BAgBC;IAED,iCA0BC;IAGD,2BA0CC;IA8CD,mCAmBC;CAEJ;6BApW4B,oBAAoB"}

package/src/engine/graphics/ecs/light/binding/three/ThreeLightBinding.js

@@ -70,6 +70,27 @@ function scene_object_filter(object3D) {
     return true;
 }
 
+/**
+ *
+ * @param {LightShadow} shadow
+ * @param {number} resolution
+ */
+export function three_set_shadow_resolution(shadow, resolution) {
+    const mapSize = shadow.mapSize;
+
+    if (mapSize.width !== resolution || mapSize.height !== resolution) {
+
+        mapSize.width = mapSize.height = resolution;
+
+        //destroy old map
+        if (shadow.map !== null) {
+            shadow.map.dispose(); // important
+            shadow.map = null;
+        }
+
+    }
+}
+
 export class ThreeLightBinding extends LightBinding {
 
     constructor() {
@@ -334,17 +355,7 @@ export class ThreeLightBinding extends LightBinding {
             shadow.radius = 1;
             shadow.blurSamples = 8;
 
-            if (shadow.mapSize.width !== resolution || shadow.mapSize.height !== resolution) {
-
-                shadow.mapSize.width = shadow.mapSize.height = resolution;
-
-                //destroy old map
-                if (shadow.map !== null) {
-                    shadow.map.dispose(); // important
-                    shadow.map = null;
-                }
-
-            }
+            three_set_shadow_resolution(shadow, resolution);
 
         }
     }

package/src/engine/graphics/render/forward_plus/model/DirectionalLight.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DirectionalLight.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/render/forward_plus/model/DirectionalLight.js"],"names":[],"mappings":"AAKA;IAII;;;OAGG;IACH,UAFU,OAAO,CAEY;IAE7B;;;OAGG;IACH,WAFU,OAAO,CAEa;IAE9B;;;OAGG;IACH,gBAFU,KAAK,CAEgB;IAE/B;;;OAGG;IACH,WAFU,OAAO,CAEc;IAInC;;;OAGG;IACH,6BAFU,OAAO,CAE4B;CAN5C;8BAjC6B,oBAAoB;oBAC9B,qCAAqC;sBACnC,oCAAoC;oBACtC,qCAAqC"}
+{"version":3,"file":"DirectionalLight.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/render/forward_plus/model/DirectionalLight.js"],"names":[],"mappings":"AAKA;IAIQ;;;OAGG;IACH,UAFU,OAAO,CAEY;IAE7B;;;OAGG;IACH,WAFU,OAAO,CAEa;IAE9B;;;OAGG;IACH,gBAFU,KAAK,CAEgB;IAE/B;;;OAGG;IACH,WAFU,OAAO,CAEc;IAIvC;;;OAGG;IACH,6BAFU,OAAO,CAE4B;CAN5C;8BA9B6B,oBAAoB;oBAD9B,qCAAqC;sBAFnC,oCAAoC;oBACtC,qCAAqC"}

package/src/engine/graphics/render/forward_plus/model/DirectionalLight.js

@@ -1,36 +1,36 @@
-import { AbstractLight } from "./AbstractLight.js";
-import Vector3 from "../../../../../core/geom/Vector3.js";
 import { Color } from "../../../../../core/color/Color.js";
 import Vector1 from "../../../../../core/geom/Vector1.js";
+import Vector3 from "../../../../../core/geom/Vector3.js";
+import { AbstractLight } from "./AbstractLight.js";
 
 export class DirectionalLight extends AbstractLight {
-constructor() {
-    super();
+    constructor() {
+        super();
 
-    /**
-     *
-     * @type {Vector3}
-     */
-    this.position = new Vector3();
+        /**
+         *
+         * @type {Vector3}
+         */
+        this.position = new Vector3();
 
-    /**
-     *
-     * @type {Vector3}
-     */
-    this.direction = new Vector3();
+        /**
+         *
+         * @type {Vector3}
+         */
+        this.direction = new Vector3();
 
-    /**
-     * @readonly
-     * @type {Color}
-     */
-    this.color = new Color(1, 1, 1);
+        /**
+         * @readonly
+         * @type {Color}
+         */
+        this.color = new Color(1, 1, 1);
 
-    /**
-     *
-     * @type {Vector1}
-     */
-    this.intensity = new Vector1(1);
-}
+        /**
+         *
+         * @type {Vector1}
+         */
+        this.intensity = new Vector1(1);
+    }
 }
 
 /**

package/src/engine/graphics/sh3/fromCubeRenderTarget.d.ts

@@ -0,0 +1,9 @@
+/**
+ *
+ * @param {Uint8Array} data
+ * @param {THREE.WebGLRenderer} renderer
+ * @param {THREE.WebGLCubeRenderTarget} cubeRenderTarget
+ * @return {Float64Array}
+ */
+export function fromCubeRenderTarget(data: Uint8Array, renderer: THREE.WebGLRenderer, cubeRenderTarget: THREE.WebGLCubeRenderTarget): Float64Array;
+//# sourceMappingURL=fromCubeRenderTarget.d.ts.map

package/src/engine/graphics/sh3/fromCubeRenderTarget.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fromCubeRenderTarget.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics/sh3/fromCubeRenderTarget.js"],"names":[],"mappings":"AAIA;;;;;;GAMG;AACH,2CALW,UAAU,YACV,MAAM,aAAa,oBACnB,MAAM,qBAAqB,GAC1B,YAAY,CAuIvB"}

package/src/engine/graphics/sh3/fromCubeRenderTarget.js

@@ -0,0 +1,145 @@
+import { sh3_basis_at } from "../../../core/geom/3d/sphere/harmonics/sh3_basis_at.js";
+import { sh3_dering_optimize_positive } from "../../../core/geom/3d/sphere/harmonics/sh3_dering_optimize_positive.js";
+import { v3_length_sqr } from "../../../core/geom/vec3/v3_length_sqr.js";
+
+/**
+ *
+ * @param {Uint8Array} data
+ * @param {THREE.WebGLRenderer} renderer
+ * @param {THREE.WebGLCubeRenderTarget} cubeRenderTarget
+ * @return {Float64Array}
+ */
+export function fromCubeRenderTarget(
+    data,
+    renderer,
+    cubeRenderTarget
+) {
+
+    // The renderTarget must be set to RGBA in order to make readRenderTargetPixels works
+    let total_weight = 0;
+
+    const __shared_buffer = new ArrayBuffer((27 + 9) * 8);
+
+    const sh_basis = new Float64Array(__shared_buffer, 0, 9);
+    const coefficients = new Float64Array(__shared_buffer, 9 * 8, 27);
+
+    const image_size = cubeRenderTarget.width;
+
+    const pixel_size = 2 / image_size;
+
+    let normal_x = 0, normal_y = 0, normal_z = 0;
+
+    for (let faceIndex = 0; faceIndex < 6; faceIndex++) {
+
+        renderer.readRenderTargetPixels(cubeRenderTarget, 0, 0, image_size, image_size, data, faceIndex);
+
+        // RGBA assumed
+
+        for (let i = 0, il = data.length; i < il; i += 4) {
+
+
+            // pixel coordinate on unit cube
+
+            const pixelIndex = i / 4;
+
+            const col = -1 + (pixelIndex % image_size + 0.5) * pixel_size;
+
+            const row = 1 - (Math.floor(pixelIndex / image_size) + 0.5) * pixel_size;
+
+
+            switch (faceIndex) {
+
+                case 0:
+                    normal_x = 1;
+                    normal_y = row;
+                    normal_z = -col;
+                    break;
+
+                case 1:
+                    normal_x = -1;
+                    normal_y = row;
+                    normal_z = col;
+                    break;
+
+                case 2:
+                    normal_x = col;
+                    normal_y = 1;
+                    normal_z = -row;
+                    break;
+
+                case 3:
+                    normal_x = col;
+                    normal_y = -1;
+                    normal_z = row;
+                    break;
+
+                case 4:
+                    normal_x = col;
+                    normal_y = row;
+                    normal_z = 1;
+                    break;
+
+                case 5:
+                    normal_x = -col;
+                    normal_y = row;
+                    normal_z = -1;
+                    break;
+
+            }
+
+            // weight assigned to this pixel
+
+            const length_squared = v3_length_sqr(normal_x, normal_y, normal_z);
+
+            const length = Math.sqrt(length_squared);
+
+            const weight = 4 / (length * length_squared);
+
+            total_weight += weight;
+
+            // direction vector to this pixel
+            normal_x /= length;
+            normal_y /= length;
+            normal_z /= length;
+
+            // evaluate SH basis functions in direction dir
+            sh3_basis_at(normal_x, normal_y, normal_z, sh_basis);
+
+            // pixel color, already in linear space so no sRGB->Linear conversion necessary
+
+            // 0.003921 constant value is 1/255, a conversion value from UINT8 to normalized float
+            const weight_conv = weight * 0.00392156862745098;
+
+            const color_r = data[i] * weight_conv;
+            const color_g = data[i + 1] * weight_conv;
+            const color_b = data[i + 2] * weight_conv;
+
+            // accumulate
+            for (let j = 0; j < 9; j++) {
+
+                const j3 = j * 3;
+
+                coefficients[j3] += sh_basis[j] * color_r;
+                coefficients[j3 + 1] += sh_basis[j] * color_g;
+                coefficients[j3 + 2] += sh_basis[j] * color_b;
+
+            }
+
+        }
+
+    }
+
+    // normalize
+    const norm = (4 * Math.PI) / total_weight;
+
+    for (let j = 0; j < 27; j++) {
+
+        coefficients[j] *= norm;
+
+    }
+
+    sh3_dering_optimize_positive(coefficients, 0, coefficients, 0, 3);
+
+    return coefficients;
+
+}

package/src/engine/graphics/sh3/gi/tetrahedral_mesh_to_texture.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Assumes that the mesh is compacted
+ * @param {AttributeDataTexture} vertices
+ * @param {AttributeDataTexture} neighbours
+ * @param {TetrahedralMesh} mesh
+ */
+export function tetrahedral_mesh_to_texture(vertices: AttributeDataTexture, neighbours: AttributeDataTexture, mesh: TetrahedralMesh): void;
+//# sourceMappingURL=tetrahedral_mesh_to_texture.d.ts.map

package/src/engine/graphics/sh3/gi/tetrahedral_mesh_to_texture.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tetrahedral_mesh_to_texture.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/gi/tetrahedral_mesh_to_texture.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,2IA0CC"}

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

@@ -0,0 +1,51 @@
+import { assert } from "../../../../core/assert.js";
+
+/**
+ * Assumes that the mesh is compacted
+ * @param {AttributeDataTexture} vertices
+ * @param {AttributeDataTexture} neighbours
+ * @param {TetrahedralMesh} mesh
+ */
+export function tetrahedral_mesh_to_texture(
+    vertices,
+    neighbours,
+    mesh
+) {
+
+    assert.equal(mesh.isCompacted, true, 'mesh.isCompacted');
+
+    if (mesh.isCompacted !== true) {
+        throw new Error(`mesh is not compacted`);
+    }
+
+    if (vertices.spec.itemSize !== 4) {
+        throw new Error(`vertices texture spec must have itemSize of 4, instead was ${vertices.spec.itemSize}`);
+    }
+
+    if (neighbours.spec.itemSize !== 4) {
+        throw new Error(`neighbours texture spec must have itemSize of 4, instead was ${neighbours.spec.itemSize}`);
+    }
+
+    const tetrahedron_count = mesh.count;
+
+    vertices.resize(tetrahedron_count);
+    neighbours.resize(tetrahedron_count);
+
+    vertices.build()
+    neighbours.build();
+
+    const vertices_data = vertices.data;
+    const neighbours_data = neighbours.data;
+
+    for (let i = 0; i < tetrahedron_count; i++) {
+
+        const i4 = i * 4;
+
+        for (let j = 0; j < 4; j++) {
+            vertices_data[i4 + j] = mesh.getVertexIndex(i, j);
+
+            neighbours_data[i4 + j] = mesh.getNeighbour(i, j);
+        }
+
+    }
+}

package/src/engine/graphics/sh3/{LightProbeVolume.d.ts → lpv/LightProbeVolume.d.ts}

@@ -3,6 +3,16 @@ export class LightProbeVolume {
     __mesh: TetrahedralMesh;
     __probe_data: any[];
     __length: number;
+    clear(): void;
+    /**
+     *
+     * @return {TetrahedralMesh}
+     */
+    get mesh(): TetrahedralMesh;
+    get points(): any[];
+    get harmonics(): any[];
+    set count(arg: number);
+    get count(): number;
     /**
      *
      * @param {number} x
@@ -23,10 +33,10 @@ export class LightProbeVolume {
     build_mesh(): void;
     /**
      * Bake light probes
-     * @param {Engine} engine
      * @returns {TaskGroup}
+     * @param {EntityComponentDataset} ecd
      */
-    bake(engine: Engine): TaskGroup;
+    bake(ecd: EntityComponentDataset): TaskGroup;
     /**
      *
      * @param {EntityComponentDataset} ecd
@@ -38,15 +48,16 @@ export class LightProbeVolume {
      *
      * @param {EntityComponentDataset} ecd
      * @param {string|number} color CSS color definition
+     * @param {number} opacity
      */
-    visualize_mesh({ ecd, color }: EntityComponentDataset): void;
+    visualize_mesh({ ecd, color, opacity }: EntityComponentDataset): void;
     /**
      *
-     * @param {Engine} engine
      * @returns {TaskGroup}
+     * @param {EntityComponentDataset} ecd
      */
-    build(engine: Engine): TaskGroup;
+    build(ecd: EntityComponentDataset): TaskGroup;
 }
-import { TetrahedralMesh } from "../../../core/geom/3d/tetrahedra/TetrahedralMesh.js";
-import TaskGroup from "../../../core/process/task/TaskGroup.js";
+import { TetrahedralMesh } from "../../../../core/geom/3d/tetrahedra/TetrahedralMesh.js";
+import TaskGroup from "../../../../core/process/task/TaskGroup.js";
 //# sourceMappingURL=LightProbeVolume.d.ts.map

package/src/engine/graphics/sh3/lpv/LightProbeVolume.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LightProbeVolume.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/lpv/LightProbeVolume.js"],"names":[],"mappings":"AAiJA;IAEQ,mBAAqB;IAErB,wBAAmC;IAEnC,oBAAsB;IAEtB,iBAAiB;IAGrB,cAMC;IAED;;;OAGG;IACH,4BAEC;IAED,oBAEC;IAED,uBAEC;IAMD,uBAEC;IAND,oBAEC;IAMD;;;;;OAKG;IACH,aAJW,MAAM,KACN,MAAM,KACN,MAAM,QAchB;IAED;;;;;OAKG;IACH,mBAJW,MAAM,UACN,MAAM,EAAE,iBACR,MAAM,QAIhB;IAED;;OAEG;IACH,mBAaC;IAGD;;;;OAIG;IACH,mCAHa,SAAS,CA4CrB;IAED;;;;;OAKG;IACH,sEAWC;IAED;;;;;OAKG;IACH,sEAkBC;IAED;;;;OAIG;IACH,oCAHa,SAAS,CAMrB;CACJ;gCA1U+B,wDAAwD;sBAClE,4CAA4C"}