@woosh/meep-engine 2.95.1 → 2.97.0

package/src/engine/graphics/ecs/path/tube/build/TubePathBuilder.js

@@ -1,17 +1,17 @@
 import { BufferGeometry, MeshBasicMaterial, MeshMatcapMaterial, MeshStandardMaterial } from "three";
-import { InterpolationType } from "../../../../../navigation/ecs/components/InterpolationType.js";
+import { assert } from "../../../../../../core/assert.js";
+import { m3_rm_compose_transform } from "../../../../../../core/geom/mat3/m3_rm_compose_transform.js";
+import { GameAssetType } from "../../../../../asset/GameAssetType.js";
 import Entity from "../../../../../ecs/Entity.js";
 import { Transform } from "../../../../../ecs/transform/Transform.js";
-import { TubeMaterialType } from "../TubeMaterialType.js";
-import { GameAssetType } from "../../../../../asset/GameAssetType.js";
-import { build_geometry_linear } from "./build_geometry_linear.js";
-import { build_geometry_catmullrom } from "./build_geometry_catmullrom.js";
+import { InterpolationType } from "../../../../../navigation/ecs/components/InterpolationType.js";
 import { ShadedGeometry } from "../../../mesh-v2/ShadedGeometry.js";
 import { ShadedGeometryFlags } from "../../../mesh-v2/ShadedGeometryFlags.js";
-import { fix_shape_normal_order } from "./fix_shape_normal_order.js";
+import { TubeMaterialType } from "../TubeMaterialType.js";
+import { build_geometry_catmullrom } from "./build_geometry_catmullrom.js";
+import { build_geometry_linear } from "./build_geometry_linear.js";
 import { compute_smooth_profile_normals } from "./compute_smooth_profile_normals.js";
