@woosh/meep-engine 2.118.9 → 2.118.12

package/src/engine/graphics/geometry/buffered/build_height_field_geometry.js

@@ -0,0 +1,118 @@
+import { UintArrayForCount } from "../../../../core/collection/array/typed/uint_array_for_count.js";
+import { geometry_compute_vertex_normals_indexed } from "./geometry_compute_vertex_normals_indexed.js";
+
+/**
+ *
+ * @param {Sampler2D} samplerHeight
+ * @param {Vector2} position
+ * @param {Vector2} size
+ * @param {Vector2} scale
+ * @param {Vector2} totalSize
+ * @param {number} resolution
+ * @returns {{indices, vertices: Float32Array, normals: Float32Array, uvs: Float32Array}}
+ */
+export function build_height_field_geometry(samplerHeight, position, size, scale, totalSize, resolution) {
+
+    const width = size.x;
+    const height = size.y;
+
+
+    const gridX1 = width * resolution;
+    const gridY1 = height * resolution;
+
+    const gridX2 = gridX1 - 1;
+    const gridY2 = gridY1 - 1;
+
+    let offset = 0, offset2 = 0;
+
+    const vertexCount = gridX1 * gridY1;
+
+
+    const vertices = new Float32Array(vertexCount * 3);
+
+    const normals = new Float32Array(vertexCount * 3);
+
+    const uvs = new Float32Array(vertexCount * 2);
+
+    let y, x;
+
+    const vMultiplier = (size.y / totalSize.y) / gridY2;
+    const uMultiplier = (size.x / totalSize.x) / gridX2;
+
+    const vConst = position.y / totalSize.y;
+    const uConst = position.x / totalSize.x;
+
+    const totalScaledSizeX = totalSize.x * scale.x;
+    const totalScaledSizeY = totalSize.y * scale.y;
+
+    //fill vertices
+    let px, py, pz;
+    for (y = 0; y < gridY1; y++) {
+
+        const v = y * vMultiplier + vConst;
+
+        pz = v * totalScaledSizeY;
+
+        for (x = 0; x < gridX1; x++) {
+
+            const u = x * uMultiplier + uConst;
+
+            //get height sample
+            const val = samplerHeight.sampleChannelBicubicUV(u, v, 0);
+
+            px = u * totalScaledSizeX;
+            py = val;
+
+            vertices[offset] = px;
+            vertices[offset + 1] = py;
+            vertices[offset + 2] = pz;
+
+            uvs[offset2] = u;
+            uvs[offset2 + 1] = v;
+
+            offset += 3;
+            offset2 += 2;
+        }
+    }
+
+    offset = 0;
+
+    const IndexArray = UintArrayForCount(vertices.length / 3);
+
+    /**
+     * @type {Uint8Array|Uint16Array|Uint32Array}
+     */
+    const indices = new IndexArray(gridX2 * gridY2 * 6);
+
+    //add faces
+    //TODO TraingleStip mode is more efficient in terms of memory usage and probably GPU-time
+    for (y = 0; y < gridY2; y++) {
+
+        for (x = 0; x < gridX2; x++) {
+            const a = x + gridX1 * y;
+            const b = x + gridX1 * (y + 1);
+            const c = (x + 1) + gridX1 * (y + 1);
+            const d = (x + 1) + gridX1 * y;
+
+            indices[offset] = a;
+            indices[offset + 1] = b;
+            indices[offset + 2] = d;
+
+            indices[offset + 3] = b;
+            indices[offset + 4] = c;
+            indices[offset + 5] = d;
+
+            offset += 6;
+        }
+    }
+
+    geometry_compute_vertex_normals_indexed(vertices, normals, indices);
+
+    //CleanupGeometry(geometry);
+    return {
+        indices: indices,
+        vertices: vertices,
+        normals: normals,
+        uvs: uvs
+    };
+}

package/src/engine/graphics/geometry/buffered/geometry_compute_vertex_normals_indexed.d.ts

@@ -3,7 +3,7 @@
  * Prior to calling this function, normals need to be set to 0
  * @param {Array.<number>|Float32Array} positions
  * @param {Array.<number>|Float32Array} normals
- * @param {Array.<number>|Uint32Array} indices
+ * @param {Array.<number>|Uint32Array|Uint16Array|Uint8Array} indices
  */
-export function geometry_compute_vertex_normals_indexed(positions: Array<number> | Float32Array, normals: Array<number> | Float32Array, indices: Array<number> | Uint32Array): void;
+export function geometry_compute_vertex_normals_indexed(positions: Array<number> | Float32Array, normals: Array<number> | Float32Array, indices: Array<number> | Uint32Array | Uint16Array | Uint8Array): void;
 //# sourceMappingURL=geometry_compute_vertex_normals_indexed.d.ts.map

