@woosh/meep-engine 2.95.1 → 2.97.0

package/src/core/math/epsilonEquals.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=epsilonEquals.spec.d.ts.map

package/src/core/math/epsilonEquals.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"epsilonEquals.spec.d.ts","sourceRoot":"","sources":["../../../../src/core/math/epsilonEquals.spec.js"],"names":[],"mappings":""}

package/src/core/math/epsilonEquals.spec.js

@@ -0,0 +1,17 @@
+import { epsilonEquals } from "./epsilonEquals.js";
+
+test("basics", () => {
+
+    expect(epsilonEquals(0, 0, 0)).toBe(true);
+    expect(epsilonEquals(0, 1, 0)).toBe(false);
+    expect(epsilonEquals(1, 0, 0)).toBe(false);
+    expect(epsilonEquals(-1, 0, 0)).toBe(false);
+    expect(epsilonEquals(-1, 1, 0)).toBe(false);
+    expect(epsilonEquals(1, -1, 0)).toBe(false);
+
+    expect(epsilonEquals(1, 1.1, 0)).toBe(false);
+    expect(epsilonEquals(1, 1, 0.1)).toBe(true);
+    expect(epsilonEquals(1, 1.09, 0.1)).toBe(true);
+    expect(epsilonEquals(1, 1.11, 0.1)).toBe(false);
+
+});

package/src/core/math/spline/computeNonuniformCaltmullRomSplineDerivative.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Computes derivative of Catmull Rom spline
+ * @param {number[]} result_value
+ * @param {number} result_value_offset
+ * @param {number[]} result_derivative
+ * @param {number} result_derivative_offset
+ * @param {number[]} p0 spline point 0
+ * @param {number[]} p1 spline point 1
+ * @param {number[]} p2 spline point 2
+ * @param {number[]} p3 spline point 3
+ * @param {number} dimensions number of dimensions in the input and output vectors
+ * @param {number} f between 0..1
+ * @param {number} alpha between 0..1
+ */
+export function computeNonuniformCaltmullRomSplineDerivative(result_value: number[], result_value_offset: number, result_derivative: number[], result_derivative_offset: number, p0: number[], p1: number[], p2: number[], p3: number[], dimensions: number, f: number, alpha: number): void;
+//# sourceMappingURL=computeNonuniformCaltmullRomSplineDerivative.d.ts.map

package/src/core/math/spline/computeNonuniformCaltmullRomSplineDerivative.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"computeNonuniformCaltmullRomSplineDerivative.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/spline/computeNonuniformCaltmullRomSplineDerivative.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH,2EAZW,MAAM,EAAE,uBACR,MAAM,qBACN,MAAM,EAAE,4BACR,MAAM,MACN,MAAM,EAAE,MACR,MAAM,EAAE,MACR,MAAM,EAAE,MACR,MAAM,EAAE,cACR,MAAM,KACN,MAAM,SACN,MAAM,QA2EhB"}

package/src/core/math/spline/computeNonuniformCaltmullRomSplineDerivative.js

