@woosh/meep-engine 2.107.0 → 2.108.2

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.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TextureAttachmensByMaterialType.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/asset/loaders/material/TextureAttachmensByMaterialType.js"],"names":[],"mappings":"AAmCA;;;GAGG;AACH,mDA2FE"}
+{"version":3,"file":"TextureAttachmensByMaterialType.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/asset/loaders/material/TextureAttachmensByMaterialType.js"],"names":[],"mappings":"AAmCA;;;GAGG;AACH,mDA8FE"}

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

@@ -43,6 +43,9 @@ export const TextureAttachmentsByMaterialType = {
         taDisplacement,
         taAlphaMap
     ],
+    MeshBasicMaterial: [
+        taDiffuse
+    ],
     MeshStandardMaterial: [
         taDiffuse,
         taAlphaMap,
@@ -129,3 +132,5 @@ export const TextureAttachmentsByMaterialType = {
         })
     ]
 };
+
+TextureAttachmentsByMaterialType.MeshPhysicalMaterial = TextureAttachmentsByMaterialType.MeshStandardMaterial;

package/src/engine/ecs/terrain/overlay/TerrainOverlay.js

@@ -1,7 +1,7 @@
 import { ClampToEdgeWrapping, DataTexture, NearestFilter } from "three";
 import { assert } from "../../../../core/assert.js";
-import { float2uint8 } from "../../../../core/binary/float2uint8.js";
-import { uint82float } from "../../../../core/binary/uint82float.js";
+import { float_to_uint8 } from "../../../../core/binary/float_to_uint8.js";
+import { uint8_to_float } from "../../../../core/binary/uint8_to_float.js";
 import { array_copy } from "../../../../core/collection/array/array_copy.js";
 import { isTypedArray } from "../../../../core/collection/array/typed/isTypedArray.js";
 import Vector1 from "../../../../core/geom/Vector1.js";
@@ -203,7 +203,7 @@ export class TerrainOverlay {
         for (let i = 0; i < 4; i++) {
             const v = this.sampler.readChannel(x, y, i);
 
-            result[i] = uint82float(v);
+            result[i] = uint8_to_float(v);
         }
     }
 