package/src/engine/graphics/geometry/buffered/geometry_compute_vertex_normals_indexed.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"geometry_compute_vertex_normals_indexed.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/geometry/buffered/geometry_compute_vertex_normals_indexed.js"],"names":[],"mappings":"AAMA;;;;;;GAMG;AACH,mEAJW,MAAO,MAAM,CAAC,GAAC,YAAY,WAC3B,MAAO,MAAM,CAAC,GAAC,YAAY,WAC3B,MAAO,MAAM,CAAC,GAAC,WAAW,QAgCpC"}
+{"version":3,"file":"geometry_compute_vertex_normals_indexed.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/geometry/buffered/geometry_compute_vertex_normals_indexed.js"],"names":[],"mappings":"AAMA;;;;;;GAMG;AACH,mEAJW,MAAO,MAAM,CAAC,GAAC,YAAY,WAC3B,MAAO,MAAM,CAAC,GAAC,YAAY,WAC3B,MAAO,MAAM,CAAC,GAAC,WAAW,GAAC,WAAW,GAAC,UAAU,QAgC3D"}

package/src/engine/graphics/geometry/buffered/geometry_compute_vertex_normals_indexed.js

@@ -9,7 +9,7 @@ const scratch_v3 = new Float64Array(3);
  * Prior to calling this function, normals need to be set to 0
  * @param {Array.<number>|Float32Array} positions
  * @param {Array.<number>|Float32Array} normals
- * @param {Array.<number>|Uint32Array} indices
+ * @param {Array.<number>|Uint32Array|Uint16Array|Uint8Array} indices
  */
 export function geometry_compute_vertex_normals_indexed(
     positions,

package/src/engine/graphics/geometry/optimization/VertexCacheOptimizer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"VertexCacheOptimizer.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/geometry/optimization/VertexCacheOptimizer.js"],"names":[],"mappings":"AAgaA;;;;;;GAMG;AACH,yDALW,MAAM,EAAE,GAAC,WAAW,WACpB,MAAM,EAAE,GAAC,WAAW,eACpB,MAAM,gBACN,MAAM,QAIhB;AAED;;;;;;GAMG;AACH,8DALW,MAAM,EAAE,GAAC,WAAW,WACpB,MAAM,EAAE,GAAC,WAAW,eACpB,MAAM,gBACN,MAAM,QAIhB"}
+{"version":3,"file":"VertexCacheOptimizer.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/geometry/optimization/VertexCacheOptimizer.js"],"names":[],"mappings":"AA8aA;;;;;;GAMG;AACH,yDALW,MAAM,EAAE,GAAC,WAAW,WACpB,MAAM,EAAE,GAAC,WAAW,eACpB,MAAM,gBACN,MAAM,QAIhB;AAED;;;;;;GAMG;AACH,8DALW,MAAM,EAAE,GAAC,WAAW,WACpB,MAAM,EAAE,GAAC,WAAW,eACpB,MAAM,gBACN,MAAM,QAIhB"}

package/src/engine/graphics/geometry/optimization/VertexCacheOptimizer.js