@@ -0,0 +1,90 @@
+import { catmull_rom_compute_T } from "./catmull_rom_compute_T.js";
+
+/**
+ * Computes derivative of Catmull Rom spline
+ * @param {number[]} result_value
+ * @param {number} result_value_offset
+ * @param {number[]} result_derivative
+ * @param {number} result_derivative_offset
+ * @param {number[]} p0 spline point 0
+ * @param {number[]} p1 spline point 1
+ * @param {number[]} p2 spline point 2
+ * @param {number[]} p3 spline point 3
+ * @param {number} dimensions number of dimensions in the input and output vectors
+ * @param {number} f between 0..1
+ * @param {number} alpha between 0..1
+ */
+export function computeNonuniformCaltmullRomSplineDerivative(
+    result_value, result_value_offset,
+    result_derivative, result_derivative_offset,
+    p0, p1, p2, p3,
+    dimensions, f, alpha
+) {
+    /*
+    @see https://math.stackexchange.com/questions/843595/how-can-i-calculate-the-derivative-of-a-catmull-rom-spline-with-nonuniform-param
+    @see http://denkovacs.com/2016/02/catmull-rom-spline-derivatives/
+    @see https://en.wikipedia.org/wiki/Centripetal_Catmull%E2%80%93Rom_spline
+     */
+
+    const half_alpha = alpha * 0.5;
+
+    // calculate T
+    const t0 = 0;
+    let t_01 = catmull_rom_compute_T(p0, p1, dimensions, half_alpha);
+    let t_02 = catmull_rom_compute_T(p1, p2, dimensions, half_alpha);
+    let t_03 = catmull_rom_compute_T(p2, p3, dimensions, half_alpha);
+
+    // safety check for repeated points, to prevent division by 0
+    if (t_01 < 1e-4) {
+        t_01 = 1;
+    }
+    if (t_02 < 1e-4) {
+        t_02 = t_01;
+    }
+    if (t_03 < 1e-4) {
+        t_03 = t_02;
+    }
+
+    const t1 = t_01 + t0;
+    const t2 = t_02 + t1;
+    const t3 = t_03 + t2;
+
+    /**
+     * Interpolation between points 1 and 2
+     * @type {number}
+     */
+    const t = t1 * (1 - f) + t2 * f;
+
+    for (let i = 0; i < dimensions; i++) {
+        // read vector values for the dimension
+        const v0 = p0[i];
+        const v1 = p1[i];
+        const v2 = p2[i];
+        const v3 = p3[i];
+
+        const A1 = (t1 - t) / (t1 - t0) * v0 + (t - t0) / (t1 - t0) * v1;
+        const A2 = (t2 - t) / (t2 - t1) * v1 + (t - t1) / (t2 - t1) * v2;
+        const A3 = (t3 - t) / (t3 - t2) * v2 + (t - t2) / (t3 - t2) * v3;
+
+        const B1 = (t2 - t) / (t2 - t0) * A1 + (t - t0) / (t2 - t0) * A2;
+        const B2 = (t3 - t) / (t3 - t1) * A2 + (t - t1) / (t3 - t1) * A3;
+
+        const C = (t2 - t) / (t2 - t1) * B1 + (t - t1) / (t2 - t1) * B2;
+
+        result_value[result_value_offset + i] = C;
+
+        // derivatives
+
+        const dA1 = (v1 - v0) / (t1 - t0)
+        const dA2 = (v2 - v1) / (t2 - t1);
+        const dA3 = (v3 - v2) / (t3 - t2);
+
+        const dB1 = (A2 - A1) / (t2 - t0) + dA1 * (t2 - t) / (t2 - t0) + dA2 * (t - t0) / (t2 - t0);
+        const dB2 = (A3 - A2) / (t3 - t1) + dA2 * (t3 - t) / (t3 - t1) + dA3 * (t - t1) / (t3 - t1);
+
+        const dC = (B2 - B1) / (t2 - t1) + dB1 * (t2 - t) / (t2 - t1) + dB2 * (t - t1) / (t2 - t1);
+
+        result_derivative[result_derivative_offset + i] = dC;
+    }
+
+}

package/src/core/primitives/strings/string_compute_similarity.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Higher value means string are more similar
+ * @type {(function(string, string): number)}
+ */
+export const string_compute_similarity: ((arg0: string, arg1: string) => number);
+//# sourceMappingURL=string_compute_similarity.d.ts.map

package/src/core/primitives/strings/string_compute_similarity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"string_compute_similarity.d.ts","sourceRoot":"","sources":["../../../../../src/core/primitives/strings/string_compute_similarity.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,wCAFU,QAAU,MAAM,QAAE,MAAM,KAAG,MAAM,CAAC,CAEiB"}

package/src/core/primitives/strings/string_compute_similarity.js

@@ -0,0 +1,7 @@
+import { string_jaro_winkler } from "./string_jaro_winkler.js";
+
+/**
+ * Higher value means string are more similar
+ * @type {(function(string, string): number)}
+ */
+export const string_compute_similarity = string_jaro_winkler;

