@woosh/meep-engine 2.43.32 → 2.43.34

package/core/geom/3d/line/line3_compute_nearest_point_to_point.js

@@ -0,0 +1,36 @@
+import { v3_dot } from "../../v3_dot.js";
+import { clamp01 } from "../../../math/clamp01.js";
+
+export function line3_compute_nearest_point_to_point(
+    result, result_offset,
+    ax, ay, az,
+    bx, by, bz,
+    ref_x, ref_y, ref_z
+) {
+
+    const direction_x = bx - ax;
+    const direction_y = by - ay;
+    const direction_z = bz - az;
+
+    // find closest point
+    const sp0_x = ref_x - ax;
+    const sp0_y = ref_y - ay;
+    const sp0_z = ref_z - az;
+
+    //
+    const d2 = v3_dot(direction_x, direction_y, direction_z, direction_x, direction_y, direction_z);
+    const d3 = v3_dot(direction_x, direction_y, direction_z, sp0_x, sp0_y, sp0_z);
+
+    const t = d3 / d2;
+
+    const t_clamped = clamp01(t);
+
+    // compute point on the line
+    const lp_x = direction_x * t_clamped + ax;
+    const lp_y = direction_y * t_clamped + ay;
+    const lp_z = direction_z * t_clamped + az;
+
+    result[result_offset + 0] = lp_x;
+    result[result_offset + 1] = lp_y;
+    result[result_offset + 2] = lp_z;
+}

package/core/geom/Quaternion.d.ts