@@ -8,10 +8,9 @@ const kCacheSizeMax = 16;
 const kValenceMax = 8;
 
 class VertexScoreTable {
-    constructor() {
-        this.cache = new Float32Array(1 + kCacheSizeMax);
-        this.live = new Float32Array(1 + kValenceMax);
-    }
+
+    cache = new Float32Array(1 + kCacheSizeMax);
+    live = new Float32Array(1 + kValenceMax);
 
     /**
      *
@@ -42,11 +41,10 @@ const kVertexScoreTableStrip = VertexScoreTable.from(
 );
 
 class TriangleAdjacency {
-    constructor() {
-        this.counts = new Uint32Array(1);
-        this.offsets = new Uint32Array(1);
-        this.data = new Uint32Array(1);
-    }
+
+    counts = new Uint32Array(1);
+    offsets = new Uint32Array(1);
+    data = new Uint32Array(1);
 
     /**
      *
@@ -76,42 +74,48 @@ function buildTriangleAdjacency(adjacency, indices, index_count, vertex_count) {
     // fill triangle counts
     // adjacency.counts.fill(0);// unnecessary, new arrays are already zero-filled
 
+    const adjacency_counts = adjacency.counts;
+
     for (let i = 0; i < index_count; ++i) {
         const index = indices[i];
 
         assert.lessThan(index, vertex_count);
 
-        adjacency.counts[index]++;
+        adjacency_counts[index]++;
     }
 
     // fill offset table
     let offset = 0;
 
+    const adjacency_offsets = adjacency.offsets;
+
     for (let i = 0; i < vertex_count; ++i) {
-        adjacency.offsets[i] = offset;
-        offset += adjacency.counts[i];
+        adjacency_offsets[i] = offset;
+        offset += adjacency_counts[i];
     }
 
     assert.equal(offset, index_count);
 
+    const adjacency_data = adjacency.data;
+
     // fill triangle data
     for (let i = 0; i < face_count; ++i) {
         const i3 = i * 3;
 
-        const a = indices[i3 + 0];
+        const a = indices[i3];
         const b = indices[i3 + 1];
         const c = indices[i3 + 2];
 
-        adjacency.data[adjacency.offsets[a]++] = i;
-        adjacency.data[adjacency.offsets[b]++] = i;
-        adjacency.data[adjacency.offsets[c]++] = i;
+        adjacency_data[adjacency_offsets[a]++] = i;
+        adjacency_data[adjacency_offsets[b]++] = i;
+        adjacency_data[adjacency_offsets[c]++] = i;
     }
 
     // fix offsets that have been disturbed by the previous pass
     for (let i = 0; i < vertex_count; ++i) {
         // assert(adjacency.offsets[i] >= adjacency.counts[i]);
 
-        adjacency.offsets[i] -= adjacency.counts[i];
+        adjacency_offsets[i] -= adjacency_counts[i];
     }
 }
 
@@ -236,8 +240,9 @@ function meshopt_optimizeVertexCacheTable(destination, indices, index_count, ver
     assert.equal(index_count % 3, 0);
 
     // guard for empty meshes
-    if (index_count === 0 || vertex_count === 0)
+    if (index_count === 0 || vertex_count === 0) {
         return;
+    }
 
     // support in-place optimization
     if (destination === indices) {
@@ -273,9 +278,10 @@ function meshopt_optimizeVertexCacheTable(destination, indices, index_count, ver
     const triangle_scores = new Float32Array(face_count);
 
     for (let i = 0; i < face_count; ++i) {
+
         const i3 = i * 3;
 
-        const a = indices[i3 + 0];
+        const a = indices[i3];
         const b = indices[i3 + 1];
         const c = indices[i3 + 2];
 
@@ -296,16 +302,17 @@ function meshopt_optimizeVertexCacheTable(destination, indices, index_count, ver
 
         const in_tri_3 = current_triangle * 3;
 
-        const a = indices[in_tri_3 + 0];
+        const a = indices[in_tri_3];
         const b = indices[in_tri_3 + 1];
         const c = indices[in_tri_3 + 2];
 
         // output indices
         const out_tri_3 = output_triangle * 3;
 
-        destination[out_tri_3 + 0] = a;
+        destination[out_tri_3] = a;
         destination[out_tri_3 + 1] = b;
         destination[out_tri_3 + 2] = c;
+
         output_triangle++;
 
         // update emitted flags
@@ -327,8 +334,11 @@ function meshopt_optimizeVertexCacheTable(destination, indices, index_count, ver
             }
         }
 
+        // swap caches
         const cache_temp = cache;
-        cache = cache_new, cache_new = cache_temp;
+        cache = cache_new;
+        cache_new = cache_temp;
+
         cache_count = cache_write > cache_size ? cache_size : cache_write;
 
         // update live triangle counts
@@ -346,13 +356,17 @@ function meshopt_optimizeVertexCacheTable(destination, indices, index_count, ver
             const neighbours_size = adjacency.counts[index];
 
             for (let i = 0; i < neighbours_size; ++i) {
+
                 const tri = neighbours[i + neighbour_offset];
 
                 if (tri === current_triangle) {
+
                     neighbours[neighbour_offset + i] = neighbours[neighbour_offset + neighbours_size - 1];
                     adjacency.counts[index]--;
                     break;
+
                 }
+
             }
         }
 

package/src/engine/graphics/material/optimization/MaterialOptimizationContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MaterialOptimizationContext.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/material/optimization/MaterialOptimizationContext.js"],"names":[],"mappings":"AAkXA;IAEQ;;;OAGG;IACH,UAFU,MAAM,OAAO,EAAE,CAEP;IAElB;;;OAGG;IACH,QAFU,MAAM,IAAI,EAAE,CAEN;IAGhB;;;OAGG;IACH,SAFU,IAAI,MAAM,EAAC,SAAS,CAAC,CAEP;IAExB;;;OAGG;IACH,YAFU,SAAS,CAEC;IAGxB;;;OAGG;IACH,sBAFW,kBAAkB,EAAE,QAkE9B;IAED;;;OAGG;IACH,gCAFW,kBAAkB,EAAE,QAmE9B;IAED;;;OAGG;IACH,kCAFW,kBAAkB,QA4E5B;IAED;;;OAGG;IACH,cAFW,MAAM,IAAI,QAUpB;IAED;;;OAGG;IACH,iCAMC;IAED;;OAEG;IACH,eAwIC;IAED;;;OAGG;IACH,6BAFY,IAAI,MAAM,EAAE,iBAAiB,CAAC,CAyBzC;IAED;;;;OAIG;IACH,0CAHW,MAAM,cAAc,OACpB,kBAAkB,QA+C5B;CACJ;;0BAIS,MAAM;;0BAx0BU,oCAAoC;mCAK3B,yBAAyB;4BA3BrD,OAAO"}
+{"version":3,"file":"MaterialOptimizationContext.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/material/optimization/MaterialOptimizationContext.js"],"names":[],"mappings":"AAkXA;IAEQ;;;OAGG;IACH,UAFU,MAAM,OAAO,EAAE,CAEP;IAElB;;;OAGG;IACH,QAFU,MAAM,IAAI,EAAE,CAEN;IAGhB;;;OAGG;IACH,SAFU,IAAI,MAAM,EAAC,SAAS,CAAC,CAEP;IAExB;;;OAGG;IACH,YAFU,SAAS,CAEC;IAGxB;;;OAGG;IACH,sBAFW,kBAAkB,EAAE,QAkE9B;IAED;;;OAGG;IACH,gCAFW,kBAAkB,EAAE,QAmE9B;IAED;;;OAGG;IACH,kCAFW,kBAAkB,QA4E5B;IAED;;;OAGG;IACH,cAFW,MAAM,IAAI,QAUpB;IAED;;;OAGG;IACH,iCAMC;IAED;;OAEG;IACH,eAwIC;IAED;;;OAGG;IACH,6BAFY,IAAI,MAAM,EAAE,iBAAiB,CAAC,CAyBzC;IAED;;;;OAIG;IACH,0CAHW,MAAM,cAAc,OACpB,kBAAkB,QA+C5B;CACJ;;0BAIS,MAAM;;0BAz0BU,oCAAoC;mCAM3B,yBAAyB;4BA3BrD,OAAO"}

package/src/engine/graphics/material/optimization/MaterialOptimizationContext.js

@@ -27,10 +27,10 @@ import { channelCountToThreeTextureFormat } from "../../texture/channelCountToTh
 import { computeThreeTextureTypeFromDataType } from "../../texture/computeThreeTextureTypeFromDataType.js";
 import { normalized_internal_format } from "../../texture/normalized_internal_format.js";
 import { convertTexture2Sampler2D } from "../../texture/sampler/convertTexture2Sampler2D.js";
-import { copy_Sampler2D_channel_data } from "../../texture/sampler/copy_Sampler2D_channel_data.js";
 import { Sampler2D } from "../../texture/sampler/Sampler2D.js";
 import { sampler2d_copy_channel_data } from "../../texture/sampler/sampler2d_copy_channel_data.js";
 import { sampler2d_sub_copy_same_item_size } from "../../texture/sampler/sampler2d_sub_copy_same_item_size.js";
+import { sampler2d_transfer_data } from "../../texture/sampler/sampler2d_transfer_data.js";
 import { BUFFER_GEOMETRY_UVS } from "./BUFFER_GEOMETRY_UVS.js";
 import { is_compliant_mesh } from "./is_compliant_mesh.js";
 import { MaterialDescriptor } from "./MaterialDescriptor.js";
@@ -198,7 +198,7 @@ function extract_texture_data(destination, source, texture_name) {
             sampler2d_copy_channel_data(source, 2, destination, 0);
             break;
         default:
-            copy_Sampler2D_channel_data(source, destination);
+            sampler2d_transfer_data(source, destination);
     }
 }
 

package/src/engine/graphics/render/forward_plus/materials/FPlusDebugMaterial.js

@@ -1,7 +1,7 @@
 import { GLSL3, ShaderMaterial, Vector2, Vector3 } from "three";
-import { Sampler2D } from "../../../texture/sampler/Sampler2D.js";
-import sampler2D2Texture from "../../../texture/sampler/Sampler2D2Texture.js";
 import { ParameterLookupTable } from "../../../particles/particular/engine/parameter/ParameterLookupTable.js";
+import { Sampler2D } from "../../../texture/sampler/Sampler2D.js";
+import sampler2d_to_texture from "../../../texture/sampler/sampler2d_to_texture.js";
 
 
 const v_shader = `
@@ -155,7 +155,7 @@ export class FPlusDebugMaterial extends ShaderMaterial {
             heatmap_sampler.set(i, 0, r);
         }
 
-        const heatmap_texture = sampler2D2Texture(heatmap_sampler);
+        const heatmap_texture = sampler2d_to_texture(heatmap_sampler);
 
         this.uniforms.t_heatmap_lookup.value = heatmap_texture;
     }

package/src/engine/graphics/texture/sampler/Sampler2D.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Sampler2D.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/texture/sampler/Sampler2D.js"],"names":[],"mappings":"AAmBA;;;;GAIG;AACH;IAk8BI;;;;;;OAMG;IACH,6DAFY,SAAS,CAKpB;IAED;;;;;;OAMG;IACH,sDAFY,SAAS,CAKpB;IAED;;;;;;OAMG;IACH,uDAFY,SAAS,CAKpB;IAED;;;;;;OAMG;IACH,uDAFY,SAAS,CAKpB;IAED;;;;;;OAMG;IACH,qDAFY,SAAS,CAKpB;IAED;;;;;;OAMG;IACH,sDAFY,SAAS,CAKpB;IAED;;;;;;OAMG;IACH,sDAFY,SAAS,CAKpB;IAED;;;;;;OAMG;IACH,wDAFY,SAAS,CAKpB;IAED;;;;;;OAMG;IACH,wDAFY,SAAS,CAKpB;IA3iCD;;;;;;;OAOG;IACH,mBANW,UAAU,MAAM,CAAC,GAAC,MAAM,EAAE,GAAC,iBAAiB,GAAC,UAAU,GAAC,WAAW,GAAC,WAAW,GAAC,SAAS,GAAC,UAAU,GAAC,UAAU,GAAC,YAAY,GAAC,YAAY,aACzI,MAAM,UACN,MAAM,WACN,MAAM,EAmDhB;IA7BG;;;OAGG;IACH,cAAkB;IAElB;;;OAGG;IACH,eAAoB;IAEpB;;;OAGG;IACH,iBAAwB;IAExB;;;OAGG;IACH,MAFU,MAAM,EAAE,GAAC,iBAAiB,GAAC,UAAU,GAAC,WAAW,GAAC,WAAW,GAAC,SAAS,GAAC,UAAU,GAAC,UAAU,GAAC,YAAY,GAAC,YAAY,CAEjH;IAEhB;;;OAGG;IACH,SAFU,MAAM,CAEA;IAGpB;;;;;;;OAOG;IACH,OALW,MAAM,KACN,MAAM,UACN,qCAA+B,GAC7B,MAAM,CAIlB;IAED;;;;;OAKG;IACH,sBAJW,MAAM,KACN,MAAM,UACN,MAAM,EAAE,QAQlB;IAED;;;;;;OAMG;IACH,6BALW,MAAM,KACN,MAAM,WACN,MAAM,GACJ,MAAM,CAOlB;IAED;;;;;;;OAOG;IACH,2BALW,MAAM,KACN,MAAM,WACN,MAAM,GACJ,MAAM,CA2DlB;IAED;;;;;OAKG;IACH,mBAJW,MAAM,KACN,MAAM,UACN,MAAM,EAAE,QAQlB;IAED;;;;;;OAMG;IACH,iBALW,MAAM,KACN,MAAM,UACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,QAUhB;IAED;;;;;;OAMG;IACH,0BALW,MAAM,KACN,MAAM,WACN,MAAM,GACJ,MAAM,CAOlB;IAED;;;;;;;OAOG;IACH,wBALW,MAAM,KACN,MAAM,WACN,MAAM,GACJ,MAAM,CAgFlB;IAED;;;;;;OAMG;IACH,oBALW,MAAM,KACN,MAAM,UACN,MAAM,EAAE,GAAC,YAAY,kBACrB,MAAM,QAUhB;IAED;;;;;;OAMG;IACH,kBALW,MAAM,KACN,MAAM,UACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,kBAClC,MAAM,QAWhB;IAED;;;;;;OAMG;IACH,2BALW,MAAM,KACN,MAAM,WACN,MAAM,GACL,MAAM,CAOjB;IAED;;;;;;OAMG;IACH,yBALW,MAAM,KACN,MAAM,WACN,MAAM,GACJ,MAAM,CAiFlB;IAED;;;;;OAKG;IACH,mBAJW,MAAM,KACN,MAAM,UACN,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,QAUpC;IAED;;;;;;OAMG;IACH,eALW,MAAM,KACN,MAAM,WACN,MAAM,GACJ,MAAM,CAalB;IAED;;;;;OAKG;IACH,QAJW,MAAM,KACN,MAAM,UACN,MAAM,EAAE,QAalB;IAED;;;;;OAKG;IACH,SAJW,MAAM,KACN,MAAM,QACN,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,QAapC;IAED;;;;;;OAMG;IACH,UALW,MAAM,KACN,MAAM,WACN,2BAAuB,OAajC;IAED;;;;;OAKG;IACH,eAJW,MAAM,KACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;;OAIG;IACH,mBAHW,MAAM,yBAUhB;IAED;;;;;;;;;OASG;IACH,aARW,SAAS,qHAoDnB;IAGD;;;;;;;OAOG;IACH,oEA8BC;IAED;;;;OAIG;IACH,2BAHW,MAAM,SACN,MAAM,QAYhB;IAED;;;;;;;OAOG;IACH,iEAFW,aAAc,QAqCxB;IAED;;;;;;OAMG;IACH,gBALW,MAAM,KACN,MAAM,WACN,MAAM,SACN,MAAM,QAqBhB;IAED;;;;;OAKG;IACH,OAJW,MAAM,KACN,MAAM,SACN,MAAM,EAAE,GAAC,YAAY,QAe/B;IAED;;;;;;;OAOG;IACH,wBALW,MAAM,WACN,MAAM,UACN,MAAM,sBAyBhB;IAED;;;;;OAKG;IACH,UAJW,MAAM,KACN,MAAM,iBACN,OAAO,QAyDjB;IAED;;;OAGG;IACH,mBAFY,MAAM,CAYjB;IAED;;;;OAIG;IACH,cAHW,SAAS,GACR,OAAO,CAYlB;IAED;;;OAGG;IACH,QAFY,MAAM,CAYjB;IAGD;;OAEG;IACH,SAFa,SAAS,CAerB;IAED;;;;;;MAUC;IAED;;;;;;aAwBC;IAgHL;;;OAGG;IACH,sBAFU,OAAO,CAEc;CAN9B;;kBAUS,MAAM"}
+{"version":3,"file":"Sampler2D.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/texture/sampler/Sampler2D.js"],"names":[],"mappings":"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"}

package/src/engine/graphics/texture/sampler/Sampler2D.js

@@ -3,11 +3,11 @@ import { Base64 } from "../../../../core/binary/base64/Base64.js";
 import {
     compute_typed_array_constructor_from_data_type
 } from "../../../../core/binary/type/DataType2TypedArrayConstructorMapping.js";
-import { computeStridedIntegerArrayHash } from "../../../../core/collection/array/computeStridedIntegerArrayHash.js";
 import {
     compute_binary_data_type_from_typed_array
 } from "../../../../core/collection/array/typed/compute_binary_data_type_from_typed_array.js";
 import { is_typed_array_equals } from "../../../../core/collection/array/typed/is_typed_array_equals.js";
+import { sparse_typed_array_hash } from "../../../../core/collection/array/typed/sparse_typed_array_hash.js";
 import {
     typedArrayConstructorByInstance
 } from "../../../../core/collection/array/typed/typedArrayConstructorByInstance.js";
@@ -52,19 +52,19 @@ export class Sampler2D {
 
         /**
          *
-         * @type {Number}
+         * @type {number}
          */
         this.width = width;
 
         /**
          *
-         * @type {Number}
+         * @type {number}
          */
         this.height = height;
 
         /**
          * Number of channels
-         * @type {Number}
+         * @type {number}
          */
         this.itemSize = itemSize;
 
@@ -81,18 +81,6 @@ export class Sampler2D {
         this.version = 0;
     }
 
-    /**
-     *
-     * @deprecated
-     * @param {number} x
-     * @param {number}y
-     * @param {Vector1|Vector2|Vector3|Vector4} result
-     * @returns {number}
-     */
-    get(x, y, result) {
-        throw new Error("Deprecated method, use sampleBilinear instead");
-    }
-
     /**
      *
      * @param {number} u
@@ -115,8 +103,8 @@ export class Sampler2D {
      * @returns {number}
      */
     sampleChannelCatmullRomUV(u, v, channel) {
-        const x = u * (this.width) - 0.5;
-        const y = v * (this.height) - 0.5;
+        const x = u * this.width - 0.5;
+        const y = v * this.height - 0.5;
 
         return this.sampleChannelCatmullRom(x, y, channel);
     }
@@ -171,8 +159,8 @@ export class Sampler2D {
         const texPos12_x = texPos1_x + offset12_x;
         const texPos12_y = texPos1_y + offset12_y;
 
-
         let result = 0.0;
+
         result += this.sampleChannelBilinear(texPos0_x, texPos0_y, channel) * w0_x * w0_y;
         result += this.sampleChannelBilinear(texPos12_x, texPos0_y, channel) * w12_x * w0_y;
         result += this.sampleChannelBilinear(texPos3_x, texPos0_y, channel) * w3_x * w0_y;
@@ -234,8 +222,8 @@ export class Sampler2D {
     }
 
     /**
-     * TODO there is an oversaturation bug in here somewhere, prefer to use linear sampling for now instead
-     * Bicubic-filtered sampling
+     *
+     * Bicubic-filtered sampling, note values can be negative due to the nature of the cubic curve
      * @param {number} x
      * @param {number} y
      * @param {number} channel
@@ -471,7 +459,11 @@ export class Sampler2D {
         const x = Math.round(u * w - 0.5);
         const y = Math.round(v * h - 0.5);
 
-        this.read(clamp(x, 0, w - 1), clamp(y, 0, h - 1), result);
+        this.read(
+            clamp(x, 0, w - 1),
+            clamp(y, 0, h - 1),
+            result
+        );
     }
 
     /**
@@ -532,25 +524,6 @@ export class Sampler2D {
         }
     }
 
-    /**
-     *
-     * @param {number} u
-     * @param {number} v
-     * @param {Vector4|Vector3|Vector2} [result]
-     * @deprecated
-     */
-    sample(u, v, result) {
-        console.warn("Deprecated method, use sampleBilinear instead");
-
-        const temp = [];
-
-        this.sampleBilinear(u * (this.width - 1), v * (this.height - 1), temp, 0);
-
-        result.readFromArray(temp);
-
-        return temp[0];
-    }
-
     /**
      *
      * @param {number} x
@@ -691,11 +664,11 @@ export class Sampler2D {
 
     /**
      *
-     * @param {Number} x
-     * @param {Number} y
-     * @param {Number} width
-     * @param {Number} height
-     * @param {Array.<Number>} value
+     * @param {number} x
+     * @param {number} y
+     * @param {number} width
+     * @param {number} height
+     * @param {Array.<number>} value
      */
     fill(x, y, width, height, value) {
 
@@ -885,10 +858,13 @@ export class Sampler2D {
     computeByteSize() {
         let dataSize;
 
-        if (Array.isArray(this.data)) {
-            dataSize = 8 * this.data.length;
+        const data = this.data;
+
+        if (Array.isArray(data)) {
+            // Assume IEEE float 64
+            dataSize = 8 * data.length;
         } else {
-            dataSize = this.data.buffer.byteLength;
+            dataSize = data.buffer.byteLength;
         }
 
         return dataSize + 280;
@@ -900,6 +876,11 @@ export class Sampler2D {
      * @return {boolean}
      */
     equals(other) {
+        if(this === other){
+            // special case
+            return true;
+        }
+
         if (
             this.width !== other.width
             || this.height !== other.height
@@ -920,9 +901,7 @@ export class Sampler2D {
 
         const length = this.data.length;
 
-        const stride = Math.max(1, Math.ceil(length / 509));
-
-        hash ^= computeStridedIntegerArrayHash(this.data, 0, length, stride);
+        hash ^= sparse_typed_array_hash(this.data, 0, length, 509);
 
         return hash;
     }

package/src/engine/graphics/texture/sampler/sampler2d_to_texture.d.ts

@@ -0,0 +1,10 @@
+export default sampler2d_to_texture;
+/**
+ *
+ * @param {Sampler2D} sampler
+ * @return {DataTexture}
+ */
+declare function sampler2d_to_texture(sampler: Sampler2D): DataTexture;
+import { Sampler2D } from "./Sampler2D.js";
+import { DataTexture } from 'three';
+//# sourceMappingURL=sampler2d_to_texture.d.ts.map

package/src/engine/graphics/texture/sampler/sampler2d_to_texture.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sampler2d_to_texture.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/texture/sampler/sampler2d_to_texture.js"],"names":[],"mappings":";AAMA;;;;GAIG;AACH,+CAHW,SAAS,GACR,WAAW,CAsCtB;0BA7CyB,gBAAgB;4BAFqC,OAAO"}

package/src/engine/graphics/texture/sampler/{Sampler2D2Texture.js → sampler2d_to_texture.js}

@@ -1,7 +1,7 @@
 import { ClampToEdgeWrapping, DataTexture, RGBAFormat, UnsignedByteType } from 'three';
 import { assert } from "../../../../core/assert.js";
-import { copy_Sampler2D_channel_data } from "./copy_Sampler2D_channel_data.js";
 import { Sampler2D } from "./Sampler2D.js";
+import { sampler2d_transfer_data } from "./sampler2d_transfer_data.js";
 
 
 /**
@@ -9,8 +9,8 @@ import { Sampler2D } from "./Sampler2D.js";
  * @param {Sampler2D} sampler
  * @return {DataTexture}
  */
-function sampler2D2Texture(sampler) {
-    assert.notEqual(sampler, undefined, 'sampler is undefined');
+function sampler2d_to_texture(sampler) {
+    assert.defined(sampler, 'sampler');
 
     const result = new DataTexture();
     result.format = RGBAFormat;
@@ -23,7 +23,7 @@ function sampler2D2Texture(sampler) {
 
     } else {
         const dest = Sampler2D.uint8(4, sampler.width, sampler.height);
-        copy_Sampler2D_channel_data(sampler, dest);
+        sampler2d_transfer_data(sampler, dest);
 
         data = dest.data;
     }
@@ -47,4 +47,4 @@ function sampler2D2Texture(sampler) {
 
 }
 
-export default sampler2D2Texture;
+export default sampler2d_to_texture;

package/src/engine/graphics/texture/sampler/{copy_Sampler2D_channel_data.d.ts → sampler2d_transfer_data.d.ts}

@@ -4,5 +4,5 @@
  * @param {Sampler2D} source
  * @param {Sampler2D} destination
  */
-export function copy_Sampler2D_channel_data(source: Sampler2D, destination: Sampler2D): void;
-//# sourceMappingURL=copy_Sampler2D_channel_data.d.ts.map
+export function sampler2d_transfer_data(source: Sampler2D, destination: Sampler2D): void;
+//# sourceMappingURL=sampler2d_transfer_data.d.ts.map

package/src/engine/graphics/texture/sampler/sampler2d_transfer_data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sampler2d_transfer_data.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/texture/sampler/sampler2d_transfer_data.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,yFAiEC"}

package/src/engine/graphics/texture/sampler/{copy_Sampler2D_channel_data.js → sampler2d_transfer_data.js}

@@ -6,7 +6,7 @@ import { saturated_value_by_constructor } from "./saturated_value_by_constructor
  * @param {Sampler2D} source
  * @param {Sampler2D} destination
  */
-export function copy_Sampler2D_channel_data(source, destination) {
+export function sampler2d_transfer_data(source, destination) {
     if (source.width !== destination.width || source.height !== destination.height) {
         throw new Error('Source and destination dimensions do not match');
     }

package/src/engine/graphics/texture/sampler/writeSampler2DDataToDataTexture.js

@@ -16,11 +16,11 @@ export function writeSample2DDataToDataTexture(sampler, texture) {
         }
     } else if (sampler.itemSize === 3) {
         if (texture.format !== RGBFormat) {
-            throw new Error('itemSize is 2 and texture.format is not RGBFormat');
+            throw new Error('itemSize is 3 and texture.format is not RGBFormat');
         }
     } else if (sampler.itemSize === 4) {
         if (texture.format !== RGBAFormat) {
-            throw new Error('itemSize is 2 and texture.format is not RGBAFormat');
+            throw new Error('itemSize is 4 and texture.format is not RGBAFormat');
         }
     } else {
         throw new Error('Unsupported itemSize');

package/src/engine/graphics/trail/x/simulator/RibbonXFixedPhysicsSimulator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RibbonXFixedPhysicsSimulator.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/trail/x/simulator/RibbonXFixedPhysicsSimulator.js"],"names":[],"mappings":"AAIA;;GAEG;AACH;IAKI;;;;;OAKG;IACH,iCAHW,MAAM,aACN,MAAM,QAkBhB;CACJ"}
+{"version":3,"file":"RibbonXFixedPhysicsSimulator.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/trail/x/simulator/RibbonXFixedPhysicsSimulator.js"],"names":[],"mappings":"AAIA;;GAEG;AACH;IAEI;;;;;OAKG;IACH,iCAHW,MAAM,aACN,MAAM,QAkBhB;CACJ"}

package/src/engine/graphics/trail/x/simulator/RibbonXFixedPhysicsSimulator.js

@@ -6,9 +6,6 @@ import { RIBBON_ATTRIBUTE_ADDRESS_AGE, RIBBON_ATTRIBUTE_ADDRESS_UV_OFFSET } from
  * Fixed function simulation engine for ribbons
  */
 export class RibbonXFixedPhysicsSimulator {
-    constructor() {
-
-    }
 
     /**
      *