package/src/core/primitives/strings/string_jaro_distance.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Calculate Jaro distance between two strings, this is a measure of string similarity. Higher value means more similarity.
+ * @param {string} first
+ * @param {string} second
+ * @param {number} first_length
+ * @param {number} second_length
+ * @return {number}
+ */
+export function string_jaro_distance(first: string, second: string, first_length: number, second_length: number): number;
+//# sourceMappingURL=string_jaro_distance.d.ts.map

package/src/core/primitives/strings/string_jaro_distance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"string_jaro_distance.d.ts","sourceRoot":"","sources":["../../../../../src/core/primitives/strings/string_jaro_distance.js"],"names":[],"mappings":"AAIA;;;;;;;GAOG;AACH,4CANW,MAAM,UACN,MAAM,gBACN,MAAM,iBACN,MAAM,GACL,MAAM,CAmBjB"}

package/src/core/primitives/strings/string_jaro_distance.js

@@ -0,0 +1,127 @@
+import { BitSet } from "../../binary/BitSet.js";
+import { max2 } from "../../math/max2.js";
+import { min2 } from "../../math/min2.js";
+
+/**
+ * Calculate Jaro distance between two strings, this is a measure of string similarity. Higher value means more similarity.
+ * @param {string} first
+ * @param {string} second
+ * @param {number} first_length
+ * @param {number} second_length
+ * @return {number}
+ */
+export function string_jaro_distance(
+    first, second,
+    first_length, second_length
+) {
+
+    const matches1 = BitSet.fixedSize(first_length);
+    const matches2 = BitSet.fixedSize(second_length);
+
+    const matches = getMatching(first, second, matches1, matches2);
+
+    if (matches <= 0) {
+        return 0;
+    }
+
+    const transpositions = getTranspositions(first, second, matches1, matches2);
+    return (matches / first_length + matches / second_length + (matches - transpositions) / matches) / 3;
+
+}
+
+/**
+ * Find matching characters in both strings according to Jaro algorithm
+ * @param {string} a1
+ * @param {string} a2
+ * @param {BitSet} matches1
+ * @param {BitSet} matches2
+ * @return {number}
+ */
+function getMatching(a1, a2, matches1, matches2) {
+    const a1_length = a1.length;
+    const a2_length = a2.length;
+
+    // Window is modified to work with string of length 1
+    const matchWindow = max2(
+        0,
+        Math.floor(max2(a1_length, a2_length) * 0.5) - 1
+    );
+
+    let matches = 0;
+
+    // Loop to find matched characters:
+    for (let index1 = 0; index1 < a1_length; index1++) {
+
+        // Use the highest of the window diff and the min of the window and string 2 length:
+        const start = max2(0, index1 - matchWindow);
+        const end = min2(index1 + matchWindow + 1, a2_length);
+
+        // Iterate second string index:
+        for (let index2 = start; index2 < end; index2++) {
+
+            // If second string character already matched, skip:
+            if (matches2.get(index2)) {
+                continue;
+            }
+
+            // If the characters don't match, skip:
+            if (a1.charAt(index1) !== a2.charAt(index2)) {
+                continue;
+            }
+
+            // Assume match if the above 2 checks don't continue:
+            matches1.set(index1, true);
+            matches2.set(index2, true);
+
+            // Add matches by 1, break inner loop:
+            ++matches;
+            break;
+        }
+    }
+
+    return matches;
+}
+
+/**
+ * Calculate the number of transpositions between the two words
+ * @param {string} a1 The first string to compare
+ * @param {string} a2 The second string to compare
+ * @param {BitSet} matches1
+ * @param {BitSet} matches2
+ * @returns {number}
+ */
+function getTranspositions(
+    a1, a2,
+    matches1, matches2
+) {
+    let transpositions = 0;
+
+    // Loop to find transpositions:
+    const a1_length = a1.length;
+    const a2_length = a2.length;
+
+    for (let i1 = 0, i2 = 0; i1 < a1_length; i1++) {
+        // If a non-matching character was found, skip:
+        if (matches1.get(i1) === false) {
+            continue;
+        }
+
+        // Move i2 index to the next match:
+        while (
+            i2 < a2_length
+            && matches2.get(i2) === false
+            ) {
+            i2++;
+        }
+
+        // If the characters don't match, increase transposition:
+        if (a1.charAt(i1) !== a2.charAt(i2)) {
+            transpositions++;
+        }
+
+        // Iterate i2 index normally:
+        i2++;
+    }
+
+    return Math.floor(transpositions * 0.5);
+}

