@needle-tools/engine 4.8.8 → 4.8.9-next.5e888f7

package/src/engine-components/OrbitControls.ts

@@ -889,6 +889,8 @@ export class OrbitControls extends Behaviour implements ICameraController {
             }
             else this._fovLerpDuration = this.targetLerpDuration;
         }
+
+        // if (this.context.mainCameraComponent) this.context.mainCameraComponent.fieldOfView = fov;
     }
 
     /** Moves the camera look-at target to a position smoothly. 
@@ -984,22 +986,22 @@ export class OrbitControls extends Behaviour implements ICameraController {
     */
     fitCamera(options?: FitCameraOptions);
     fitCamera(objects?: Object3D | Array<Object3D>, options?: Omit<FitCameraOptions, "objects">);
-    fitCamera(objectsOrOptions?: Object3D | Array<Object3D> | FitCameraOptions, options?: FitCameraOptions) {
+    fitCamera(objectsOrOptions?: Object3D | Array<Object3D> | FitCameraOptions, options?: FitCameraOptions): void {
 
         if (this.context.isInXR) {
             // camera fitting in XR is not supported
+            console.warn('[OrbitControls] Can not fit camera while XR session is active');
             return;
         }
 
         let objects: Object3D | Array<Object3D> | undefined = undefined;
-
         // If the user passed in an array as first argument
         if (Array.isArray(objectsOrOptions)) {
             objects = objectsOrOptions;
         }
         // If the user passed in an object as first argument
         else if (objectsOrOptions && "type" in objectsOrOptions) {
-            objects = objectsOrOptions.children;
+            objects = objectsOrOptions;
         }
         // If the user passed in an object as first argument and options as second argument
         else if (objectsOrOptions && typeof objectsOrOptions === "object") {
@@ -1008,12 +1010,10 @@ export class OrbitControls extends Behaviour implements ICameraController {
                 objects = options.objects;
             }
         }
-
         // Ensure objects are setup correctly
         if (objects && !Array.isArray(objects)) {
-            objects = objects.children;
+            objects = [objects];
         }
-
         if (!Array.isArray(objects) || objects && objects.length <= 0) {
             objects = this.context.scene.children;
         }
@@ -1032,7 +1032,7 @@ export class OrbitControls extends Behaviour implements ICameraController {
             return;
         }
         if (!options) options = {}
-        const { immediate = false, centerCamera = "y", cameraNearFar = "auto", fitOffset = 1.1, fov = camera?.fov } = options;
+        const { immediate = false, centerCamera, cameraNearFar = "auto", fitOffset = 1.1, fov = camera?.fov } = options;
         const size = new Vector3();
         const center = new Vector3();
         // TODO would be much better to calculate the bounds in camera space instead of world space - 
@@ -1041,15 +1041,13 @@ export class OrbitControls extends Behaviour implements ICameraController {
         // and thus we're just getting some maximum that will work for sure.
         const box = getBoundingBox(objects, undefined, this._camera?.threeCamera?.layers);
         const boxCopy = box.clone();
-
-        camera.updateMatrixWorld();
-        camera.updateProjectionMatrix();
         box.getCenter(center);
 
         const box_size = new Vector3();
         box.getSize(box_size);
 
         // project this box into camera space
+        camera.updateMatrixWorld();
         box.applyMatrix4(camera.matrixWorldInverse);
 
         box.getSize(size);
@@ -1078,9 +1076,18 @@ export class OrbitControls extends Behaviour implements ICameraController {
         this.minZoom = distance * 0.01;
 
         const verticalOffset = 0.05;
-
         const lookAt = center.clone();
         lookAt.y -= size.y * verticalOffset;
+        if (options.targetOffset) {
+            if (options.targetOffset.x !== undefined) lookAt.x += options.targetOffset.x;
+            if (options.targetOffset.y !== undefined) lookAt.y += options.targetOffset.y;
+            if (options.targetOffset.z !== undefined) lookAt.z += options.targetOffset.z;
+        }
+        if (options.relativeTargetOffset) {
+            if (options.relativeTargetOffset.x !== undefined) lookAt.x += options.relativeTargetOffset.x * size.x;
+            if (options.relativeTargetOffset.y !== undefined) lookAt.y += options.relativeTargetOffset.y * size.y;
+            if (options.relativeTargetOffset.z !== undefined) lookAt.z += options.relativeTargetOffset.z * size.z;
+        }
         this.setLookTargetPosition(lookAt, immediate);
         this.setFieldOfView(options.fov, immediate);
 
@@ -1092,6 +1099,7 @@ export class OrbitControls extends Behaviour implements ICameraController {
             // TODO: this doesnt take the Camera component nearClipPlane into account
             camera.near = (distance / 100);
             camera.far = boundsMax + distance * 10;
+            camera.updateProjectionMatrix();
 
             // adjust maxZoom so that the ground projection radius is always inside
             if (groundprojection) {
@@ -1104,12 +1112,13 @@ export class OrbitControls extends Behaviour implements ICameraController {
         if (currentZoom < this.minZoom) this.minZoom = currentZoom * 0.9;
         if (currentZoom > this.maxZoom) this.maxZoom = currentZoom * 1.1;
 
-        camera.updateMatrixWorld();
-        camera.updateProjectionMatrix();
-
-        const cameraWp = getWorldPosition(camera);
         const direction = center.clone();
-        direction.sub(cameraWp);
+        if (options.fitDirection) {
+            direction.sub(new Vector3().copy(options.fitDirection).multiplyScalar(1_000_000));
+        }
+        else {
+            direction.sub(camera.worldPosition);
+        }
         if (centerCamera === "y")
             direction.y = 0;
         direction.normalize();
@@ -1118,6 +1127,16 @@ export class OrbitControls extends Behaviour implements ICameraController {
             direction.y += -verticalOffset * 4 * distance;
 
         let cameraLocalPosition = center.clone().sub(direction);
+        if (options.cameraOffset) {
+            if (options.cameraOffset.x !== undefined) cameraLocalPosition.x += options.cameraOffset.x;
+            if (options.cameraOffset.y !== undefined) cameraLocalPosition.y += options.cameraOffset.y;
+            if (options.cameraOffset.z !== undefined) cameraLocalPosition.z += options.cameraOffset.z;
+        }
+        if (options.relativeCameraOffset) {
+            if (options.relativeCameraOffset.x !== undefined) cameraLocalPosition.x += options.relativeCameraOffset.x * size.x;
+            if (options.relativeCameraOffset.y !== undefined) cameraLocalPosition.y += options.relativeCameraOffset.y * size.y;
+            if (options.relativeCameraOffset.z !== undefined) cameraLocalPosition.z += options.relativeCameraOffset.z * size.z;
+        }
         if (camera.parent) {
             cameraLocalPosition = camera.parent.worldToLocal(cameraLocalPosition);
         }
@@ -1154,7 +1173,7 @@ export class OrbitControls extends Behaviour implements ICameraController {
 /**
  * Options for fitting the camera to the scene. Used in {@link OrbitControls.fitCamera}
  */
-declare type FitCameraOptions = {
+export type FitCameraOptions = {
     /** When enabled debug rendering will be shown */
     debug?: boolean,
     /**
@@ -1166,14 +1185,41 @@ declare type FitCameraOptions = {
      */
     immediate?: boolean,
 
+    /** Fit offset: A factor to multiply the distance to the objects by
+     * @default 1.1
+     */
+    fitOffset?: number,
+
+    /** The direction from which the camera should be fitted in worldspace. If not defined the current camera's position will be used */
+    fitDirection?: Vector3Like,
+
     /** If set to "y" the camera will be centered in the y axis */
     centerCamera?: "none" | "y",
+    /** Set to 'auto' to update the camera near or far plane based on the fitted-objects bounds */
     cameraNearFar?: "keep" | "auto",
 
-    fov?: number,
+    /**
+     * Offset the camera position in world space
+     */
+    cameraOffset?: Partial<Vector3Like>,
+    /**
+     * Offset the camera position relative to the size of the objects being focused on (e.g. x: 0.5).  
+     * Value range: -1 to 1
+     */
+    relativeCameraOffset?: Partial<Vector3Like>,
 
-    /** Fit offset: A factor to multiply the distance to the objects by
-     * @default 1.1
+    /**
+     * Offset the camera target position in world space
      */
-    fitOffset?: number,
+    targetOffset?: Partial<Vector3Like>,
+    /**
+     * Offset the camera target position relative to the size of the objects being focused on.  
+     * Value range: -1 to 1
+     */
+    relativeTargetOffset?: Partial<Vector3Like>,
+
+    /**
+     * Field of view (FOV) for the camera
+     */
+    fov?: number,
 }

package/src/engine-components/Renderer.ts

@@ -706,7 +706,8 @@ export class Renderer extends Behaviour implements IRenderer {
         }
 
         if (this.reflectionProbeUsage !== ReflectionProbeUsage.Off && this._reflectionProbe) {
-            this._reflectionProbe.onSet(this);
+            if (!this._lightmaps?.length) // Currently reflectionprobes cant be used with lightmaps
+                this._reflectionProbe.onSet(this);
         }
         // since three 163 we need to set the envMap to the scene envMap if it is not set
         // otherwise the envmapIntensity has no effect: https://github.com/mrdoob/three.js/pull/27903

package/src/engine-components/Skybox.ts

@@ -48,21 +48,20 @@ function createRemoteSkyboxComponent(context: IContext, url: string, skybox: boo
 const promises = new Array<Promise<any>>();
 ContextRegistry.registerCallback(ContextEvent.ContextCreationStart, (args) => {
     const context = args.context;
-    const skyboxImage = context.domElement.getAttribute("background-image");
+    const backgroundImage = context.domElement.getAttribute("background-image");
     const environmentImage = context.domElement.getAttribute("environment-image");
-    const envAndSkyboxAreSame = skyboxImage === environmentImage;
-
-    if (skyboxImage && !envAndSkyboxAreSame) {
-        if (debug) console.log("Creating remote skybox to load " + skyboxImage);
+    
+    if (backgroundImage) {
+        if (debug) console.log("Creating RemoteSkybox to load background " + backgroundImage);
         // if the user is loading a GLB without a camera then the CameraUtils (which creates the default camera)
         // checks if we have this attribute set and then sets the skybox clearflags accordingly
         // if the user has a GLB with a camera but set to solid color then the skybox image is not visible -> we will just warn then and not override the camera settings
-        const promise = createRemoteSkyboxComponent(context, skyboxImage, true, false, "background-image");
+        const promise = createRemoteSkyboxComponent(context, backgroundImage, true, false, "background-image");
         if (promise) promises.push(promise);
     }
     if (environmentImage) {
-        if (debug) console.log("Creating remote environment to load " + environmentImage);
-        const promise = createRemoteSkyboxComponent(context, environmentImage, envAndSkyboxAreSame, true, "environment-image");
+        if (debug) console.log("Creating RemoteSkybox to load environment " + environmentImage);
+        const promise = createRemoteSkyboxComponent(context, environmentImage, false, true, "environment-image");
         if (promise) promises.push(promise);
     }
 });
@@ -200,7 +199,7 @@ export class RemoteSkybox extends Behaviour {
             console.warn("Potentially invalid skybox URL: \"" + name + "\" on " + (this.name || this.gameObject?.name || "context"));
         }
 
-        if (debug) console.log("Set remote skybox url: " + url);
+        if (debug) console.log("Set RemoteSkybox url: " + url);
 
         if (this._prevUrl === url && this._prevLoadedEnvironment) {
             this.apply();
@@ -258,7 +257,7 @@ export class RemoteSkybox extends Behaviour {
             this._prevBackground = this.context.scene.background;
         if (this.context.scene.environment !== envMap)
             this._prevEnvironment = this.context.scene.environment;
-        if (debug) console.log("Set remote skybox", this.url, !Camera.backgroundShouldBeTransparent(this.context));
+        if (debug) console.log("Set RemoteSkybox (" + ((this.environment && this.background) ? "environment and background" : this.environment ? "environment" : this.background ? "background" : "none") + ")", this.url, !Camera.backgroundShouldBeTransparent(this.context));
         if (this.environment)
             this.context.scene.environment = envMap;
         if (this.background && !Camera.backgroundShouldBeTransparent(this.context))

package/src/engine-components/api.ts

@@ -51,9 +51,11 @@ import "./CameraUtils.js"
 import "./AnimationUtils.js"
 import "./AnimationUtilsAutoplay.js"
 
-export { DragMode } from "./DragControls.js"
+export { DragMode } from "./DragControls.js";
 export type { DropListenerNetworkEventArguments, DropListenerOnDropArguments } from "./DropListener.js";
+export { type FitCameraOptions } from "./OrbitControls.js";
 export * from "./particlesystem/api.js"
+export * from "./splines/index.js";
 
 // for correct type resolution in JSDoc
 import type { PhysicsMaterial } from "../engine/engine_physics.types.js";

package/src/engine-components/codegen/components.ts

@@ -150,6 +150,9 @@ export { SmoothFollow } from "../SmoothFollow.js";
 export { SpatialTriggerReceiver } from "../SpatialTrigger.js";
 export { SpatialTrigger } from "../SpatialTrigger.js";
 export { SpectatorCamera } from "../SpectatorCamera.js";
+export { SplineData } from "../splines/Spline.js";
+export { SplineContainer } from "../splines/Spline.js";
+export { SplineWalker } from "../splines/SplineWalker.js";
 export { Sprite } from "../SpriteRenderer.js";
 export { SpriteSheet } from "../SpriteRenderer.js";
 export { SpriteData } from "../SpriteRenderer.js";

package/src/engine-components/splines/Spline.ts

@@ -0,0 +1,284 @@
+
+import { BufferGeometry, CatmullRomCurve3, CubicBezierCurve3, Curve, Line, LineBasicMaterial,LineCurve3, Object3D, Quaternion, Vector3 } from "three";
+
+import { Mathf } from "../../engine/engine_math.js";
+import { serializeable } from "../../engine/engine_serialization.js";
+import { getParam } from "../../engine/engine_utils.js";
+import { Behaviour } from "../Component.js";
+
+const debug = getParam("debugsplines");
+
+export class SplineData {
+    @serializeable(Vector3)
+    position: Vector3 = new Vector3();
+
+    @serializeable(Quaternion)
+    rotation: Quaternion = new Quaternion();
+
+    @serializeable(Vector3)
+    tangentIn: Vector3 = new Vector3();
+
+    @serializeable(Vector3)
+    tangentOut: Vector3 = new Vector3();
+}
+
+// enum SplineTypeEnum {
+//     CatmullRom = 0,
+//     Bezier = 1,
+//     Linear = 2
+// }
+// type SplineType = "CatmullRom" | "Bezier" | "Linear";
+
+
+//@dont-generate-component
+/**
+ * Holds spline data and generates a spline curve. Use with SplineWalker to move objects along the spline or call getPointAt to sample points on the spline.
+ * The spline is defined by an array of knots (SplineData) which define position, rotation and tangents.  
+ * 
+ * You can create a SplineContainer from an array of points using the static method 'createFromPoints'.
+ */
+export class SplineContainer extends Behaviour {
+
+    /**
+     * Adds a knot to the end of the spline.
+     */
+    addKnot(knot: SplineData | { position: Vector3 }): SplineContainer {
+        if (knot instanceof SplineData) {
+            this.spline.push(knot);
+            this._isDirty = true;
+        }
+        else {
+            const k = new SplineData();
+            k.position.copy(knot.position);
+            this.spline.push(k);
+            this._isDirty = true;
+        }
+        return this;
+    }
+
+    /**
+     * Removes a knot by index or by reference.
+     */
+    removeKnot(index: number | SplineData): SplineContainer {
+        if (typeof index === "number") {
+            this.spline.splice(index, 1);
+            this._isDirty = true;
+        } else {
+            const i = this.spline.indexOf(index);
+            if (i !== -1) {
+                this.spline.splice(i, 1);
+                this._isDirty = true;
+            }
+        }
+        return this;
+    }
+
+    /**
+     * Gets a point on the spline in world space.
+     */
+    getPointAt(t: number, target?: Vector3): Vector3 {
+        if (!this.curve) return new Vector3();
+        const pos = this.curve.getPointAt(Mathf.clamp01(t), target);
+        const worldMatrix = this.gameObject.matrixWorld ?? undefined;
+        if (worldMatrix) {
+            pos.applyMatrix4(worldMatrix);
+        }
+        return pos;
+    }
+
+    /**
+     * Marks the spline as dirty, causing it to be rebuilt on the next update.
+     */
+    markDirty() {
+        this._isDirty = true;
+    }
+
+    /**
+     * Gets the tangent vector on the spline in world space.
+     */
+    getTangentAt(t: number, target?: Vector3): Vector3 {
+        if (!this.curve) return target ?? new Vector3();
+        const wr = this.gameObject.worldQuaternion;
+        return this.curve.getTangentAt(Mathf.clamp01(t), target).applyQuaternion(wr);
+    }
+
+    @serializeable()
+    set closed(value: boolean) {
+        this._closed = value;
+        this._isDirty = true;
+    }
+    get closed() { return this._closed; }
+    private _closed: boolean = false;
+
+
+    /** Spline data. Call 'markDirty' if modified */
+    @serializeable(SplineData)
+    spline: SplineData[] = [];
+
+    /** Enable to render the spline curve for debugging */
+    set debug(debug: boolean) {
+        if (debug && !this._builtCurve) this.buildCurve();
+        if (!this._debugLine) return;
+        this._debugLine.visible = debug;
+    }
+
+    /** Gets the spline curve generated from the 'spline' data */
+    get curve(): Curve<Vector3> | null {
+        return this._curve;
+    }
+
+    get isDirty() { return this._isDirty; }
+
+    private _isDirty: boolean = false;
+
+    private _curve: Curve<Vector3> | null = null;
+    private _builtCurve: boolean = false;
+    private _debugLine: Object3D | null = null;
+
+    /** @internal */
+    awake() {
+        if (debug) {
+            console.log(`[Spline] ${this.name}`, this);
+            this.buildCurve();
+        }
+    }
+
+    /** @internal */
+    update() {
+        if (this._isDirty) {
+            this.buildCurve(true);
+        }
+        if (this._debugLine && this._debugLine.parent !== this.gameObject) this.gameObject.add(this._debugLine);
+    }
+
+    private buildCurve(force: boolean = false) {
+        if (this._builtCurve && !force) return;
+        this._builtCurve = true;
+
+        if (!this.spline) {
+            console.error("[Spline] Can not build curve, no spline data", this.name);
+            return;
+        }
+        this._isDirty = false;
+        this._curve = createCatmullRomCurve(this.spline, this.closed);
+        this.buildDebugCurve();
+        // TODO: Unity supports spline interpolation type per knot which we don't support right now. Additionally EditType is deprecated. For simplicity we're just supporting CatmullRom for now.
+        // switch (this.editType) {
+        //     case SplineType.CatmullRom:
+        //         this.createCatmullRomCurve();
+        //         break;
+        //     case SplineType.Bezier:
+        //         console.warn("Bezier spline not implemented yet", this.name);
+        //         this.createCatmullRomCurve();
+        //         // this.createBezierCurve();
+        //         break;
+        //     case SplineType.Linear:
+        //         this.createLinearCurve();
+        //         break;
+        // }
+    }
+
+    private buildDebugCurve() {
+        if (debug && this.spline && this._curve) {
+            this._debugLine?.removeFromParent();
+            this._debugLine = null;
+
+            const material = new LineBasicMaterial({
+                color: 0x6600ff,
+            });
+            const res = this.spline.length * 10;
+            const splinePoints = this._curve.getPoints(res);
+            const geometry = new BufferGeometry().setFromPoints(splinePoints);
+            this._debugLine = new Line(geometry, material);
+            this.gameObject?.add(this._debugLine);
+        }
+    }
+}
+
+
+function createCatmullRomCurve(data: SplineData[], closed: boolean): CatmullRomCurve3 {
+    const points = data.map(knot => new Vector3(-knot.position.x, knot.position.y, knot.position.z));
+    if (points.length === 1) points.push(points[0]);
+    const averageTension = data.reduce((acc, knot) => acc + Math.abs(knot.tangentOut.x) + Math.abs(knot.tangentOut.y) + Math.abs(knot.tangentOut.z), 0) / data.length;
+    const tension = Mathf.remap(averageTension, 0, 0.3, 0, .5);
+    return new CatmullRomCurve3(points, closed, "catmullrom", tension);
+}
+
+function createLinearCurve(data: SplineData[], closed: boolean): LineCurve3 | null {
+    if (!data || data.length < 2) return null;
+    const points = data.map(knot => new Vector3(-knot.position.x, knot.position.y, knot.position.z));
+    if (closed) points.push(points[0]);
+    return new LineCurve3(points.at(0), points.at(1));
+}
+
+
+// function createBezierCurve(data: SplineData[], closed: boolean): CubicBezierCurve3 | null {
+//     if (!data || data.length < 2) return null;
+
+//     for (let k = 0; k < data.length; k++) {
+//         const k0 = data[k];
+//         let nextIndex = k + 1;
+//         if (nextIndex >= data.length) {
+//             if (!closed) break;
+//             nextIndex = 0;
+//         }
+//         const k1 = data[nextIndex];
+//         // points
+//         const p0 = new Vector3(-k0.position.x, k0.position.y, k0.position.z);
+//         const p1 = new Vector3(-k1.position.x, k1.position.y, k1.position.z);
+//         // tangents
+//         const t0 = new Vector3(-k0.tangentOut.x, k0.tangentOut.y, k0.tangentOut.z);
+//         const t1 = new Vector3(-k1.tangentIn.x, k1.tangentIn.y, k1.tangentIn.z);
+//         // rotations
+//         // const q0 = k0.rotation;// new Quaternion(k0.rotation.value.x, k0.rotation.value.y, k0.rotation.value.z, k0.rotation.value.w);
+//         // const q1 = k1.rotation;// new Quaternion(k1.rotation.value.x, k1.rotation.value.y, k1.rotation.value.z, k1.rotation.value.w);
+//         // const a = new Vector3(0,1,0);
+//         // const angle = Math.PI*.5;
+//         // t0.sub(p0).applyQuaternion(q0).add(p0);
+//         // t1.sub(p1).applyQuaternion(q1).add(p1);
+//         t0.add(p0);
+//         // t0.applyQuaternion(q0);
+//         t1.add(p1);
+//         const curve = new CubicBezierCurve3(p0, t0, t1, p1);
+//         return curve;
+//     }
+//     return null;
+// }
+
+// class SplineCurve {
+
+//     private spline: Spline;
+
+//     constructor(spline: Spline) {
+//         this.spline = spline;
+//     }
+
+//     getPoints(num: number): Vector3[] {
+//         const points: Vector3[] = [];
+//         const samplePerKnot = num / this.spline.length;
+//         for (let k = 1; k < this.spline.length; k++) {
+//             const cur = this.spline[k];
+//             const prev = this.spline[k - 1];
+
+//             for (let i = 0; i < samplePerKnot; i++) {
+//                 const t = i / (samplePerKnot - 1);
+//                 console.log(CurveUtils);
+//                 const x = this.interpolate(-prev.Position.x, -cur.Position.x, -prev.tangentOut.x, -cur.TangentIn.x, t);
+//                 const y = this.interpolate(prev.Position.y, cur.Position.y, prev.tangentOut.y, cur.TangentIn.y, t);
+//                 const z = this.interpolate(prev.Position.z, cur.Position.z, prev.tangentOut.z, cur.TangentIn.z, t);
+//                 points.push(new Vector3(x, y, z));
+//             }
+//         }
+
+//         return points;
+//     }
+
+//     interpolate(p0, p1, p2, p3, t) {
+
+//         var v0 = (p2 - p0) * 0.5;
+//         var v1 = (p3 - p1) * 0.5;
+//         var t2 = t * t;
+//         var t3 = t * t2;
+//         return (2 * p1 - 2 * p2 + v0 + v1) * t3 + (- 3 * p1 + 3 * p2 - 2 * v0 - v1) * t2 + v0 * t + p1;
+//     }
+// }

package/src/engine-components/splines/SplineUtils.ts

@@ -0,0 +1,32 @@
+import { Vector3 } from "three";
+
+import { Mathf } from "../../engine/engine_math.js";
+import { SplineContainer, SplineData } from "./Spline.js";
+
+
+export namespace SplineUtils {
+
+    /**
+     * Creates a SplineContainer from an array of points.
+     * @param positions The positions of the knots.
+     * @param closed Whether the spline is closed (the last knot connects to the first).
+     * @param tension The tension of the spline. 0 is no tension, 1 is high tension (straight lines between knots). Default is 0.75.
+     * @return The created SplineContainer component - add it to an Object3D to use it.
+     */
+    export function createFromPoints(positions: Vector3[], closed: boolean = false, tension: number = .75): SplineContainer {
+        const spline = new SplineContainer();
+        const tangentFactor = 1 - Mathf.clamp(tension, 0, 1);
+        positions.forEach((pos, index) => {
+            const tangent = new Vector3();
+            if (index < positions.length - 1) tangent.subVectors(positions[index + 1], pos).normalize().multiplyScalar(tangentFactor);
+            else if (closed && positions.length > 1) tangent.subVectors(positions[0], pos).normalize().multiplyScalar(tangentFactor);
+            const knot = new SplineData();
+            knot.position.copy(pos);
+            knot.tangentIn.copy(tangent);
+            knot.tangentOut.copy(tangent);
+            spline.addKnot(knot);
+        });
+        spline.closed = closed;
+        return spline;
+    }
+}