@woosh/meep-engine 2.35.16 → 2.36.1

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);
 }

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

@@ -1,5 +1,4 @@
-import { Vector3 } from "three";
-import { Matrix4 } from "three/src/math/Matrix4.js";
+import { Matrix4, Vector3 } from "three";
 import { max2 } from "../../../../../../core/math/max2.js";
 import { min2 } from "../../../../../../core/math/min2.js";
 import { clamp } from "../../../../../../core/math/clamp.js";