package/src/core/primitives/strings/string_jaro_winkler.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Calculate the Jaro-Winkler distance between two strings
+ * @param {string} first The string to compare
+ * @param {string} second The string to compare with
+ * @returns {number} similarity score, higher value means strings are more similar
+ */
+export function string_jaro_winkler(first: string, second: string): number;
+//# sourceMappingURL=string_jaro_winkler.d.ts.map

package/src/core/primitives/strings/string_jaro_winkler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"string_jaro_winkler.d.ts","sourceRoot":"","sources":["../../../../../src/core/primitives/strings/string_jaro_winkler.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,2CAJW,MAAM,UACN,MAAM,GACJ,MAAM,CAwBlB"}

package/src/core/primitives/strings/string_jaro_winkler.js

@@ -0,0 +1,53 @@
+import { min3 } from "../../math/min3.js";
+import { string_jaro_distance } from "./string_jaro_distance.js";
+
+/**
+ * Calculate the Jaro-Winkler distance between two strings
+ * @param {string} first The string to compare
+ * @param {string} second The string to compare with
+ * @returns {number} similarity score, higher value means strings are more similar
+ */
+export function string_jaro_winkler(first, second) {
+    const l1 = first.length;
+    const l2 = second.length;
+
+    if (l1 === 0 && l2 === 0) {
+        // special case for empty string
+        return 1;
+    }
+
+    // Calculate the Jaro distance:
+    const similarity = string_jaro_distance(first, second, l1, l2);
+
+    if (similarity === 0) {
+        // no similarity at all
+        return 0;
+    }
+
+    // Transform to Jaro-Winkler:
+    // Prefix scale gives more favorable ratings to strings that share common prefixes:
+    const prefix_scale = 0.1;
+    const prefix = getPrefix(first, second, min3(l1, l2, 4));
+    return similarity + prefix * prefix_scale * (1 - similarity);
+}
+
+/**
+ * Counts the number of common characters at the beginning
+ * of each word up to a maximum of 4
+ * @param {string} a1 The first string to compare
+ * @param {string} a2 The second string to compare
+ * @param {number} character_limit
+ * @returns {number}
+ */
+function getPrefix(a1, a2, character_limit) {
+
+    let p = 0;
+
+    for (; p < character_limit; p++) {
+        if (a1.charAt(p) !== a2.charAt(p)) {
+            return p;
+        }
+    }
+
+    return ++p;
+}

package/src/core/primitives/strings/string_jaro_winkler.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=string_jaro_winkler.spec.d.ts.map

package/src/core/primitives/strings/string_jaro_winkler.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"string_jaro_winkler.spec.d.ts","sourceRoot":"","sources":["../../../../../src/core/primitives/strings/string_jaro_winkler.spec.js"],"names":[],"mappings":""}

package/src/core/primitives/strings/string_jaro_winkler.spec.js