@@ -250,7 +250,7 @@ export class TerrainOverlay {
     paintPoint(x, y, vec4) {
         for (let i = 0; i < 4; i++) {
 
-            this.sampler.writeChannel(x, y, i, float2uint8(vec4[i]));
+            this.sampler.writeChannel(x, y, i, float_to_uint8(vec4[i]));
 
         }
 

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/camera/topdown/TopDownCameraController.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TopDownCameraController.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/ecs/camera/topdown/TopDownCameraController.js"],"names":[],"mappings":"AAaA;;;;;;GAMG;AACH,iDALW,MAAM,kBACN,MAAM,SACN,uBAAuB,UACvB,uBAAuB,QAejC;;AAiED;IAgJI,iDAMC;IArJD,0BAeC;IAdG,gBAA2B;IAE3B,cAAc;IACd,YAAY;IACZ,aAAa;IAEb,iBAAiB;IACjB,oBAAoB;IACpB,oBAAsB;IAQ1B;;;;;OAKG;IACH,yBAJW,OAAO,UACP,OAAO,OACP,OAAO,QAmBjB;IAED;;;;OAIG;IACH,cAHW,uBAAuB,GACrB,OAAO,CAWnB;IAED;;;OAGG;IACH,YAFW,uBAAuB,QAYjC;IAED;;;OAGG;IACH,SAFa,uBAAuB,CAQnC;IAED;;;;;OAKG;IACH,QAJW,uBAAuB,KACvB,uBAAuB,KACvB,MAAM,QAahB;IAED;;;;;;;;MAYC;IAED;;;;;;;;aAsBC;CASJ;;;;;;oBArPmB,qCAAqC;AAsEzD;;;;;;;;;GASG;AACH,gEANW,OAAO,kBACP,MAAM,OACN,MAAM,UACN,OAAO,eACP,OAAO,QAajB"}
+{"version":3,"file":"TopDownCameraController.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/ecs/camera/topdown/TopDownCameraController.js"],"names":[],"mappings":"AAcA;;;;;;GAMG;AACH,iDALW,MAAM,kBACN,MAAM,SACN,uBAAuB,UACvB,uBAAuB,QAejC;;AAiED;IAmJI,iDAMC;IAxJD,0BAeC;IAdG,gBAA2B;IAE3B,cAAc;IACd,YAAY;IACZ,aAAa;IAEb,iBAAiB;IACjB,oBAAoB;IACpB,oBAAsB;IAQ1B;;;;;OAKG;IACH,yBAJW,OAAO,UACP,OAAO,OACP,OAAO,QAsBjB;IAED;;;;OAIG;IACH,cAHW,uBAAuB,GACrB,OAAO,CAWnB;IAED;;;OAGG;IACH,YAFW,uBAAuB,QAYjC;IAED;;;OAGG;IACH,SAFa,uBAAuB,CAQnC;IAED;;;;;OAKG;IACH,QAJW,uBAAuB,KACvB,uBAAuB,KACvB,MAAM,QAahB;IAED;;;;;;;;MAYC;IAED;;;;;;;;aAsBC;CASJ;;;;;;oBAzPmB,qCAAqC;AAuEzD;;;;;;;;;GASG;AACH,gEANW,OAAO,kBACP,MAAM,OACN,MAAM,UACN,OAAO,eACP,OAAO,QAajB"}

package/src/engine/graphics/ecs/camera/topdown/TopDownCameraController.js

@@ -4,6 +4,7 @@ import { eulerAnglesFromMatrix } from "../../../../../core/geom/3d/eulerAnglesFr
 import { normalize_angle_rad } from "../../../../../core/geom/normalize_angle_rad.js";
 import Vector3 from '../../../../../core/geom/Vector3.js';
 import { lerp } from "../../../../../core/math/lerp.js";
+import { max2 } from "../../../../../core/math/max2.js";
 
 const m4 = new Matrix4();
 const angles = [];
@@ -136,6 +137,9 @@ class TopDownCameraController {
 
         this.distance = eye.distanceTo(target);
 
+        // ensure we can maintain this distance
+        this.distanceMax = max2(this.distance, this.distanceMax);
+
         this.target.copy(target);
     }
 

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/ecs/sprite/SpriteSystemPE.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SpriteSystemPE.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/ecs/sprite/SpriteSystemPE.js"],"names":[],"mappings":"AA6HA;IACI,cAKC;IADG,mDAAuC;CAE9C;sCA/HqC,8CAA8C;0BAF1D,qCAAqC;uBAIxC,aAAa"}
+{"version":3,"file":"SpriteSystemPE.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/ecs/sprite/SpriteSystemPE.js"],"names":[],"mappings":"AA6HA;IACI,cAKC;IADG,mDAAuC;CAE9C;sCAjIqC,8CAA8C;0BAE1D,qCAAqC;uBAQxC,aAAa"}

package/src/engine/graphics/ecs/sprite/SpriteSystemPE.js

@@ -1,17 +1,17 @@
-import { ParticleEmitter } from "../../particles/particular/engine/emitter/ParticleEmitter.js";
-import { ParticleLayer } from "../../particles/particular/engine/emitter/ParticleLayer.js";
-import Entity from "../../../ecs/Entity.js";
-import { Transform } from "../../../ecs/transform/Transform.js";
+import { float_to_uint8 } from "../../../../core/binary/float_to_uint8.js";
 import { SerializationMetadata } from "../../../ecs/components/SerializationMetadata.js";
+import Entity from "../../../ecs/Entity.js";
 import { AbstractContextSystem } from "../../../ecs/system/AbstractContextSystem.js";
 import { SystemEntityContext } from "../../../ecs/system/SystemEntityContext.js";
-import { Sprite } from "./Sprite.js";
+import { Transform } from "../../../ecs/transform/Transform.js";
 import {
     PARTICLE_ATTRIBUTE_COLOR,
     PARTICLE_ATTRIBUTE_POSITION
 } from "../../particles/particular/engine/emitter/PARTICLE_ATTRIBUTES.js";