@@ -21,6 +21,8 @@ export default class Quaternion {
     copy(other: ThreeQuaternion): void
     copy(other: { x: number, y: number, z: number, w: number }): void
 
+    clone():Quaternion
+
     equals(other: { x: number, y: number, z: number, w: number }): boolean
 
     slerp(other: Quaternion, t: number): void

package/engine/graphics/render/Lines.js

@@ -0,0 +1,122 @@
+import { DynamicDrawUsage, LineBasicMaterial, LineSegments } from "three";
+import { array_copy } from "../../../core/collection/array/copyArray.js";
+import { BufferGeometry } from "three/src/core/BufferGeometry.js";
+import { Float32BufferAttribute } from "three/src/core/BufferAttribute.js";
+
+function buildGeometry(capacity) {
+    const geometry = new BufferGeometry();
+
+    geometry.dynamic = true;
+    // no index
+
+    const attribute_position = new Float32BufferAttribute(capacity * 3 * 2, 3, false);
+    const attribute_color = new Float32BufferAttribute(capacity * 4 * 2, 4, false);
+
+    attribute_position.setUsage(DynamicDrawUsage);
+    attribute_color.setUsage(DynamicDrawUsage);
+
+    geometry.setAttribute('position', attribute_position);
+    geometry.setAttribute('color', attribute_color);
+
+    return geometry;
+}
+
+export class Lines {
+
+    constructor() {
+        this.count = 0;
+        this.capacity = 64;
+
+        /**
+         *
+         * @type {BufferGeometry|null}
+         */
+        this.geometry = buildGeometry(this.capacity);
+
+        this.mesh = new LineSegments(this.geometry, new LineBasicMaterial());
+
+        // disable automatic culling/updates
+        this.mesh.matrixAutoUpdate = false;
+        this.mesh.frustumCulled = false;
+        this.mesh.matrixWorldNeedsUpdate = false;
+
+    }
+
+    /**
+     *
+     * @param {number} x
+     */
+    setCount(x) {
+        this.ensure_capacity(x);
+
+        this.count = x;
+        this.geometry.drawRange.count = x * 6;
+    }
+
+    /**
+     *
+     * @param {number} x
+     */
+    ensure_capacity(x) {
+        if (this.capacity >= x) {
+            // enough capacity
+            return;
+        }
+
+        this.capacity = x;
+
+        this.build();
+    }
+
+    /**
+     *
+     * @param {vec3} from
+     * @param {vec3} to
+     * @param {vec4} color
+     */
+    add_line(from, to, color) {
+        const index = this.count;
+
+        this.setCount(index + 1);
+
+
+        const position_attribute = this.geometry.getAttribute('position');
+        const color_attribute = this.geometry.getAttribute('color');
+
+        const position_array = position_attribute.array;
+
+        array_copy(from, 0, position_array, index * 6, 3);
+        array_copy(to, 0, position_array, index * 6 + 3, 3);
+
+        const color_array = color_attribute.array;
+
+        array_copy(color, 0, color_array, index * 8, 4);
+        array_copy(color, 0, color_array, index * 8 + 4, 4);
+
+
+        this.geometry.drawRange.count = this.count;
+
+        //
+        position_attribute.needsUpdate = true;
+        color_attribute.needsUpdate = true;
+
+        console.warn('feature not fully implemented');
+    }
+
+    build() {
+
+        const geometry = buildGeometry(this.capacity);
+
+        // TODO copy existing attribute values
+
+        this.geometry = geometry;
+
+        this.mesh.geometry = geometry;
+
+    }
+
+    dispose() {
+        this.geometry.dispose();
+
+    }
+}

package/engine/graphics/render/gizmo/GizmoShapeRenderingInterface.js

@@ -8,6 +8,7 @@ import Quaternion from "../../../../core/geom/Quaternion.js";
 import { makeHelperBoxGeometry } from "../../../../editor/process/symbolic/makeHelperBoxGeometry.js";
 import { DrawMode } from "../../ecs/mesh-v2/DrawMode.js";
 import { makeHelperSphereGeometry } from "../../../../editor/process/symbolic/makeHelperSphereGeometry.js";
+import { Lines } from "../Lines.js";
 
 /**
  *
@@ -55,6 +56,9 @@ export class GizmoShapeRenderingInterface {
         this.__sphere_wire = InstancedMeshGroup.from(makeHelperSphereGeometry(), new LineBasicMaterial());
 
         this.__sphere_wire.draw_mode = DrawMode.Lines;
+
+        // lines are handles different because they are relatively simple and require 2 archor points
+        this.__lines = new Lines();
     }
 
     __get_groups() {
@@ -62,7 +66,8 @@ export class GizmoShapeRenderingInterface {
             this.__boxes_wire,
             this.__boxes_solid,
             this.__sphere_wire,
-            this.__sphere_solid
+            this.__sphere_solid,
+            this.__lines
         ];
     }
 
@@ -131,7 +136,7 @@ export class GizmoShapeRenderingInterface {
      * @param {number[]} to
      */
     draw_line(from, to) {
-        throw new Error('Not Implemented');
+        this.__lines.add_line(from, to, this.__color);
     }
 
 

package/engine/graphics/render/gizmo/prototypeGizmo.js

@@ -0,0 +1,29 @@
+import { EngineHarness } from "../../../EngineHarness.js";
+import { GizmoRenderingPlugin } from "./GizmoRenderingPlugin.js";
+import { Gizmo } from "./Gizmo.js";
+
+const harness = new EngineHarness();
+
+/**
+ *
+ * @param {Engine} engine
+ * @return {Promise<void>}
+ */
+async function main(engine) {
+    await EngineHarness.buildBasics({
+        engine
+    });
+
+
+    engine.graphics.on.preRender.add(()=>{
+       Gizmo.draw_line([0,0,0],[10,10,10]);
+
+       Gizmo.draw_wire_sphere([1,1,1],2);
+    });
+}
+
+harness.initialize({
+    configuration(config, engine) {
+        config.addPlugin(GizmoRenderingPlugin);
+    }
+}).then(main);

package/package.json

@@ -5,7 +5,7 @@
   "productName": "Meep",
   "description": "production-ready JavaScript game engine based on Entity Component System Architecture",
   "author": "Alexander Goldring",
-  "version": "2.43.32",
+  "version": "2.43.34",
   "dependencies": {
     "gl-matrix": "3.4.3",
     "fast-levenshtein": "2.0.6",