@@ -0,0 +1,39 @@
+import { string_jaro_winkler } from "./string_jaro_winkler.js";
+
+test("empty strings", () => {
+
+    expect(string_jaro_winkler("", "")).toBe(1)
+
+});
+
+test("whitespace", () => {
+    expect(string_jaro_winkler(" ", " ")).toBe(1);
+
+    expect(string_jaro_winkler("\n", "\n")).toBe(1);
+    expect(string_jaro_winkler("\t", "\t")).toBe(1);
+
+    expect(string_jaro_winkler("  ", " ")).toBeGreaterThan(0);
+});
+
+test("negative cases", () => {
+
+
+    expect(string_jaro_winkler("a", "")).toBe(0);
+    expect(string_jaro_winkler("", "a")).toBe(0);
+
+    expect(string_jaro_winkler("a", "b")).toBe(0);
+    expect(string_jaro_winkler("b", "a")).toBe(0);
+
+});
+
+test("known cases", () => {
+
+
+    expect(string_jaro_winkler("a", "a")).toBeCloseTo(1);
+    expect(string_jaro_winkler("aa", "aa")).toBeCloseTo(1);
+    expect(string_jaro_winkler("abc", "abc")).toBeCloseTo(1);
+
+    expect(string_jaro_winkler("DwAyNE", "DuANE")).toBeCloseTo(0.84);
+    expect(string_jaro_winkler("TRATE", "TRACE")).toBeCloseTo(0.906667);
+
+});

package/src/engine/graphics/ecs/mesh/SkeletonUtils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SkeletonUtils.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/ecs/mesh/SkeletonUtils.js"],"names":[],"mappings":"AAMA;;;;;GAKG;AACH,2DAHW,MAAM,GACJ,UAAU,GAAG,IAAI,CAiD7B;AAiCD;;;;GAIG;AACH,mEAFa,WAAS,SAAS,CAgB9B;AAED;;;;;GAKG;AACH,qEAHW,yBAAuB,GACtB,IAAI,GAAC,IAAI,CAkCpB;AAED;;;;;GAKG;AACH,iEAHW,yBAAuB,GACrB,IAAI,GAAG,IAAI,CAUvB;AAGD;;;;;GAKG;AACH,0EAFa,IAAI,GAAG,IAAI,CA+BvB;AAID;;;;;GAKG;AACH,sEAFa,IAAI,GAAG,IAAI,CA8BvB;qBAlPoB,OAAO"}
+{"version":3,"file":"SkeletonUtils.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/ecs/mesh/SkeletonUtils.js"],"names":[],"mappings":"AAOA;;;;;GAKG;AACH,2DAHW,MAAM,GACJ,UAAU,GAAG,IAAI,CAuC7B;AAiCD;;;;GAIG;AACH,mEAFa,WAAS,SAAS,CAgB9B;AAED;;;;;GAKG;AACH,qEAHW,yBAAuB,GACtB,IAAI,GAAC,IAAI,CAkCpB;AAED;;;;;GAKG;AACH,iEAHW,yBAAuB,GACrB,IAAI,GAAG,IAAI,CAUvB;AAGD;;;;;GAKG;AACH,0EAFa,IAAI,GAAG,IAAI,CA+BvB;AAID;;;;;GAKG;AACH,sEAFa,IAAI,GAAG,IAAI,CA8BvB;qBA1OoB,OAAO"}

package/src/engine/graphics/ecs/mesh/SkeletonUtils.js

@@ -1,7 +1,8 @@
-import { distance as levenshtein_distance } from "fastest-levenshtein";
 import { Bone } from "three";
-import { BoneMapping } from "./skeleton/BoneMapping.js";
+import { arrayPickBestElement } from "../../../../core/collection/array/arrayPickBestElement.js";
+import { string_compute_similarity } from "../../../../core/primitives/strings/string_compute_similarity.js";
 import { extractName } from "../../../../extractName.js";
