@woosh/meep-engine 2.35.14 → 2.35.17

package/core/collection/array/typed/uint_array_for_count.js

@@ -0,0 +1,17 @@
+/**
+ *
+ * @param {number} count
+ * @returns {function}
+ */
+export function UintArrayForCount(count) {
+
+    if (count <= 256) {
+        return Uint8Array;
+    } else if (count <= 65536) {
+        return Uint16Array;
+    } else if (count <= 4294967295) {
+        return Uint32Array;
+    } else {
+        throw new Error(`Unsupported size ${count}`)
+    }
+}

package/core/geom/3d/ray/ray3_array_apply_matrix4.js

@@ -0,0 +1,42 @@
+/**
+ *
+ * @param {number[]|ArrayLike<number>|Float32Array} output 6 component vector, [origin_x, origin_y, origin_z, direction_x, direction_y, direction_z]
+ * @param {number[]|ArrayLike<number>|Float32Array} input 6 component vector, [origin_x, origin_y, origin_z, direction_x, direction_y, direction_z]
+ * @param {number[]|ArrayLike<number>|Float32Array} m4 4x4 matrix
+ */
+export function ray3_array_apply_matrix4(output, input, m4) {
+    const origin_x = input[0];
+    const origin_y = input[1];
+    const origin_z = input[2];
+
+    const direction_x = input[3];
+    const direction_y = input[4];
+    const direction_z = input[5];
+
+    // transform ray to local space (inlined for speed)
+    const inv_w = 1 / (m4[3] * origin_x + m4[7] * origin_y + m4[11] * origin_z + m4[15]);
+
+    const out_origin_x = (m4[0] * origin_x + m4[4] * origin_y + m4[8] * origin_z + m4[12]) * inv_w;
+    const out_origin_y = (m4[1] * origin_x + m4[5] * origin_y + m4[9] * origin_z + m4[13]) * inv_w;
+    const out_origin_z = (m4[2] * origin_x + m4[6] * origin_y + m4[10] * origin_z + m4[14]) * inv_w;
+
+    const out_direction_x = m4[0] * direction_x + m4[4] * direction_y + m4[8] * direction_z;
+    const out_direction_y = m4[1] * direction_x + m4[5] * direction_y + m4[9] * direction_z;
+    const out_direction_z = m4[2] * direction_x + m4[6] * direction_y + m4[10] * direction_z;
+
+    // normalize direction
+    const out_direction_magnitude = Math.hypot(out_direction_x, out_direction_y, out_direction_z);
+    const out_direction_magnitude_inverse = 1 / out_direction_magnitude;
+
+    const out_direction_normalized_x = out_direction_x * out_direction_magnitude_inverse;
+    const out_direction_normalized_y = out_direction_y * out_direction_magnitude_inverse;
+    const out_direction_normalized_z = out_direction_z * out_direction_magnitude_inverse;
+
+    output[0] = out_origin_x;
+    output[1] = out_origin_y;
+    output[2] = out_origin_z;
+
+    output[3] = out_direction_normalized_x;
+    output[4] = out_direction_normalized_y;
+    output[5] = out_direction_normalized_z;
+}

package/core/geom/3d/ray/ray3_array_compose.js

@@ -0,0 +1,19 @@
+/**
+ *
+ * @param {number[]|ArrayLike<number>|Float32Array} output
+ * @param {number} origin_x
+ * @param {number} origin_y
+ * @param {number} origin_z
+ * @param {number} direction_x
+ * @param {number} direction_y
+ * @param {number} direction_z
+ */
+export function ray3_array_compose(output, origin_x, origin_y, origin_z, direction_x, direction_y, direction_z) {
+    output[0] = origin_x;
+    output[1] = origin_y;
+    output[2] = origin_z;
+
+    output[3] = direction_x;
+    output[4] = direction_y;
+    output[5] = direction_z;
+}

package/core/geom/3d/ray/ray3_array_compose.spec.js

@@ -0,0 +1,14 @@
+import { ray3_array_compose } from "./ray3_array_compose.js";
+
+test('correctness', () => {
+    const result = [];
+    ray3_array_compose(result, 1, -3, 7, -11, 13, -17);
+
+    expect(result[0]).toBe(1);
+    expect(result[1]).toBe(-3);
+    expect(result[2]).toBe(7);
+
+    expect(result[3]).toBe(-11);
+    expect(result[4]).toBe(13);
+    expect(result[5]).toBe(-17);
+});

package/engine/graphics/ecs/mesh-v2/ShadedGeometrySystem.js