-import { assert } from "../../../../../../core/assert.js";
-import { m3_rm_compose_transform } from "../../../../../../core/geom/mat3/m3_rm_compose_transform.js";
+import { fix_shape_normal_order } from "./fix_shape_normal_order.js";
 
 /**
  *
@@ -61,7 +61,7 @@ function make_material(style, am) {
     } else if (material_type === TubeMaterialType.Standard) {
         material_def = new MeshStandardMaterial({
             metalness: style.material.metalness,
-            roughness: style.material.roughness
+            roughness: style.material.roughness,
         });
     } else if (material_type === TubeMaterialType.Matcap) {
 

package/src/engine/graphics/ecs/path/tube/build/build_geometry_catmullrom.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"build_geometry_catmullrom.d.ts","sourceRoot":"","sources":["../../../../../../../../src/engine/graphics/ecs/path/tube/build/build_geometry_catmullrom.js"],"names":[],"mappings":"AAKA;;;;;;;;;;GAUG;AACH,mFAPW,MAAM,EAAE,gBACR,MAAM,EAAE,GAAC,YAAY,mBACrB,MAAM,EAAE,iBACR,MAAM,eACN,MAAM,GACL,MAAM,cAAc,CA4D/B"}
+{"version":3,"file":"build_geometry_catmullrom.d.ts","sourceRoot":"","sources":["../../../../../../../../src/engine/graphics/ecs/path/tube/build/build_geometry_catmullrom.js"],"names":[],"mappings":"AAmFA;;;;;;;;;;GAUG;AACH,mFAPW,MAAM,EAAE,gBACR,MAAM,EAAE,GAAC,YAAY,mBACrB,MAAM,EAAE,iBACR,MAAM,eACN,MAAM,GACL,MAAM,cAAc,CAoI/B"}

package/src/engine/graphics/ecs/path/tube/build/build_geometry_catmullrom.js

@@ -1,7 +1,85 @@
+import { v3_dot } from "../../../../../../core/geom/vec3/v3_dot.js";
+import { clamp } from "../../../../../../core/math/clamp.js";
+import { max2 } from "../../../../../../core/math/max2.js";
+import {
+    computeNonuniformCaltmullRomSplineDerivative
+} from "../../../../../../core/math/spline/computeNonuniformCaltmullRomSplineDerivative.js";
+import { PathNormalType } from "../PathNormalType.js";
 import { computeFrenetFrames } from "./computeFrenetFrames.js";
 import { makeTubeGeometry } from "./makeTubeGeometry.js";
-import Vector3 from "../../../../../../core/geom/Vector3.js";
-import { PathNormalType } from "../PathNormalType.js";
+
+
+const scratch_array_0 = [];
+const scratch_array_1 = [];
+const scratch_array_2 = [];
+const scratch_array_3 = [];
+
+/**
+ *
+ * @param {number[]} positions
+ * @param {number[]} derivatives
+ * @param {number} result_offset
+ * @param {Path} path
+ * @param {number} offset
+ */
+function sample_path(positions, derivatives, result_offset, path, offset) {
+
+
+    if (!path.find_index_and_normalized_distance(scratch_array_0, offset)) {
+        return 0;
+    }
+
+
+    /**
+     *
+     * @type {number}
+     */
+    const i1 = scratch_array_0[0];
+
+    /**
+     *
+     * @type {number}
+     */
+    const t = scratch_array_0[1];
+
+
+    const input_length = path.getPointCount();
+
+    const max_index = input_length - 1;
+
+    const i0 = clamp(i1 - 1, 0, max_index);
+    const i2 = clamp(i1 + 1, 0, max_index);
+    const i3 = clamp(i1 + 2, 0, max_index);
+
+    path.readPositionToArray(i0, scratch_array_0, 0);
+    path.readPositionToArray(i1, scratch_array_1, 0);
+    path.readPositionToArray(i2, scratch_array_2, 0);
+    path.readPositionToArray(i3, scratch_array_3, 0);
+
+    computeNonuniformCaltmullRomSplineDerivative(
+        positions, result_offset,
+        derivatives, result_offset,
+        scratch_array_0, scratch_array_1, scratch_array_2, scratch_array_3,
+        3, t, 0.5
+    );
+
+    // normalize derivative
+    const dx = derivatives[result_offset];
+    const dy = derivatives[result_offset + 1];
+    const dz = derivatives[result_offset + 2];
+
+    const mag = Math.hypot(dx, dy, dz);
+
+    if (mag !== 0) {
+        const inv_mag = 1 / mag;
+
+        derivatives[result_offset] = dx * inv_mag;
+        derivatives[result_offset + 1] = dy * inv_mag;
+        derivatives[result_offset + 2] = dz * inv_mag;
+    }
+
+    return i1;
+}
 
 /**
  *
@@ -25,51 +103,123 @@ export function build_geometry_catmullrom(
     // resample curve
     const total_points = Math.ceil(point_count * style.resolution);
 
-    const path_length = path.length;
+    const reference_step_size = 1 / max2(0.00001, style.resolution);
+    const reference_min_step_size = reference_step_size * 0.25;
 
-    const point = new Vector3();
+    let step_size = reference_step_size;
 
-    const points_f32 = [];
+    const path_length = path.length;
 
+    const sample_positions_f32 = [];
+    const sample_derivatives_f32 = [];
 
     let added_points = 0;
-    let i;
 
     // initial segment
-    path.sample_catmull_rom(point, segment_start * path_length);
-
-    point.writeToArray(points_f32, added_points * 3);
+    let last_knot_index = sample_path(
+        sample_positions_f32,
+        sample_derivatives_f32,
+        added_points * 3,
+        path,
+        segment_start * path_length
+    );
 
     added_points++;
 
-    const max_i = segment_end * (total_points - 1);
-    for (i = Math.ceil(segment_start * total_points + 0.0001); i < max_i; i++) {
-        // TODO initial i value can potentially result in sample being produced before the "segment start"
-        const t = i / (total_points - 1);
-
-        path.sample_catmull_rom(point, path_length * t);
-
-        point.writeToArray(points_f32, added_points * 3);
+    let current_offset = segment_start * path_length;
+
+    let step_resized_direction = 0;
+
+    const absolute_end_offset = segment_end * path_length;
+
+    for (; current_offset < absolute_end_offset; current_offset += step_size) {
+
+
+        const point_address = added_points * 3;
+
+        const knot_index = sample_path(
+            sample_positions_f32,
+            sample_derivatives_f32,
+            point_address,
+            path,
+            current_offset
+        );
+
+        // check difference with previous derivative
+        const previous_point_index = added_points - 1;
+        const previous_point_address = previous_point_index * 3;
+
+        // derivatives are basically normals, and dot product is has Cosine value of angle between two vectors
+        const dot = v3_dot(
+            sample_derivatives_f32[previous_point_address], sample_derivatives_f32[previous_point_address + 1], sample_derivatives_f32[previous_point_address + 2],
+            sample_derivatives_f32[point_address], sample_derivatives_f32[point_address + 1], sample_derivatives_f32[point_address + 2]
+        );
+
+        // angular difference results in larger visual error for longer runs
+        const error_size = (1 - dot) * step_size;
+
+        if (
+            (step_size > reference_min_step_size)
+            && (
+                (
+                    // check if we jumped over a knot, so that we can sample down to get closer to it
+                    knot_index > last_knot_index
+                    && step_size > reference_min_step_size
+                )
+                || (
+                    error_size * 10 > reference_min_step_size
+                    && step_resized_direction <= 0
+                )
+                || (
+                    // check if we're getting too close to the end of the segment, this lets us create a nice end
+                    current_offset + step_size > absolute_end_offset
+                )
+            )
+        ) {
+
+            // step looks to be too large
+            current_offset -= step_size;
+            step_size *= 0.5;
+            step_resized_direction = -1;
+            continue; // retry
+
+        } else if (
+            error_size < 0.02
+            && step_resized_direction >= 0
+        ) {
+
+            // step looks to be too small
+            current_offset -= step_size;
+            step_size *= 2;
+            step_resized_direction = 1;
+            continue; // retry
+
+        }
+
+        // reset adaptive step direction
+        step_resized_direction = 0;
+        // remember the last knot, so we know when we get to the end of the segment
+        last_knot_index = knot_index;
 
         added_points++
     }
 
-    if (segment_end - ((i - 1) / (total_points - 1)) > 0.0001) {
+    if ((absolute_end_offset - current_offset + step_size) > 0.0001) {
         // end
 
-        path.sample_catmull_rom(point, segment_end * path_length);
-
-        point.writeToArray(points_f32, added_points * 3);
+        sample_path(sample_positions_f32, sample_derivatives_f32, added_points * 3, path, absolute_end_offset);
 
         added_points++;
     }
 
+    // console.log(`Total Points ${added_points}`) // DEBUG info
+
     const normal_hint = style.path_normal_type === PathNormalType.FixedStart ? style.path_normal : undefined;
 
-    const frames = computeFrenetFrames(points_f32, false, normal_hint);
+    const frames = computeFrenetFrames(sample_positions_f32, false, normal_hint);
 
     return makeTubeGeometry(
-        points_f32, frames.normals, frames.binormals, frames.tangents,
+        sample_positions_f32, frames.normals, frames.binormals, frames.tangents,
         shape, shape_normal, shape.length / 2, shape_transform, false, style.cap_type
     );
 }

package/src/engine/graphics/ecs/path/tube/prototypeAnimatedPathMask.js

@@ -2,7 +2,7 @@ import FacingDirectionSystem from "../../../../../../../model/game/ecs/system/Fa
 import { makeEngineOptionsModel } from "../../../../../../../model/game/options/makeEngineOptionsModel.js";
 import { enableEditor } from "../../../../../../editor/enableEditor.js";
 import Vector3 from "../../../../../core/geom/Vector3.js";
-import { pingpong } from "../../../../../core/math/pingpong.js";
+import { clamp01 } from "../../../../../core/math/clamp01.js";
 import { computeCatmullRomSpline } from "../../../../../core/math/spline/computeCatmullRomSpline.js";
 import { CanvasView } from "../../../../../view/elements/CanvasView.js";
 import { GameAssetType } from "../../../../asset/GameAssetType.js";
@@ -64,6 +64,7 @@ import { PathDisplaySpec } from "../PathDisplaySpec.js";
 import { PathDisplaySystem } from "../PathDisplaySystem.js";
 import { PathDisplayType } from "../PathDisplayType.js";
 import { RibbonPathStyle } from "../ribbon/RibbonPathStyle.js";
+import { CapType } from "./CapType.js";
 import { MatcapMaterialDefinition } from "./MatcapMaterialDefinition.js";
 import { TubeMaterialType } from "./TubeMaterialType.js";
 import { TubePathStyle } from "./TubePathStyle.js";
@@ -308,6 +309,8 @@ function sample_style_tube() {
     style.material.texture = "data/textures/matcap/nidorx/3E2335_D36A1B_8E4A2E_2842A5.jpg";
 
     style.width = 0.1;
+    style.resolution = 50;
+    style.cap_type = CapType.None;
 
     style.path_mask = [
         0, 1,
@@ -370,7 +373,18 @@ function main(engine) {
     new Entity()
         .add(BehaviorComponent.looping_function((delta) => {
             time += delta * 0.01;
-            tube_style.path_mask[1] = pingpong(time, 1);
+
+            const segment_count = 23;
+
+            tube_style.path_mask = [];
+            for (let i = 0; i < segment_count; i++) {
+                const offset_start = (i / (segment_count - 1) + time) % 1;
+                const offset_end = offset_start + 1 / (segment_count * 1.5);
+
+                tube_style.path_mask.push(
+                    clamp01(offset_start), clamp01(offset_end)
+                );
+            }
 
             path_entity.sendEvent(PathEvents.Changed);
         }))