+import { BoneMapping } from "./skeleton/BoneMapping.js";
 
 
 /**
@@ -42,20 +43,10 @@ export function getSkeletonBone(component, boneName) {
     //bone not found
 
     //try to find similar bones
-    const similarities = bones.map(function (bone) {
-        const distance = levenshtein_distance(bone.name, boneName);
-        return {
-            bone: bone,
-            distance: distance
-        };
+    const bestMatch = arrayPickBestElement(bones, function (bone) {
+        return string_compute_similarity(bone.name, boneName);
     });
 
-    similarities.sort(function (a, b) {
-        return a.distance - b.distance;
-    });
-
-    const bestMatch = similarities[0].bone;
-
     throw  new Error("Bone '" + boneName + "' not found, did you mean '" + bestMatch.name + "'");
 }
 

package/src/engine/graphics/ecs/mesh/skeleton/BoneMapping.js

@@ -1,7 +1,7 @@
-import { HumanoidBoneType } from "./HumanoidBoneType.js";
-import { distance as levenshtein_distance } from "fastest-levenshtein";
 import { assert } from "../../../../../core/assert.js";
 import { string_compute_common_prefix } from "../../../../../core/primitives/strings/string_compute_common_prefix.js";
+import { string_compute_similarity } from "../../../../../core/primitives/strings/string_compute_similarity.js";
+import { HumanoidBoneType } from "./HumanoidBoneType.js";
 
 
 /**
@@ -40,7 +40,7 @@ export class BoneMapping {
         boneValues.forEach(function (boneName, boneIndex) {
 
             conditionedNames.forEach(function (name, inputIndex) {
-                const distance = levenshtein_distance(name, boneName);
+                const distance = string_compute_similarity(name, boneName);
                 const match = {
                     boneIndex,
                     inputIndex,

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

@@ -1,3 +1,4 @@
+import { MeshStandardMaterial, OctahedronBufferGeometry } from "three";
 import '../../../../../../../../css/game.scss';
 import FacingDirectionSystem from "../../../../../../model/game/ecs/system/FacingDirectionSystem.js";
 import { makeEngineOptionsModel } from "../../../../../../model/game/options/makeEngineOptionsModel.js";
@@ -47,6 +48,7 @@ import Highlight from "../highlight/Highlight.js";
 import MeshHighlightSystem from "../highlight/system/MeshHighlightSystem.js";
 import { ShadedGeometryHighlightSystem } from "../highlight/system/ShadedGeometryHighlightSystem.js";
 import LightSystem from "../light/LightSystem.js";
+import { ShadedGeometry } from "../mesh-v2/ShadedGeometry.js";
 import { ShadedGeometrySystem } from "../mesh-v2/ShadedGeometrySystem.js";
 import Mesh from "../mesh/Mesh.js";
 import { MeshSystem } from "../mesh/MeshSystem.js";
@@ -412,7 +414,35 @@ function makePath({
     return new Entity()
         .add(_p)
         .add(pathDisplay)
-        .add(Highlight.fromOne(0, 1, 1, 1));
+    // .add(Highlight.fromOne(0, 1, 1, 1));
+
+}
+
+/**
+ *
+ * @param {Path} path
+ * @param {EntityComponentDataset} ecd
+ */
+function drawControlPoints(path, ecd) {
+
+    const point_count = path.getPointCount();
+
+    const geo = new OctahedronBufferGeometry(1, 3);
+    const mat = new MeshStandardMaterial({});
+
+    for (let i = 0; i < point_count; i++) {
+        const t = new Transform();
+
+        t.scale.setScalar(0.4);
+
+        path.getPosition(i, t.position);
+
+        new Entity()
+            .add(t)
+            .add(ShadedGeometry.from(geo, mat))
+            .build(ecd)
+    }
+
 
 }
 