@@ -10,6 +10,8 @@ import { aabb3_intersects_ray } from "../../../../core/bvh2/aabb3/aabb3_intersec
 import { ShadedGeometryRendererContext } from "./render/ShadedGeometryRendererContext.js";
 import { BinaryNode } from "../../../../core/bvh2/BinaryNode.js";
 import { assert } from "../../../../core/assert.js";
+import { ray3_array_compose } from "../../../../core/geom/3d/ray/ray3_array_compose.js";
+import { ray3_array_apply_matrix4 } from "../../../../core/geom/3d/ray/ray3_array_apply_matrix4.js";
 
 /**
  *
@@ -35,6 +37,9 @@ const scratch_point = new SurfacePoint3();
  */
 const scratch_m4 = new Float32Array(16);
 
+const scratch_ray_0 = new Float32Array(6);
+const scratch_ray_1 = new Float32Array(6);
+
 export class ShadedGeometrySystem extends System {
     /**
      *
@@ -332,29 +337,19 @@ export class ShadedGeometrySystem extends System {
                 // get transform in local space
                 mat4.invert(scratch_m4, m4);
 
-                // transform ray to local space
-                const inv_w = 1 / (scratch_m4[3] * origin_x + scratch_m4[7] * origin_y + scratch_m4[11] * origin_z + scratch_m4[15]);
-
-                const local_origin_x = (scratch_m4[0] * origin_x + scratch_m4[4] * origin_y + scratch_m4[8] * origin_z + scratch_m4[12]) * inv_w;
-                const local_origin_y = (scratch_m4[1] * origin_x + scratch_m4[5] * origin_y + scratch_m4[9] * origin_z + scratch_m4[13]) * inv_w;
-                const local_origin_z = (scratch_m4[2] * origin_x + scratch_m4[6] * origin_y + scratch_m4[10] * origin_z + scratch_m4[14]) * inv_w;
-
-                const local_direction_x = scratch_m4[0] * direction_x + scratch_m4[4] * direction_y + scratch_m4[8] * direction_z;
-                const local_direction_y = scratch_m4[1] * direction_x + scratch_m4[5] * direction_y + scratch_m4[9] * direction_z;
-                const local_direction_z = scratch_m4[2] * direction_x + scratch_m4[6] * direction_y + scratch_m4[10] * direction_z;
-
-                const local_direction_magnitude = Math.hypot(local_direction_x, local_direction_y, local_direction_z);
-                const local_direction_magnitude_inverse = 1 / local_direction_magnitude;
+                ray3_array_compose(
+                    scratch_ray_0,
+                    origin_x, origin_y, origin_z,
+                    direction_x, direction_y, direction_z
+                );
 
-                const local_direction_normalized_x = local_direction_x * local_direction_magnitude_inverse;
-                const local_direction_normalized_y = local_direction_y * local_direction_magnitude_inverse;
-                const local_direction_normalized_z = local_direction_z * local_direction_magnitude_inverse;
+                // transform ray to local space
+                ray3_array_apply_matrix4(scratch_ray_0, scratch_ray_0, scratch_m4);
 
-                const geometry_hit_found = GeometrySpatialQueryAccelerator.INSTANCE.queryRaycastNearest_primitive(
+                const geometry_hit_found = GeometrySpatialQueryAccelerator.INSTANCE.queryRaycastNearest_array(
                     scratch_point,
                     sg.geometry,
-                    local_origin_x, local_origin_y, local_origin_z,
-                    local_direction_normalized_x, local_direction_normalized_y, local_direction_normalized_z
+                    scratch_ray_0
                 );
 
                 if (!geometry_hit_found) {
@@ -373,13 +368,12 @@ export class ShadedGeometrySystem extends System {
                     origin_x, origin_y, origin_z
                 );
 
-                if (distance_sqr >= best_distance) {
-                    // further than best found
-                    continue;
+                if (distance_sqr < best_distance) {
+                    contact.copy(scratch_point);
+                    best_result = sg;
+                    best_distance = distance_sqr;
                 }
 
-                contact.copy(scratch_point);
-                best_result = sg;
             }
         }
 

package/engine/graphics/ecs/mesh-v2/sample/prototypeShadedGeometry.js

@@ -22,7 +22,6 @@ import { OrbitingBehavior } from "../../../../../../model/game/util/behavior/Orb
 import { BehaviorSystem } from "../../../../intelligence/behavior/ecs/BehaviorSystem.js";
 import { MicronShadedGeometryRenderAdapter } from "../../../micron/plugin/shaded_geometry/MicronShadedGeometryRenderAdapter.js";
 import { MicronRenderContext } from "../../../micron/render/v1/MicronRenderContext.js";
-import { randomIntegerBetween } from "../../../../../core/math/random/randomIntegerBetween.js";
 
 const eh = new EngineHarness();
 
@@ -102,8 +101,8 @@ async function main(engine) {
         // sg.draw_method = DRAW_METHOD_PLAIN;
         // sg.draw_method = DRAW_METHOD_INSTANCED;
         // sg.draw_method = 2;
-        sg.draw_method = randomIntegerBetween(random, 0, 2);
-        // sg.draw_method = random() > 0.01 ? DRAW_METHOD_INSTANCED : DRAW_METHOD_PLAIN;
+        // sg.draw_method = DRAW_METHOD_INSTANCED;
+        // sg.draw_method = random() > 0.5 ? DRAW_METHOD_INSTANCED : 2;
         sg.clearFlag(ShadedGeometryFlags.CastShadow | ShadedGeometryFlags.ReceiveShadow);
 
         new EntityBuilder()

package/engine/graphics/ecs/mesh-v2/sample/prototype_sg_raycast.js

@@ -0,0 +1,212 @@
+import { EngineHarness } from "../../../../EngineHarness.js";
+import { ShadedGeometrySystem } from "../ShadedGeometrySystem.js";
+import EntityBuilder from "../../../../ecs/EntityBuilder.js";
+import { Transform } from "../../../../ecs/transform/Transform.js";
+import { ShadedGeometry } from "../ShadedGeometry.js";
+import {
+    BoxBufferGeometry,
+    MeshBasicMaterial,
+    MeshStandardMaterial,
+    OctahedronGeometry,
+    SphereBufferGeometry
+} from "three";
+import { randomFloatBetween } from "../../../../../core/math/random/randomFloatBetween.js";
+import { seededRandom } from "../../../../../core/math/random/seededRandom.js";
+import ViewportPosition from "../../../../ecs/gui/position/ViewportPosition.js";
+import GUIElement from "../../../../ecs/gui/GUIElement.js";
+import ButtonView from "../../../../../view/elements/button/ButtonView.js";
+import { downloadAsFile } from "../../../../../core/binary/ByteArrayTools.js";
+import { convert_bvh_to_dot_format_string } from "../../../../../core/bvh2/visual/convert_bvh_to_dot_format_string.js";
+import ViewportPositionSystem from "../../../../ecs/gui/position/ViewportPositionSystem.js";
+import GUIElementSystem from "../../../../ecs/gui/GUIElementSystem.js";
+import Vector3 from "../../../../../core/geom/Vector3.js";
+import Quaternion from "../../../../../core/geom/Quaternion.js";
+import { ShadedGeometryFlags } from "../ShadedGeometryFlags.js";
+import { randomFromArray } from "../../../../../core/math/random/randomFromArray.js";
+import { BehaviorComponent } from "../../../../intelligence/behavior/ecs/BehaviorComponent.js";
+import { OrbitingBehavior } from "../../../../../../model/game/util/behavior/OrbitingBehavior.js";
+import { BehaviorSystem } from "../../../../intelligence/behavior/ecs/BehaviorSystem.js";
+import { MicronShadedGeometryRenderAdapter } from "../../../micron/plugin/shaded_geometry/MicronShadedGeometryRenderAdapter.js";
+import { MicronRenderContext } from "../../../micron/render/v1/MicronRenderContext.js";
+import { randomIntegerBetween } from "../../../../../core/math/random/randomIntegerBetween.js";
+import Vector2 from "../../../../../core/geom/Vector2.js";
+import { SurfacePoint3 } from "../../../../../core/geom/3d/SurfacePoint3.js";
+
+const eh = new EngineHarness();
+
+const DRAW_METHOD_PLAIN = 0;
+const DRAW_METHOD_INSTANCED = 1;
+
+function makeMovingShadedGeometry() {
+    const b = new OrbitingBehavior();
+    b.offset.set(4, 1, 4);
+    b.radius = 2;
+    b.rate = 1;
+
+    const sg = ShadedGeometry.from(new OctahedronGeometry(0.5, 5), new MeshStandardMaterial({ color: 0xFF0000 }));
+
+    sg.draw_method = DRAW_METHOD_INSTANCED;
+
+    return new EntityBuilder()
+        .add(new Transform())
+        .add(sg)
+        .add(BehaviorComponent.fromOne(b));
+}
+
+/**
+ *
+ * @param {Engine} engine
+ */
+async function main(engine) {
+
+    const em = engine.entityManager;
+
+    const sgs = new ShadedGeometrySystem(engine);
+
+    const mrc = new MicronRenderContext();
+    sgs.register_render_adapter(2, () => {
+        const adapter = new MicronShadedGeometryRenderAdapter();
+        adapter.ctx = mrc;
+
+        return adapter;
+    });
+
+    await em.addSystem(sgs);
+    await em.addSystem(new BehaviorSystem(engine));
+
+    EngineHarness.buildBasics({
+        engine,
+        yaw: -0.8,
+        pitch: 1,
+        distance: 46,
+        focus: new Vector3(10, 0, 10)
+    });
+
+
+    const ecd = em.dataset;
+
+    const material = new MeshStandardMaterial({
+        color: 0xFFFFFF,
+        transparent: true,
+        opacity: 0.5
+    });
+
+    // material.visible = false;
+
+    window.material = material;
+
+    const random = seededRandom(0);
+
+    const INSTANCE_COUNT = 100;
+
+    const geometries = [];
+
+    for (let i = 0; i < 1; i++) {
+        geometries.push(new BoxBufferGeometry());
+    }
+
+    for (let i = 0; i < INSTANCE_COUNT; i++) {
+        const geometry = randomFromArray(random, geometries);
+        const sg = ShadedGeometry.from(geometry, material);
+
+        // sg.draw_method = DRAW_METHOD_PLAIN;
+        // sg.draw_method = DRAW_METHOD_INSTANCED;
+        // sg.draw_method = 2;
+        sg.draw_method = randomIntegerBetween(random, 0, 2);
+        // sg.draw_method = random() > 0.01 ? DRAW_METHOD_INSTANCED : DRAW_METHOD_PLAIN;
+        sg.clearFlag(ShadedGeometryFlags.CastShadow | ShadedGeometryFlags.ReceiveShadow);
+
+        new EntityBuilder()
+            .add(Transform.fromJSON({
+                position: {
+                    x: randomFloatBetween(random, 0, 20),
+                    y: randomFloatBetween(random, 0, 10),
+                    z: randomFloatBetween(random, 0, 20)
+                },
+                rotation: Quaternion.random(random),
+                scale: 1
+            }))
+            .add(sg)
+            .build(ecd);
+    }
+
+    // makeMovingShadedGeometry().build(ecd);
+
+    debug_button(engine, () => {
+        const dot = convert_bvh_to_dot_format_string(engine.graphics.layers.getLayerByName('shaded-geometry').bvh);
+        downloadAsFile(dot, 'bvh.dot', 'text');
+
+    }, 'save dot file');
+
+    const raycast_marker = new EntityBuilder()
+        .add(ShadedGeometry.from(new SphereBufferGeometry(1), new MeshBasicMaterial({
+            color: 0xFF0000
+        })))
+        .add(Transform.fromJSON({
+            scale: 0.07
+        }));
+
+    raycast_marker.build(engine.entityManager.dataset);
+
+    engine.devices.pointer.position.onChanged.add((p_x, p_y) => {
+        const p = new Vector2(p_x, p_y);
+        const ndc = new Vector2();
+        const ray_origin = new Vector3();
+        const ray_direction = new Vector3();
+
+        engine.graphics.normalizeViewportPoint(p, ndc);
+        engine.graphics.viewportProjectionRay(ndc.x, ndc.y, ray_origin, ray_direction);
+
+        /**
+         *
+         * @type {ShadedGeometrySystem}
+         */
+        const sgm = engine.entityManager.getSystem(ShadedGeometrySystem);
+
+        const sp = new SurfacePoint3();
+
+        sgm.raycastNearest(sp, ray_origin.x, ray_origin.y, ray_origin.z, ray_direction.x, ray_direction.y, ray_direction.z, ((entity, mesh) => {
+            return (entity !== raycast_marker.entity);
+        }));
+
+        const t = raycast_marker.getComponent(Transform);
+
+        t.position.copy(sp.position);
+    });
+}
+
+
+const entityManager = engine.entityManager;
+
+/**
+ *
+ * @param {Engine} engine
+ * @param {function} action
+ * @param {string} [name]
+ * @param {EntityComponentDataset} ecd
+ */
+function debug_button(engine, action, name = "Button", ecd = entityManager.dataset) {
+    if (entityManager.getSystem(ViewportPositionSystem) === null) {
+        entityManager.addSystem(new ViewportPositionSystem(engine.graphics.viewport.size));
+    }
+
+    if (entityManager.getSystem(GUIElementSystem) === null) {
+        entityManager.addSystem(new GUIElementSystem(engine.gui.view, engine));
+    }
+
+    new EntityBuilder()
+        .add(ViewportPosition.fromJSON({}))
+        .add(GUIElement.fromView(new ButtonView({
+            action,
+            name,
+            css: {
+                background: 'rgba(255,255,255,0.8)',
+                border: '1px solid black',
+                borderRadius: '4px',
+                padding: '2px',
+            }
+        })))
+        .build(ecd);
+}
+
+eh.initialize().then(main);

package/engine/graphics/ecs/path/PathDisplaySystem.js

@@ -125,7 +125,8 @@ class PathDisplayContext extends SystemEntityContext {
             try {
                 builder(spec.style, path, this.system, ownedEntities);
             } catch (e) {
-                console.error(`Failed to build path of type '${spec.type}': ${e}`);
+                console.error(`Failed to build path of type '${spec.type}'`);
+                console.error(e);
             }
         }
 

package/engine/graphics/ecs/path/testPathDisplaySystem.js

@@ -359,14 +359,14 @@ function main(engine) {
 
     const pathDisplay = new PathDisplay();
     pathDisplay.specs.push(
-        PathDisplaySpec.from(
-            PathDisplayType.Ribbon,
-            trailPathStyle
-        ),
-        PathDisplaySpec.from(
-            PathDisplayType.Entity,
-            sample_style_entity()
-        ),
+        // PathDisplaySpec.from(
+        //     PathDisplayType.Ribbon,
+        //     trailPathStyle
+        // ),
+        // PathDisplaySpec.from(
+        //     PathDisplayType.Entity,
+        //     sample_style_entity()
+        // ),
         PathDisplaySpec.from(
             PathDisplayType.Tube,
             sample_style_tube()

package/engine/graphics/ecs/path/tube/CapType.d.ts

@@ -0,0 +1,5 @@
+export enum CapType {
+    None,
+    Flat,
+    Round
+}

package/engine/graphics/ecs/path/tube/CapType.js

@@ -0,0 +1,9 @@
+/**
+ * @readonly
+ * @enum {number}
+ */
+export const CapType = {
+    None: 0,
+    Flat: 1,
+    Round: 2
+};

package/engine/graphics/ecs/path/tube/TubePathStyle.d.ts

@@ -2,6 +2,7 @@ import {Color} from "../../../../../core/color/Color";
 import {TubeMaterialType} from "./TubeMaterialType";
 import {StandardMaterialDefinition} from "./StandardMaterialDefinition";
 import {MatcapMaterialDefinition} from "./MatcapMaterialDefinition";
+import {CapType} from "./CapType";
 
 export class TubePathStyle {
     public color: Color
@@ -14,4 +15,5 @@ export class TubePathStyle {
     public cast_shadow: boolean
     public receive_shadow: boolean
     public path_mask: number[]
+    public cap_type: CapType
 }

package/engine/graphics/ecs/path/tube/TubePathStyle.js

@@ -2,6 +2,7 @@ import { Color } from "../../../../../core/color/Color.js";
 import { TubeMaterialType } from "./TubeMaterialType.js";
 import { assert } from "../../../../../core/assert.js";
 import { MatcapMaterialDefinition } from "./MatcapMaterialDefinition.js";
+import { CapType } from "./CapType.js";
 
 const DEFAULT_COLOR = Object.freeze({ r: 1, g: 1, b: 1 });
 
@@ -71,6 +72,11 @@ export class TubePathStyle {
          * @type {number[]}
          */
         this.path_mask = [0, 1];
+
+        /**
+         * @type {CapType}
+         */
+        this.cap_type = CapType.Flat;
     }
 
     static fromJSON(j) {
@@ -91,7 +97,8 @@ export class TubePathStyle {
                  radial_resolution = 16,
                  cast_shadow = false,
                  receive_shadow = false,
-                 path_mask = [0, 1]
+                 path_mask = [0, 1],
+                 cap_type = CapType.None
              }) {
         assert.enum(material_type, TubeMaterialType, 'material_type');
         assert.isNumber(opacity, 'opacity');
@@ -106,6 +113,7 @@ export class TubePathStyle {
 
         assert.greaterThanOrEqual(path_mask.length, 2, 'path_mask length bust be at least 2');
         assert.ok(path_mask.length % 2 === 0, 'path_mask length bust be multiple of 2');
+        assert.enum(cap_type, CapType, 'cap_type');
 
         if (typeof color === 'string') {
             this.color.parse(color);
@@ -123,6 +131,7 @@ export class TubePathStyle {
         this.receive_shadow = receive_shadow;
 
         this.path_mask = path_mask;
+        this.cap_type = cap_type;
 
         switch (material_type) {
             case TubeMaterialType.Matcap:

package/engine/graphics/ecs/path/tube/build/GeometryOutput.js

@@ -0,0 +1,90 @@
+import { UintArrayForCount } from "../../../../../../core/collection/array/typed/uint_array_for_count.js";
+import { BufferAttribute, BufferGeometry } from "three";
+
+/**
+ * Helper class, allowing us to treat geometry build process as a stream without having to create intermediate arrays and performing unnecessary copying
+ */
+export class GeometryOutput {
+    constructor() {
+        /**
+         *
+         * @type {number}
+         */
+        this.cursor_vertices = 0;
+
+        /**
+         *
+         * @type {number}
+         */
+        this.cursor_indices = 0;
+
+        /**
+         *
+         * @type {Float32Array|number[]|null}
+         * @private
+         */
+        this.__vertex_positions = null;
+        /**
+         *
+         * @type {Float32Array|number[]|null}
+         * @private
+         */
+        this.__vertex_normals = null;
+        /**
+         *
+         * @type {Float32Array|number[]|null}
+         * @private
+         */
+        this.__vertex_uvs = null;
+        /**
+         *
+         * @type {Uint8Array|Uint16Array|Uint32Array|number[]|null}
+         * @private
+         */
+        this.__indices = null;
+    }
+
+    get positions() {
+        return this.__vertex_positions;
+    }
+
+    get normals() {
+        return this.__vertex_normals;
+    }
+
+    get uvs() {
+        return this.__vertex_uvs;
+    }
+
+    get indices() {
+        return this.__indices;
+    }
+
+    /**
+     *
+     * @param {number} vertex_count
+     * @param {number} polygon_count
+     */
+    allocate(vertex_count, polygon_count) {
+        this.__vertex_positions = new Float32Array(vertex_count * 3);
+        this.__vertex_normals = new Float32Array(vertex_count * 3);
+        this.__vertex_uvs = new Float32Array(vertex_count * 2);
+
+        const INDEX_BUFFER_CLASS = UintArrayForCount(vertex_count);
+        this.__indices = new INDEX_BUFFER_CLASS(polygon_count * 3);
+    }
+
+    /**
+     * @returns {THREE.BufferGeometry}
+     */
+    build() {
+        const geometry = new BufferGeometry();
+
+        geometry.setIndex(new BufferAttribute(this.__indices, 1));
+        geometry.setAttribute('position', new BufferAttribute(this.__vertex_positions, 3));
+        geometry.setAttribute('normal', new BufferAttribute(this.__vertex_normals, 3));
+        geometry.setAttribute('uv', new BufferAttribute(this.__vertex_uvs, 2));
+
+        return geometry;
+    }
+}

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

@@ -36,6 +36,7 @@ export function build_geometry_catmullrom(path, style, segment_start, segment_en
 
     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);
@@ -45,7 +46,7 @@ export function build_geometry_catmullrom(path, style, segment_start, segment_en
         added_points++
     }
 
-    if (((i - 1) / (total_points - 1)) - segment_end > 0.0001) {
+    if (segment_end - ((i - 1) / (total_points - 1)) > 0.0001) {
         // end
 
         path.sample_catmull_rom(point, segment_end * path_length);
@@ -57,5 +58,5 @@ export function build_geometry_catmullrom(path, style, segment_start, segment_en
 
     const frames = computeFrenetFrames(points_f32, false);
 
-    return makeTubeGeometry(points_f32, frames.normals, frames.binormals, style.width, style.radial_resolution, false);
+    return makeTubeGeometry(points_f32, frames.normals, frames.binormals, style.width, style.radial_resolution, false, style.cap_type);
 }

package/engine/graphics/ecs/path/tube/build/build_geometry_linear.js

@@ -52,5 +52,5 @@ export function build_geometry_linear(path, style, segment_start, segment_end) {
 
     const frames = computeFrenetFrames(points, false);
 
-    return makeTubeGeometry(points, frames.normals, frames.binormals, style.width, style.radial_resolution, false);
+    return makeTubeGeometry(points, frames.normals, frames.binormals, style.width, style.radial_resolution, false, style.cap_type);
 }