+import { ParticleEmitter } from "../../particles/particular/engine/emitter/ParticleEmitter.js";
 import { ParticleEmitterFlag } from "../../particles/particular/engine/emitter/ParticleEmitterFlag.js";
-import { float2uint8 } from "../../../../core/binary/float2uint8.js";
+import { ParticleLayer } from "../../particles/particular/engine/emitter/ParticleLayer.js";
+import { Sprite } from "./Sprite.js";
 
 class Context extends SystemEntityContext {
     constructor() {
@@ -92,7 +92,7 @@ class Context extends SystemEntityContext {
 
         emitter.particles?.writeAttributeVector4(
             0, PARTICLE_ATTRIBUTE_COLOR,
-            float2uint8(sprite.color.r), float2uint8(sprite.color.g), float2uint8(sprite.color.b), float2uint8(sprite.opacity.getValue())
+            float_to_uint8(sprite.color.r), float_to_uint8(sprite.color.g), float_to_uint8(sprite.color.b), float_to_uint8(sprite.opacity.getValue())
         );
 
 

package/src/engine/graphics/impostors/octahedral/bake/prepare_bake_material.js

@@ -1,4 +1,4 @@
-import { float2uint8 } from "../../../../../core/binary/float2uint8.js";
+import { float_to_uint8 } from "../../../../../core/binary/float_to_uint8.js";
 import { clamp01 } from "../../../../../core/math/clamp01.js";
 import { makeOnePixelTexture } from "../../../texture/makeOnePixelTexture.js";
 
@@ -38,12 +38,12 @@ export function prepare_bake_material({
 
 
         if (texture_metalness === null) {
-            const m = float2uint8(clamp01(source_material.metalness));
+            const m = float_to_uint8(clamp01(source_material.metalness));
             texture_metalness = makeOnePixelTexture([m, m, m, 255], cleanup_signal);
         }
 
         if (texture_roughness === null) {
-            const r = float2uint8(clamp01(source_material.roughness));
+            const r = float_to_uint8(clamp01(source_material.roughness));
 
             texture_roughness = makeOnePixelTexture([r, r, r, 255], cleanup_signal);
         }

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/SH3VisualisationMaterial.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SH3VisualisationMaterial.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics/sh3/SH3VisualisationMaterial.js"],"names":[],"mappings":"AAuDA;IAEI,cAoBC;CAEJ;+BA/EuC,OAAO"}
+{"version":3,"file":"SH3VisualisationMaterial.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics/sh3/SH3VisualisationMaterial.js"],"names":[],"mappings":"AA0DA;IAEI,cAoBC;CAEJ;+BAlFuC,OAAO"}

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

@@ -24,17 +24,20 @@ vec3 inverseTransformDirection( in vec3 normal, in mat4 matrix ) {
 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[ 1 ] * 2.0 * 0.511664 * y;
 	result += shCoefficients[ 2 ] * 2.0 * 0.511664 * z;
-	result += shCoefficients[ 3 ] * 2.0 * 0.511664 * x;
+	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[ 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[ 7 ] * 2.0 * 0.429043 * x * z;
 	result += shCoefficients[ 8 ] * 0.429043 * ( x * x - y * y );
 	
 	return result;
@@ -46,9 +49,9 @@ varying vec3 vNormal;
 
 void main() {
 	vec3 normal = normalize( vNormal );
-	vec3 worldNormal = inverseTransformDirection( normal, viewMatrix );
+	vec3 worldNormal = normalize(inverseTransformDirection( normal, viewMatrix ));
 	vec3 irradiance = shGetIrradianceAt( worldNormal, sh );
-	vec3 outgoingLight = RECIPROCAL_PI * irradiance * intensity;
+	vec3 outgoingLight = 1.0  * irradiance * intensity;
 	gl_FragColor = linearToOutputTexel( vec4( outgoingLight, 1.0 ) );
 }
 `;

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