@@ -424,18 +454,120 @@ function main(engine) {
     const cam = ecd.getAnyComponent(Camera);
     // cam.component.projectionType.set(ProjectionType.Orthographic);
 
+    const points = [
+        84,
+        20,
+        100,
+        68.36000061035156,
+        5.840000152587891,
+        31.1200008392334,
+        69.01000213623047,
+        8,
+        24.020000457763672,
+        88.19000244140625,
+        35,
+        22.729999542236328,
+        114.80999755859375,
+        35,
+        10.970000267028809,
+        71,
+        35,
+        -69.01000213623047,
+        -31.809999465942383,
+        25,
+        -27.850000381469727,
+        -11.130000114440918,
+        25,
+        30.770000457763672,
+        20.75,
+        25,
+        6.539999961853027,
+        13.0600004196167,
+        25,
+        -6.28000020980835,
+        7.75,
+        17.760000228881836,
+        14.109999656677246,
+        4.260000228881836,
+        10.529999732971191,
+        8.869999885559082,
+        -5.96999979019165,
+        8.079999923706055,
+        -2.180000066757202,
+        -5.369999885559082,
+        6.059999942779541,
+        -12.010000228881836,
+        -9.359999656677246,
+        6.059999942779541,
+        -12.369999885559082,
+        -10.579999923706055,
+        4.789999961853027,
+        -15.300000190734863,
+        -9.130000114440918,
+        4.639999866485596,
+        -16.350000381469727,
+        -9.119999885559082,
+        4.639999866485596,
+        -16.360000610351562,
+        -9.109999656677246,
+        4.639999866485596,
+        -16.360000610351562,
+        -9.100000381469727,
+        4.630000114440918,
+        -16.360000610351562,
+        -4.429999828338623,
+        5,
+        -9.720000267028809,
+        -7.309999942779541,
+        5,
+        6.059999942779541,
+        -4.170000076293945,
+        0.1599999964237213,
+        10.720000267028809,
+        -1.4600000381469727,
+        0.1599999964237213,
+        12.109999656677246,
+        -0.4399999976158142,
+        0.1599999964237213,
+        19.25,
+        0.5099999904632568,
+        0.1599999964237213,
+        21.65999984741211,
+        2,
+        0.1599999964237213,
+        21.56999969482422,
+        7.880000114440918,
+        2.859999895095825,
+        21.610000610351562,
+        12.039999961853027,
+        2.859999895095825,
+        21.860000610351562,
+        14.369999885559082,
+        3.2100000381469727,
+        21.760000228881836,
+        14.1899995803833,
+        4.440000057220459,
+        25.639999389648438,
+        14.130000114440918,
+        5.53000020980835,
+        29.149999618530273,
+        15.15999984741211,
+        7.159999847412109,
+        29.899999618530273,
+        19.540000915527344,
+        700,
+        51.060001373291016
+    ];
+
     makePath({
-        points: [
-            3, 1, 1,
-            3, 1, 3,
-            7, 1, 3,
-            7, 1, 7,
-            3, 1, 7,
-            3, 1, 8
-        ],
-        interp: InterpolationType.Linear
+        points: points,
+        interp: InterpolationType.CatmullRom
     }).build(ecd);
 
+    drawControlPoints(Path.fromJSON({
+        points
+    }), ecd);
+
     makePath({
         points: [
             17.600000381469727, 3.2100000381469727, -16.34000015258789,

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

@@ -1 +1 @@
-{"version":3,"file":"TubePathBuilder.d.ts","sourceRoot":"","sources":["../../../../../../../../src/engine/graphics/ecs/path/tube/build/TubePathBuilder.js"],"names":[],"mappings":"AAoFA;IAEQ;;;OAGG;IACH,OAFU,gBAAc,IAAI,CAEX;IAEjB;;;OAGG;IACH,MAFU,OAAK,IAAI,CAEH;IAEhB;;;OAGG;IACH,WAFU,kBAAgB,IAAI,CAET;IAErB;;;OAGG;IACH,cAFU,eAAa,IAAI,CAEH;IAG5B,yBAEC;IAED,2BAEC;IAED,2BAEC;IAED,yCAEC;IAED;;;OAGG;IACH,mBAFW,MAAM,EAAE,QAyElB;CACJ;mBAzMkB,8BAA8B"}
+{"version":3,"file":"TubePathBuilder.d.ts","sourceRoot":"","sources":["../../../../../../../../src/engine/graphics/ecs/path/tube/build/TubePathBuilder.js"],"names":[],"mappings":"AAoFA;IAEQ;;;OAGG;IACH,OAFU,gBAAc,IAAI,CAEX;IAEjB;;;OAGG;IACH,MAFU,OAAK,IAAI,CAEH;IAEhB;;;OAGG;IACH,WAFU,kBAAgB,IAAI,CAET;IAErB;;;OAGG;IACH,cAFU,eAAa,IAAI,CAEH;IAG5B,yBAEC;IAED,2BAEC;IAED,2BAEC;IAED,yCAEC;IAED;;;OAGG;IACH,mBAFW,MAAM,EAAE,QAyElB;CACJ;mBAvMkB,8BAA8B"}