@woosh/meep-engine 3.57.0 → 3.58.0

package/editor/ecs/component/editors/ColorEditor.js

@@ -1,6 +1,6 @@
 import { TypeEditor } from "../TypeEditor.js";
 import EmptyView from "../../../../src/view/elements/EmptyView.js";
-import { rgb2hex } from "../../../../src/core/color/hex/rgb2hex.js";
+import { rgb_to_hex } from "../../../../src/core/color/hex/rgb_to_hex.js";
 
 export class ColorEditor extends TypeEditor {
     build(parent, field) {
@@ -20,7 +20,7 @@ export class ColorEditor extends TypeEditor {
 
         function sync_up() {
             view.attr({
-                value: `#${rgb2hex(color.r * 255, color.g * 255, color.b * 255)}`
+                value: `#${rgb_to_hex(color.r * 255, color.g * 255, color.b * 255)}`
             })
         }
 

package/editor/particles/effect/ParticleEffectDocument.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ParticleEffectDocument.d.ts","sourceRoot":"","sources":["../../../../editor/particles/effect/ParticleEffectDocument.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"ParticleEffectDocument.d.ts","sourceRoot":"","sources":["../../../../editor/particles/effect/ParticleEffectDocument.js"],"names":[],"mappings":"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"}

package/editor/particles/effect/ParticleEffectDocument.js

@@ -18,11 +18,8 @@ import {
 import {
     particle_library_description_or_undefined,
 } from "../../../src/shade/renderer/particles/graph/particle_node_library.js";
-import {
-    PARTICLE_GRAPH_ERROR,
-    PARTICLE_GRAPH_PHASE,
-    validate_particle_graph,
-} from "../../../src/shade/renderer/particles/graph/validate_particle_graph.js";
+import { PARTICLE_GRAPH_PHASE, validate_particle_graph } from "../../../src/shade/renderer/particles/graph/validate_particle_graph.js";
+import { PARTICLE_GRAPH_ERROR } from "../../../src/shade/renderer/particles/graph/particle_graph_diagnostic.js";
 import {
     disassemble_particle_program,
     parse_particle_assembly,

package/editor/tools/GridPaintTool.js

@@ -1,4 +1,4 @@
-import { hex2rgb } from "../../src/core/color/hex/hex2rgb.js";
+import { hex_to_rgb } from "../../src/core/color/hex/hex_to_rgb.js";
 import Vector1 from "../../src/core/geom/Vector1.js";
 import Vector2 from "../../src/core/geom/Vector2.js";
 import Vector4 from "../../src/core/geom/Vector4.js";
@@ -56,7 +56,7 @@ class GridPaintTool extends Tool {
     buildColor() {
 
         const color = new Vector4();
-        const baseColor = hex2rgb(this.settings.color.get());
+        const baseColor = hex_to_rgb(this.settings.color.get());
         color.set(baseColor.r, baseColor.g, baseColor.b, 0);
         color.multiplyScalar(1 / 255);
 

package/editor/view/node-graph/NodeGraphEditorView.d.ts

@@ -245,7 +245,7 @@ import View from "../../../src/view/View.js";
 import { ActionProcessor } from "../../../src/core/process/undo/ActionProcessor.js";
 import { NodeGraphClipboard } from "./NodeGraphClipboard.js";
 import { NodeGraphSelection } from "./NodeGraphSelection.js";
-import { NodeGraphCamera } from "./NodeGraphView.js";
+import { NodeGraphCamera } from "./NodeGraphCamera.js";
 import { NodeDescriptionVisualRegistry } from "../../../src/core/model/node-graph/visual/NodeDescriptionVisualRegistry.js";
 import { NodeGraphView } from "./NodeGraphView.js";
 import { NodeGraphMinimapView } from "./NodeGraphMinimapView.js";

package/editor/view/node-graph/NodeGraphEditorView.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NodeGraphEditorView.d.ts","sourceRoot":"","sources":["../../../../editor/view/node-graph/NodeGraphEditorView.js"],"names":[],"mappings":"AAmDA;IAyBI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmCG;IACH,+KAiSC;IA7VD;;OAEG;IACH,iBAWE;IA+DE;;OAEG;IACH,UAFU,OAAO,CAEO;IAExB;;;OAGG;IACH,2CAAsC;IAEtC;;;;;OAKG;IACH,WAFU,kBAAkB,CAEF;IAE1B;;OAEG;IACH,kCAFiC,OAAO,CAEA;IAExC;;;OAGG;IACH,WAFU,kBAAkB,CAEa;IAEzC;;;OAGG;IACH,QAFU,eAAe,CAEL;IACpB;;;OAGG;IACH,4BAAoB;IAEpB;;;OAGG;IACH,iBAAkB;IAElB,mBAAuC;IAYvC;;;OAGG;IACH,gBAFU,6BAA6B,CAEH;IAepC;;OAEG;IACH,WAFU,aAAa,CAEG;IA4H1B;;;;;;;;OAQG;IACH,SAFU,oBAAoB,GAAC,IAAI,CAEhB;IA4BnB;;;;;OAKG;IACH,YAFU,uBAAuB,GAAC,IAAI,CAEhB;IAEtB;;;;;;;;;;OAUG;IACH,aAFU,qBAAqB,GAAC,IAAI,CAEb;IAgF3B;;;;;;;;;;;;;;;OAeG;IACH;QAP4B,CAAC,GAAlB,MAAM;QACW,CAAC,GAAlB,MAAM;QACW,UAAU,GAA3B,MAAM;QAC6B,QAAQ;QAC7B,IAAI;QAChB,qBAAqB,CAwBjC;IAED;;;;;;;;;;;;OAYG;IACH,eAWC;IAED;;;;;;;;;OASG;IACH,4BAFa,OAAO,CAInB;IAED;;;;;;;;;;;;;OAaG;IACH;QAN4B,CAAC,GAAlB,MAAM;QACW,CAAC,GAAlB,MAAM;QACW,UAAU,GAA3B,MAAM;QACJ,qBAAqB,CA6BjC;IAED;;;OAGG;IACH,0BAFa,OAAO,CAQnB;IAED;;;;;OAKG;IACH,gCA8BC;IAED;;;;;;;;;OASG;IACH,iBAJa,OAAO,CAmBnB;IAED;;;;;;;;;;;;;;OAcG;IACH,SAJa,QAAQ,cAAc,CAAC,CAiCnC;IAED;;;;;;;;;;;OAWG;IACH,sBAJa,QAAQ,cAAc,CAAC,CAqBnC;IA+DD,yBAuDC;;CACJ;iBAz1BgB,2BAA2B;gCAHZ,mDAAmD;mCA4B5E,yBAAyB;mCArBG,yBAAyB;gCAFb,oBAAoB;8CAS5D,4EAA4E;8BATpC,oBAAoB;qCAC9B,2BAA2B;wCAexB,8BAA8B;oBALlD,mCAAmC"}
+{"version":3,"file":"NodeGraphEditorView.d.ts","sourceRoot":"","sources":["../../../../editor/view/node-graph/NodeGraphEditorView.js"],"names":[],"mappings":"AAmDA;IAyBI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmCG;IACH,+KAiSC;IA7VD;;OAEG;IACH,iBAWE;IA+DE;;OAEG;IACH,UAFU,OAAO,CAEO;IAExB;;;OAGG;IACH,2CAAsC;IAEtC;;;;;OAKG;IACH,WAFU,kBAAkB,CAEF;IAE1B;;OAEG;IACH,kCAFiC,OAAO,CAEA;IAExC;;;OAGG;IACH,WAFU,kBAAkB,CAEa;IAEzC;;;OAGG;IACH,QAFU,eAAe,CAEL;IACpB;;;OAGG;IACH,4BAAoB;IAEpB;;;OAGG;IACH,iBAAkB;IAElB,mBAAuC;IAYvC;;;OAGG;IACH,gBAFU,6BAA6B,CAEH;IAepC;;OAEG;IACH,WAFU,aAAa,CAEG;IA4H1B;;;;;;;;OAQG;IACH,SAFU,oBAAoB,GAAC,IAAI,CAEhB;IA4BnB;;;;;OAKG;IACH,YAFU,uBAAuB,GAAC,IAAI,CAEhB;IAEtB;;;;;;;;;;OAUG;IACH,aAFU,qBAAqB,GAAC,IAAI,CAEb;IAgF3B;;;;;;;;;;;;;;;OAeG;IACH;QAP4B,CAAC,GAAlB,MAAM;QACW,CAAC,GAAlB,MAAM;QACW,UAAU,GAA3B,MAAM;QAC6B,QAAQ;QAC7B,IAAI;QAChB,qBAAqB,CAwBjC;IAED;;;;;;;;;;;;OAYG;IACH,eAWC;IAED;;;;;;;;;OASG;IACH,4BAFa,OAAO,CAInB;IAED;;;;;;;;;;;;;OAaG;IACH;QAN4B,CAAC,GAAlB,MAAM;QACW,CAAC,GAAlB,MAAM;QACW,UAAU,GAA3B,MAAM;QACJ,qBAAqB,CA6BjC;IAED;;;OAGG;IACH,0BAFa,OAAO,CAQnB;IAED;;;;;OAKG;IACH,gCA8BC;IAED;;;;;;;;;OASG;IACH,iBAJa,OAAO,CAmBnB;IAED;;;;;;;;;;;;;;OAcG;IACH,SAJa,QAAQ,cAAc,CAAC,CAiCnC;IAED;;;;;;;;;;;OAWG;IACH,sBAJa,QAAQ,cAAc,CAAC,CAqBnC;IA+DD,yBAuDC;;CACJ;iBAz1BgB,2BAA2B;gCAHZ,mDAAmD;mCA4B5E,yBAAyB;mCArBG,yBAAyB;gCAHgB,sBAAsB;8CAU3F,4EAA4E;8BATrD,oBAAoB;qCACb,2BAA2B;wCAexB,8BAA8B;oBALlD,mCAAmC"}

package/editor/view/node-graph/NodeGraphEditorView.js

@@ -5,8 +5,8 @@ import { ActionProcessor } from "../../../src/core/process/undo/ActionProcessor.
 import KeyboardDevice from "../../../src/engine/input/devices/KeyboardDevice.js";
 import { KeyCodes } from "../../../src/engine/input/devices/KeyCodes.js";
 import View from "../../../src/view/View.js";
-import { NODE_GRAPH_SCALE_MAX, NODE_GRAPH_SCALE_MIN } from "./NodeGraphCamera.js";
-import { NodeGraphCamera, NodeGraphView } from "./NodeGraphView.js";
+import { NODE_GRAPH_SCALE_MAX, NODE_GRAPH_SCALE_MIN, NodeGraphCamera } from "./NodeGraphCamera.js";
+import { NodeGraphView } from "./NodeGraphView.js";
 import { NodeGraphMinimapView } from "./NodeGraphMinimapView.js";
 import { NodeGraphSelection } from "./NodeGraphSelection.js";
 import { ConnectionDeleteAction } from "./actions/ConnectionDeleteAction.js";

package/editor/view/node-graph/NodeGraphView.d.ts

@@ -1,4 +1,3 @@
-export { NodeGraphCamera } from "./NodeGraphCamera.js";
 export class NodeGraphView extends View {
     /**
      *

package/editor/view/node-graph/NodeGraphView.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NodeGraphView.d.ts","sourceRoot":"","sources":["../../../../editor/view/node-graph/NodeGraphView.js"],"names":[],"mappings":";AA0GA;IA4GI;;;;;;;;;;;;;;;;;;;OAmBG;IACH,gJAwiBC;IAvqBD,mBAAmC;IAEnC;;;;;;;;;OASG;IACH,oBAFU,IAAI,MAAM,EAAE,QAAQ,CAAC,CAET;IAmBtB;;;OAGG;IACH,qBAFmB,yBAAyB,cAE/B;IAEb;;OAEG;IACH,iBA0DE;IAEF;;;;OAIG;IACH,mBAFU,OAAO,CAEA;IAmCb;;;OAGG;IACH,2CAAsC;IAMtC;;;OAGG;IACH,QAFU,eAAe,CAEL;IAEpB;;;OAGG;IACH,iBAAkB;IAElB;;;OAGG;IACH,4BAAoB;IAEpB;;;OAGG;IACH,WAFU,kBAAkB,CAEF;IA6f9B;;;;;;;;;OASG;IACH,oBAFa,IAAI,CAgBhB;IAED;;;;;;;;OAQG;IACH,gBAFa,IAAI,CAMhB;IAED;;;;;;;;OAQG;IACH,cAFa,OAAO,CAInB;IAgBD;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,gCAFa,IAAI,CAgOhB;IAED;;;;;;;;OAQG;IACH,0BAHW,KAAK,GACH,MAAM,EAAE,CAwBpB;IAED;;;;;;;;;;;OAWG;IACH,gCAHW,KAAK,GACH,MAAM,EAAE,CAsBpB;IAED;;;;;;;;;;OAUG;IACH,6BAJW,KAAK,SACL,UAAU,GAAC,YAAY,GACrB,IAAI,CAgDhB;IAED;;;;OAIG;IACH,wBAHW,OAAO,GACL,aAAW,IAAI,CAiC3B;IAED;;;;;;;OAOG;IACH,4BAJW,MAAM,GAAC,IAAI,gBACX,MAAM,GAAC,IAAI,SACX,UAAU,GAAC,YAAY,QA8CjC;IAGD;;;;;;;OAOG;IACH,wDAFa,OAAO,CAcnB;IAED;;;;;;;;;OASG;IACH,+CAFa,oBAAoB,CAYhC;IAED;;;;;;OAMG;IACH,oBALW,wBAAwB,QACxB,oBAAoB,iCAEpB,OAAO,QA+DjB;IAED;;;;OAIG;IACH,mCAHW,yBAAyB,UACzB,OAAO,QAiBjB;IAeD;;;;OAIG;IACH,kCAHW,OAAO,UACP,OAAO,QAIjB;IAED;;;;OAIG;IACH,kCAHW,OAAO,UACP,OAAO,QAIjB;;CACJ;iBA/8CgB,2BAA2B;yBAInB,eAAe;0CAIE,sEAAsE;gCAChF,mDAAmD;gCACnD,sBAAsB;mCACnB,yBAAyB;kBAS1C,yCAAyC;oBAlBvC,mCAAmC;qCAiBlB,mEAAmE"}
+{"version":3,"file":"NodeGraphView.d.ts","sourceRoot":"","sources":["../../../../editor/view/node-graph/NodeGraphView.js"],"names":[],"mappings":"AAwGA;IA4GI;;;;;;;;;;;;;;;;;;;OAmBG;IACH,gJAwiBC;IAvqBD,mBAAmC;IAEnC;;;;;;;;;OASG;IACH,oBAFU,IAAI,MAAM,EAAE,QAAQ,CAAC,CAET;IAmBtB;;;OAGG;IACH,qBAFmB,yBAAyB,cAE/B;IAEb;;OAEG;IACH,iBA0DE;IAEF;;;;OAIG;IACH,mBAFU,OAAO,CAEA;IAmCb;;;OAGG;IACH,2CAAsC;IAMtC;;;OAGG;IACH,QAFU,eAAe,CAEL;IAEpB;;;OAGG;IACH,iBAAkB;IAElB;;;OAGG;IACH,4BAAoB;IAEpB;;;OAGG;IACH,WAFU,kBAAkB,CAEF;IA6f9B;;;;;;;;;OASG;IACH,oBAFa,IAAI,CAgBhB;IAED;;;;;;;;OAQG;IACH,gBAFa,IAAI,CAMhB;IAED;;;;;;;;OAQG;IACH,cAFa,OAAO,CAInB;IAgBD;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,gCAFa,IAAI,CAgOhB;IAED;;;;;;;;OAQG;IACH,0BAHW,KAAK,GACH,MAAM,EAAE,CAwBpB;IAED;;;;;;;;;;;OAWG;IACH,gCAHW,KAAK,GACH,MAAM,EAAE,CAsBpB;IAED;;;;;;;;;;OAUG;IACH,6BAJW,KAAK,SACL,UAAU,GAAC,YAAY,GACrB,IAAI,CAgDhB;IAED;;;;OAIG;IACH,wBAHW,OAAO,GACL,aAAW,IAAI,CAiC3B;IAED;;;;;;;OAOG;IACH,4BAJW,MAAM,GAAC,IAAI,gBACX,MAAM,GAAC,IAAI,SACX,UAAU,GAAC,YAAY,QA8CjC;IAGD;;;;;;;OAOG;IACH,wDAFa,OAAO,CAcnB;IAED;;;;;;;;;OASG;IACH,+CAFa,oBAAoB,CAYhC;IAED;;;;;;OAMG;IACH,oBALW,wBAAwB,QACxB,oBAAoB,iCAEpB,OAAO,QA+DjB;IAED;;;;OAIG;IACH,mCAHW,yBAAyB,UACzB,OAAO,QAiBjB;IAeD;;;;OAIG;IACH,kCAHW,OAAO,UACP,OAAO,QAIjB;IAED;;;;OAIG;IACH,kCAHW,OAAO,UACP,OAAO,QAIjB;;CACJ;iBA78CgB,2BAA2B;yBAInB,eAAe;0CAIE,sEAAsE;gCAChF,mDAAmD;gCACnD,sBAAsB;mCACnB,yBAAyB;kBAS1C,yCAAyC;oBAlBvC,mCAAmC;qCAiBlB,mEAAmE"}

package/editor/view/node-graph/NodeGraphView.js

@@ -27,8 +27,6 @@ import { aabb2_intersects_aabb2 } from "../../../src/core/geom/2d/aabb/aabb2_int
 import { min2 } from "../../../src/core/math/min2.js";
 import EmptyView from "../../../src/view/elements/EmptyView.js";
 
-export { NodeGraphCamera } from "./NodeGraphCamera.js";
-
 const v2_pointer = new Vector2();
 
 const v2_hit_source = new Vector2();

package/package.json

@@ -6,7 +6,7 @@
   "description": "Advanced 3D game engine",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "3.57.0",
+  "version": "3.58.0",
   "exports": {
     "./build/*": "./build/*",
     "./src/*": "./src/*",

package/src/core/bvh8/build/NodeProxy.js

@@ -1,6 +1,6 @@
 import { array_remove_first } from "../../collection/array/array_remove_first.js";
 import { aabb3_array_combine } from "../../geom/3d/aabb/aabb3_array_combine.js";
-import { aabb3_compute_surface_area } from "../../geom/3d/aabb/aabb3_compute_surface_area.js";
+import { aabb3_surface_area } from "../../geom/3d/aabb/aabb3_surface_area.js";
 import { v3_distance_sqr } from "../../geom/vec3/v3_distance_sqr.js";
 import { BVH8_MAX_LEAF_TRIANGLE_OFFSET } from "../BVH8.js";
 import { aabb3_from_triangle_by_index } from "./aabb3_from_triangle_by_index.js";
@@ -301,7 +301,7 @@ export class NodeProxy {
      * @return {number}
      */
     area_score() {
-        let result = aabb3_compute_surface_area(...this.bounds);
+        let result = aabb3_surface_area(...this.bounds);
 
         for (const child of this.children) {
             result += child.area_score();

package/src/core/bvh8/build/aabb3_compute_merge_cost.js

@@ -1,5 +1,5 @@
 import { aabb3_array_combine } from "../../geom/3d/aabb/aabb3_array_combine.js";
-import { aabb3_compute_surface_area } from "../../geom/3d/aabb/aabb3_compute_surface_area.js";
+import { aabb3_surface_area } from "../../geom/3d/aabb/aabb3_surface_area.js";
 
 const scratch_aabb = new Float32Array(6);
 
@@ -11,8 +11,8 @@ const scratch_aabb = new Float32Array(6);
  */
 export function aabb3_compute_merge_cost(a, b) {
 
-    const area_a = aabb3_compute_surface_area(...a);
-    const area_b = aabb3_compute_surface_area(...b);
+    const area_a = aabb3_surface_area(...a);
+    const area_b = aabb3_surface_area(...b);
 
     const area_sum = area_a + area_b;
 
@@ -23,7 +23,7 @@ export function aabb3_compute_merge_cost(a, b) {
 
     aabb3_array_combine(scratch_aabb, 0, a, 0, b, 0);
 
-    const combined_area = aabb3_compute_surface_area(...scratch_aabb);
+    const combined_area = aabb3_surface_area(...scratch_aabb);
 
     return combined_area / area_sum;
 }

package/src/core/bvh8/build/bvh8_build_for_geometry.js

@@ -5,7 +5,7 @@ import {
 } from "../../collection/array/array_quick_sort_by_lookup_uint.js";
 import { AABB3 } from "../../geom/3d/aabb/AABB3.js";
 import { aabb3_array_combine } from "../../geom/3d/aabb/aabb3_array_combine.js";
-import { aabb3_compute_surface_area } from "../../geom/3d/aabb/aabb3_compute_surface_area.js";
+import { aabb3_surface_area } from "../../geom/3d/aabb/aabb3_surface_area.js";
 import { aabb3_from_v3_array } from "../../geom/3d/aabb/aabb3_from_v3_array.js";
 import v3_morton_encode from "../../geom/3d/morton/v3_morton_encode.js";
 import { aabb3_compute_from_triangle } from "../../geom/3d/triangle/aabb3_compute_from_triangle.js";
@@ -211,7 +211,7 @@ export function bvh8_build_for_geometry(
 
         aabb3_array_combine(scratch_aabb, 0, stem.bounds, 0, addition.bounds, 0);
 
-        const combined_area = aabb3_compute_surface_area(...scratch_aabb);
+        const combined_area = aabb3_surface_area(...scratch_aabb);
 
         // simplified surface area heuristic
         return combined_area;

package/src/core/geom/2d/line/line2_segment_intersection_fraction_2d.d.ts

@@ -5,7 +5,7 @@
  * real crossing is always in [0,1]), and it is used instead of NaN so callers reject the no-crossing
  * case with a trivial comparison (`t < 0` / `=== -1`) rather than the slower Number.isNaN.
  *
- * Unlike {@link line_segment_compute_line_segment_intersection_array_2d}, the first pair of points
+ * Unlike {@link segment2_segment_compute_intersection_array_2d}, the first pair of points
  * defines an unbounded line (not a segment) and the result is the parametric position on the segment
  * rather than the intersection point.
  *

package/src/core/geom/2d/line/line2_segment_intersection_fraction_2d.js

@@ -7,7 +7,7 @@ import { v2_cross_product } from "../../vec2/v2_cross_product.js";
  * real crossing is always in [0,1]), and it is used instead of NaN so callers reject the no-crossing
  * case with a trivial comparison (`t < 0` / `=== -1`) rather than the slower Number.isNaN.
  *
- * Unlike {@link line_segment_compute_line_segment_intersection_array_2d}, the first pair of points
+ * Unlike {@link segment2_segment_compute_intersection_array_2d}, the first pair of points
  * defines an unbounded line (not a segment) and the result is the parametric position on the segment
  * rather than the intersection point.
  *

package/src/core/geom/2d/triangle/tri2_intersects_aabb2.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Separating-axis overlap test between a 2D triangle and an axis-aligned box.
+ *
+ * @param {number} ax first triangle vertex x
+ * @param {number} ay first triangle vertex y
+ * @param {number} bx second triangle vertex x
+ * @param {number} by second triangle vertex y
+ * @param {number} cx third triangle vertex x
+ * @param {number} cy third triangle vertex y
+ * @param {number} bminx box minimum corner x
+ * @param {number} bminy box minimum corner y
+ * @param {number} bmaxx box maximum corner x
+ * @param {number} bmaxy box maximum corner y
+ * @returns {boolean} true if the triangle and box overlap
+ */
+export function tri2_intersects_aabb2(ax: number, ay: number, bx: number, by: number, cx: number, cy: number, bminx: number, bminy: number, bmaxx: number, bmaxy: number): boolean;
+//# sourceMappingURL=tri2_intersects_aabb2.d.ts.map

package/src/core/geom/2d/triangle/tri2_intersects_aabb2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tri2_intersects_aabb2.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/triangle/tri2_intersects_aabb2.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,0CAZW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,SACN,MAAM,SACN,MAAM,SACN,MAAM,SACN,MAAM,GACJ,OAAO,CAanB"}

package/src/core/geom/2d/triangle/tri2_intersects_aabb2.js

@@ -0,0 +1,64 @@
+/**
+ * Separating-axis overlap test between a 2D triangle and an axis-aligned box.
+ *
+ * @param {number} ax first triangle vertex x
+ * @param {number} ay first triangle vertex y
+ * @param {number} bx second triangle vertex x
+ * @param {number} by second triangle vertex y
+ * @param {number} cx third triangle vertex x
+ * @param {number} cy third triangle vertex y
+ * @param {number} bminx box minimum corner x
+ * @param {number} bminy box minimum corner y
+ * @param {number} bmaxx box maximum corner x
+ * @param {number} bmaxy box maximum corner y
+ * @returns {boolean} true if the triangle and box overlap
+ */
+export function tri2_intersects_aabb2(ax, ay, bx, by, cx, cy, bminx, bminy, bmaxx, bmaxy) {
+    // Box axes (x then y).
+    if (Math.max(ax, bx, cx) < bminx || Math.min(ax, bx, cx) > bmaxx) return false;
+    if (Math.max(ay, by, cy) < bminy || Math.min(ay, by, cy) > bmaxy) return false;
+
+    // Triangle edge normals.
+    if (edge_separates(ax, ay, bx, by, cx, cy, bminx, bminy, bmaxx, bmaxy)) return false;
+    if (edge_separates(bx, by, cx, cy, ax, ay, bminx, bminy, bmaxx, bmaxy)) return false;
+    if (edge_separates(cx, cy, ax, ay, bx, by, bminx, bminy, bmaxx, bmaxy)) return false;
+
+    return true;
+}
+
+/**
+ * Does the outward normal of edge (p->q) separate the box from the triangle?
+ * `r` is the triangle's third vertex (to orient the normal inward).
+ *
+ * @param {number} px edge start vertex x
+ * @param {number} py edge start vertex y
+ * @param {number} qx edge end vertex x
+ * @param {number} qy edge end vertex y
+ * @param {number} rx triangle's third vertex x
+ * @param {number} ry triangle's third vertex y
+ * @param {number} bminx box minimum corner x
+ * @param {number} bminy box minimum corner y
+ * @param {number} bmaxx box maximum corner x
+ * @param {number} bmaxy box maximum corner y
+ * @returns {boolean} true if this edge's axis separates the box from the triangle
+ */
+function edge_separates(px, py, qx, qy, rx, ry, bminx, bminy, bmaxx, bmaxy) {
+    const nx = -(qy - py);
+    const ny = qx - px;
+
+    // triangle interval along n
+    const dp = nx * px + ny * py;
+    const dr = nx * rx + ny * ry;
+    let tri_min, tri_max;
+    if (dp < dr) { tri_min = dp; tri_max = dr; } else { tri_min = dr; tri_max = dp; }
+
+    // box interval along n (4 corners)
+    const c0 = nx * bminx + ny * bminy;
+    const c1 = nx * bmaxx + ny * bminy;
+    const c2 = nx * bminx + ny * bmaxy;
+    const c3 = nx * bmaxx + ny * bmaxy;
+    const box_min = Math.min(c0, c1, c2, c3);
+    const box_max = Math.max(c0, c1, c2, c3);
+
+    return box_max < tri_min || box_min > tri_max;
+}

package/src/core/geom/2d/triangle/tri2_rasterize_barycentric.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Visits every pixel of a `width` x `height` grid whose centre lies inside triangle `(x0, y0)`, `(x1, y1)`, `(x2, y2)`,
+ * in pixel units: pixel `(col, row)` is the point sample at `(col + 0.5, row + 0.5)`. A centre on an edge belongs to
+ * one of the two triangles sharing that edge (the top-left rule), so a mesh visits each point once. An edge-on
+ * triangle visits nothing.
+ *
+ * `visitor.visit(col, row, l0, l1, l2)` receives the pixel and the centre's barycentric weights of the three vertices,
+ * in the order given.
+ *
+ * @param {number} width
+ * @param {number} height
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} x2
+ * @param {number} y2
+ * @param {{visit: function(number, number, number, number, number): void}} visitor
+ */
+export function tri2_rasterize_barycentric(width: number, height: number, x0: number, y0: number, x1: number, y1: number, x2: number, y2: number, visitor: {
+    visit: (arg0: number, arg1: number, arg2: number, arg3: number, arg4: number) => void;
+}): void;
+//# sourceMappingURL=tri2_rasterize_barycentric.d.ts.map

package/src/core/geom/2d/triangle/tri2_rasterize_barycentric.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tri2_rasterize_barycentric.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/triangle/tri2_rasterize_barycentric.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,kDAVW,MAAM,UACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,WACN;IAAC,KAAK,SAAW,MAAM,QAAE,MAAM,QAAE,MAAM,QAAE,MAAM,QAAE,MAAM,KAAG,IAAI,CAAA;CAAC,QA+DzE"}

package/src/core/geom/2d/triangle/tri2_rasterize_barycentric.js

@@ -0,0 +1,81 @@
+/**
+ * Visits every pixel of a `width` x `height` grid whose centre lies inside triangle `(x0, y0)`, `(x1, y1)`, `(x2, y2)`,
+ * in pixel units: pixel `(col, row)` is the point sample at `(col + 0.5, row + 0.5)`. A centre on an edge belongs to
+ * one of the two triangles sharing that edge (the top-left rule), so a mesh visits each point once. An edge-on
+ * triangle visits nothing.
+ *
+ * `visitor.visit(col, row, l0, l1, l2)` receives the pixel and the centre's barycentric weights of the three vertices,
+ * in the order given.
+ *
+ * @param {number} width
+ * @param {number} height
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} x2
+ * @param {number} y2
+ * @param {{visit: function(number, number, number, number, number): void}} visitor
+ */
+export function tri2_rasterize_barycentric(width, height, x0, y0, x1, y1, x2, y2, visitor) {
+    let area = (x1 - x0) * (y2 - y0) - (y1 - y0) * (x2 - x0);
+    if (!(Math.abs(area) > 0)) {
+        return;
+    }
+    // counter-clockwise, so the interior is where all three edge functions are positive
+    const swapped = area < 0;
+    if (swapped) {
+        let s = x1; x1 = x2; x2 = s;
+        s = y1; y1 = y2; y2 = s;
+        area = -area;
+    }
+    const inv_area = 1.0 / area;
+
+    // a point on an edge belongs to the triangle that edge runs up through (or left along) in
+    const own_0 = (y2 - y1) > 0 || ((y2 - y1) === 0 && (x2 - x1) < 0);
+    const own_1 = (y0 - y2) > 0 || ((y0 - y2) === 0 && (x0 - x2) < 0);
+    const own_2 = (y1 - y0) > 0 || ((y1 - y0) === 0 && (x1 - x0) < 0);
+
+    const col_lo = Math.max(0, Math.ceil(Math.min(x0, x1, x2) - 0.5));
+    const col_hi = Math.min(width - 1, Math.floor(Math.max(x0, x1, x2) - 0.5));
+    const row_lo = Math.max(0, Math.ceil(Math.min(y0, y1, y2) - 0.5));
+    const row_hi = Math.min(height - 1, Math.floor(Math.max(y0, y1, y2) - 0.5));
+
+    for (let row = row_lo; row <= row_hi; row++) {
+        const cy = row + 0.5;
+
+        // Each edge function is linear along the row, `e(cx) = a - dy * cx`, and bounds cx on one side: the row's
+        // span, widened by a pixel each way so the exact tests below keep their say on the edges
+        let x_lower = -Infinity;
+        let x_upper = Infinity;
+        let dy = y2 - y1;
+        let a = (x2 - x1) * (cy - y1) + dy * x1;
+        if (dy > 0) x_upper = Math.min(x_upper, a / dy); else if (dy < 0) x_lower = Math.max(x_lower, a / dy); else if (a < 0) continue;
+        dy = y0 - y2;
+        a = (x0 - x2) * (cy - y2) + dy * x2;
+        if (dy > 0) x_upper = Math.min(x_upper, a / dy); else if (dy < 0) x_lower = Math.max(x_lower, a / dy); else if (a < 0) continue;
+        dy = y1 - y0;
+        a = (x1 - x0) * (cy - y0) + dy * x0;
+        if (dy > 0) x_upper = Math.min(x_upper, a / dy); else if (dy < 0) x_lower = Math.max(x_lower, a / dy); else if (a < 0) continue;
+
+        const span_lo = Math.max(col_lo, Math.ceil(x_lower - 0.5) - 1);
+        const span_hi = Math.min(col_hi, Math.floor(x_upper - 0.5) + 1);
+
+        for (let col = span_lo; col <= span_hi; col++) {
+            const cx = col + 0.5;
+
+            const e0 = (x2 - x1) * (cy - y1) - (y2 - y1) * (cx - x1);
+            if (e0 < 0 || (e0 === 0 && !own_0)) continue;
+            const e1 = (x0 - x2) * (cy - y2) - (y0 - y2) * (cx - x2);
+            if (e1 < 0 || (e1 === 0 && !own_1)) continue;
+            const e2 = (x1 - x0) * (cy - y0) - (y1 - y0) * (cx - x0);
+            if (e2 < 0 || (e2 === 0 && !own_2)) continue;
+
+            if (swapped) {
+                visitor.visit(col, row, e0 * inv_area, e2 * inv_area, e1 * inv_area);
+            } else {
+                visitor.visit(col, row, e0 * inv_area, e1 * inv_area, e2 * inv_area);
+            }
+        }
+    }
+}

package/src/core/geom/2d/triangle/tri2_rasterize_conservative.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tri2_rasterize_conservative.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/triangle/tri2_rasterize_conservative.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,mDARW;IAAC,KAAK,EAAC,MAAM,CAAC;IAAC,MAAM,EAAC,MAAM,CAAC;IAAC,GAAG,EAAC,CAAC,CAAC,EAAC,MAAM,EAAC,CAAC,EAAC,MAAM,KAAG,IAAI,CAAA;CAAC,MAC5D,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAoBhB"}
+{"version":3,"file":"tri2_rasterize_conservative.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/triangle/tri2_rasterize_conservative.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH,mDARW;IAAC,KAAK,EAAC,MAAM,CAAC;IAAC,MAAM,EAAC,MAAM,CAAC;IAAC,GAAG,EAAC,CAAC,CAAC,EAAC,MAAM,EAAC,CAAC,EAAC,MAAM,KAAG,IAAI,CAAA;CAAC,MAC5D,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAoBhB"}

package/src/core/geom/2d/triangle/tri2_rasterize_conservative.js

@@ -1,99 +1,36 @@
-/**
- * Conservative rasterization of a 2D triangle into a bit image: every cell
- * whose unit square overlaps the triangle is set (a superset of exact coverage),
- * so the resulting mask never under-covers — required for packing gutters.
- * Overlap is decided by the separating-axis test between the triangle and each
- * candidate cell square.
- *
- * @param {{width:number, height:number, set:(x:number,y:number)=>void}} image
- * @param {number} x0
- * @param {number} y0
- * @param {number} x1
- * @param {number} y1
- * @param {number} x2
- * @param {number} y2
- */
-export function tri2_rasterize_conservative(image, x0, y0, x1, y1, x2, y2) {
-    let min_x = Math.floor(Math.min(x0, x1, x2));
-    let min_y = Math.floor(Math.min(y0, y1, y2));
-    let max_x = Math.ceil(Math.max(x0, x1, x2));
-    let max_y = Math.ceil(Math.max(y0, y1, y2));
-
-    if (min_x < 0) min_x = 0;
-    if (min_y < 0) min_y = 0;
-    if (max_x > image.width) max_x = image.width;
-    if (max_y > image.height) max_y = image.height;
-
-    for (let py = min_y; py < max_y; py++) {
-        for (let px = min_x; px < max_x; px++) {
-            if (tri_box_overlap(x0, y0, x1, y1, x2, y2, px, py, px + 1, py + 1)) {
-                image.set(px, py);
-            }
-        }
-    }
-}
-
-/**
- * Separating-axis overlap test between a triangle and an axis-aligned box.
- *
- * @param {number} ax first triangle vertex x
- * @param {number} ay first triangle vertex y
- * @param {number} bx second triangle vertex x
- * @param {number} by second triangle vertex y
- * @param {number} cx third triangle vertex x
- * @param {number} cy third triangle vertex y
- * @param {number} bminx box minimum corner x
- * @param {number} bminy box minimum corner y
- * @param {number} bmaxx box maximum corner x
- * @param {number} bmaxy box maximum corner y
- * @returns {boolean} true if the triangle and box overlap
- */
-function tri_box_overlap(ax, ay, bx, by, cx, cy, bminx, bminy, bmaxx, bmaxy) {
-    // Box axes (x then y).
-    if (Math.max(ax, bx, cx) < bminx || Math.min(ax, bx, cx) > bmaxx) return false;
-    if (Math.max(ay, by, cy) < bminy || Math.min(ay, by, cy) > bmaxy) return false;
-
-    // Triangle edge normals.
-    if (edge_separates(ax, ay, bx, by, cx, cy, bminx, bminy, bmaxx, bmaxy)) return false;
-    if (edge_separates(bx, by, cx, cy, ax, ay, bminx, bminy, bmaxx, bmaxy)) return false;
-    if (edge_separates(cx, cy, ax, ay, bx, by, bminx, bminy, bmaxx, bmaxy)) return false;
-
-    return true;
-}
-
-/**
- * Does the outward normal of edge (p->q) separate the box from the triangle?
- * `r` is the triangle's third vertex (to orient the normal inward).
- *
- * @param {number} px edge start vertex x
- * @param {number} py edge start vertex y
- * @param {number} qx edge end vertex x
- * @param {number} qy edge end vertex y
- * @param {number} rx triangle's third vertex x
- * @param {number} ry triangle's third vertex y
- * @param {number} bminx box minimum corner x
- * @param {number} bminy box minimum corner y
- * @param {number} bmaxx box maximum corner x
- * @param {number} bmaxy box maximum corner y
- * @returns {boolean} true if this edge's axis separates the box from the triangle
- */
-function edge_separates(px, py, qx, qy, rx, ry, bminx, bminy, bmaxx, bmaxy) {
-    const nx = -(qy - py);
-    const ny = qx - px;
-
-    // triangle interval along n
-    const dp = nx * px + ny * py;
-    const dr = nx * rx + ny * ry;
-    let tri_min, tri_max;
-    if (dp < dr) { tri_min = dp; tri_max = dr; } else { tri_min = dr; tri_max = dp; }
-
-    // box interval along n (4 corners)
-    const c0 = nx * bminx + ny * bminy;
-    const c1 = nx * bmaxx + ny * bminy;
-    const c2 = nx * bminx + ny * bmaxy;
-    const c3 = nx * bmaxx + ny * bmaxy;
-    const box_min = Math.min(c0, c1, c2, c3);
-    const box_max = Math.max(c0, c1, c2, c3);
-
-    return box_max < tri_min || box_min > tri_max;
-}
+import { tri2_intersects_aabb2 } from "./tri2_intersects_aabb2.js";
+
+/**
+ * Conservative rasterization of a 2D triangle into a bit image: every cell
+ * whose unit square overlaps the triangle is set (a superset of exact coverage),
+ * so the resulting mask never under-covers — required for packing gutters.
+ * Overlap is decided by the separating-axis test between the triangle and each
+ * candidate cell square.
+ *
+ * @param {{width:number, height:number, set:(x:number,y:number)=>void}} image
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} x2
+ * @param {number} y2
+ */
+export function tri2_rasterize_conservative(image, x0, y0, x1, y1, x2, y2) {
+    let min_x = Math.floor(Math.min(x0, x1, x2));
+    let min_y = Math.floor(Math.min(y0, y1, y2));
+    let max_x = Math.ceil(Math.max(x0, x1, x2));
+    let max_y = Math.ceil(Math.max(y0, y1, y2));
+
+    if (min_x < 0) min_x = 0;
+    if (min_y < 0) min_y = 0;
+    if (max_x > image.width) max_x = image.width;
+    if (max_y > image.height) max_y = image.height;
+
+    for (let py = min_y; py < max_y; py++) {
+        for (let px = min_x; px < max_x; px++) {
+            if (tri2_intersects_aabb2(x0, y0, x1, y1, x2, y2, px, py, px + 1, py + 1)) {
+                image.set(px, py);
+            }
+        }
+    }
+}

package/src/core/geom/3d/aabb/aabb3_build_frustum.d.ts

@@ -9,15 +9,4 @@
  * @param {number} z1
  */
 export function aabb3_build_frustum(result: number[], x0: number, y0: number, z0: number, x1: number, y1: number, z1: number): void;
-/**
- * Build orthographic frustum from an axis-aligned bounding box
- * @param {number[]} result
- * @param {number} x0
- * @param {number} y0
- * @param {number} z0
- * @param {number} x1
- * @param {number} y1
- * @param {number} z1
- */
-export function aabb_build_frustum(result: number[], x0: number, y0: number, z0: number, x1: number, y1: number, z1: number): void;
 //# sourceMappingURL=aabb3_build_frustum.d.ts.map

package/src/core/geom/3d/aabb/aabb3_build_frustum.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"aabb3_build_frustum.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/aabb/aabb3_build_frustum.js"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH,4CARW,MAAM,EAAE,MACR,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAIhB;AAZD;;;;;;;;;GASG;AACH,2CARW,MAAM,EAAE,MACR,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAIhB"}
+{"version":3,"file":"aabb3_build_frustum.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/aabb/aabb3_build_frustum.js"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH,4CARW,MAAM,EAAE,MACR,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAIhB"}

package/src/core/geom/3d/aabb/aabb3_build_frustum.js

@@ -1,20 +1,15 @@
-import { frustum3_from_aabb } from "../frustum/frustum3_from_aabb.js";
-
-/**
- * Build orthographic frustum from an axis-aligned bounding box
- * @param {number[]} result
- * @param {number} x0
- * @param {number} y0
- * @param {number} z0
- * @param {number} x1
- * @param {number} y1
- * @param {number} z1
- */
-export function aabb3_build_frustum(result, x0, y0, z0, x1, y1, z1) {
-    frustum3_from_aabb(result, 0, x0, y0, z0, x1, y1, z1);
-}
-
-/**
- * @deprecated Renamed to {@link aabb3_build_frustum} (was missing the dimension digit).
- */
-export const aabb_build_frustum = aabb3_build_frustum;
+import { frustum3_from_aabb } from "../frustum/frustum3_from_aabb.js";
+
+/**
+ * Build orthographic frustum from an axis-aligned bounding box
+ * @param {number[]} result
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} z0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} z1
+ */
+export function aabb3_build_frustum(result, x0, y0, z0, x1, y1, z1) {
+    frustum3_from_aabb(result, 0, x0, y0, z0, x1, y1, z1);
+}

package/src/core/geom/3d/box/box3_raycast.d.ts

@@ -11,7 +11,7 @@
  *    starting INSIDE the box returns its exit face;
  *  - on a miss the function returns `Infinity` and leaves `outNormal` untouched.
  *
- * Distinct from {@link aabb3_raycast}, which takes an arbitrary min/max box and
+ * Distinct from {@link aabb3_raycast_hit_point}, which takes an arbitrary min/max box and
  * returns a boolean + hit POSITION + a quantized normal. This one serves the
  * raycast/narrowphase need: the entry distance, the EXACT face normal, `tMax`
  * clamping, and origin-inside handling.

package/src/core/geom/3d/box/box3_raycast.js

@@ -11,7 +11,7 @@
  *    starting INSIDE the box returns its exit face;
  *  - on a miss the function returns `Infinity` and leaves `outNormal` untouched.
  *
- * Distinct from {@link aabb3_raycast}, which takes an arbitrary min/max box and
+ * Distinct from {@link aabb3_raycast_hit_point}, which takes an arbitrary min/max box and
  * returns a boolean + hit POSITION + a quantized normal. This one serves the
  * raycast/narrowphase need: the entry distance, the EXACT face normal, `tMax`
  * clamping, and origin-inside handling.