@needle-tools/engine 3.6.3 → 3.6.5

package/src/engine-components/AnimationCurve.ts

@@ -42,9 +42,10 @@ export class AnimationCurve {
                 if (hasNextKeyframe) {
                     const nextKf = this.keys[i+1];
                     // if the next
-                    if(nextKf.time < time) continue;
-                    const t = Mathf.remap(time, kf.time, nextKf.time, 0, 1);
-                    return Mathf.lerp(kf.value, nextKf.value, t);
+                    if (nextKf.time < time) continue;
+                    // tangents are set to Infinity if interpolation is set to constant - in that case we should always return the floored value
+                    if (!isFinite(kf.outTangent) || !isFinite(nextKf.inTangent)) return kf.value;
+                    return AnimationCurve.interpolateValue(time, kf, nextKf);
                 }
                 else {
                     return kf.value;
@@ -53,4 +54,31 @@ export class AnimationCurve {
         }
         return this.keys[this.keys.length - 1].value;
     }
+
+    static interpolateValue(time: number, keyframe1: Keyframe, keyframe2: Keyframe): number {
+        const startTime1 = keyframe1.time;
+        const startValue1 = keyframe1.value;
+        const outTangent1 = keyframe1.outTangent;
+
+        const startTime2 = keyframe2.time;
+        const startValue2 = keyframe2.value;
+        const inTangent2 = keyframe2.inTangent;
+
+        // could be precomputed and stored in the keyframes maybe
+        const timeDifference = startTime2 - startTime1;
+        const timeDifferenceSquared = timeDifference * timeDifference;
+        const timeDifferenceCubed = timeDifferenceSquared * timeDifference;
+
+        const a = ((outTangent1 + inTangent2) * timeDifference - 2 * (startValue2 - startValue1)) / timeDifferenceCubed;
+        const b = (3 * (startValue2 - startValue1) - (inTangent2 + 2 * outTangent1) * timeDifference) / timeDifferenceSquared;
+        const c = outTangent1;
+        const d = startValue1;
+
+        const timeDelta = time - startTime1;
+        const timeDeltaSquared = timeDelta * timeDelta;
+        const timeDeltaCubed = timeDeltaSquared * timeDelta;
+
+        return a * timeDeltaCubed + b * timeDeltaSquared + c * timeDelta + d;
+    }
+
 }

package/src/engine-components/AnimationUtils.ts

@@ -1,14 +1,79 @@
 import { GLTF } from "three/examples/jsm/loaders/GLTFLoader.js";
 import { ContextEvent, ContextRegistry } from "../engine/engine_context_registry";
-import { findAnimations } from "../engine/engine_scenetools";
-
+import { addNewComponent } from "../engine/engine_components";
+import { Animator } from "./Animator";
+import { Animation } from "./Animation";
+import { GameObject } from "./Component";
+import { PlayableDirector } from "./api";
 
 ContextRegistry.registerCallback(ContextEvent.ContextCreated, args => {
     const autoplay = args.context.domElement.getAttribute("autoplay");
     if (autoplay !== undefined && (autoplay === "" || autoplay === "true")) {
         if (args.files) {
-            for (const file of args.files)
-                findAnimations(file.file as GLTF, true);
+            for (const file of args.files) {
+                const hasAnimation = GameObject.foreachComponent(file.file.scene, comp => {
+                    if (comp.enabled === false) return undefined;
+                    if (comp instanceof Animation && comp.playAutomatically || comp instanceof Animator || comp instanceof PlayableDirector && comp.playOnAwake === true) {
+                        return true;
+                    }
+                    else if (comp instanceof Animation) {
+                        comp.playAutomatically = true;
+                        return true;
+                    }
+                    else if (comp instanceof PlayableDirector) {
+                        comp.playOnAwake = true;
+                        return true;
+                    }
+                    return undefined;
+                }, true);
+                if (hasAnimation !== true)
+                    findAnimations(file.file as GLTF);
+            }
+        }
+    }
+});
+
+
+
+function findAnimations(gltf: GLTF) {
+    if (!gltf || !gltf.animations) return;
+
+
+    for (let i = 0; i < gltf.animations.length; i++) {
+        const animation = gltf.animations[i];
+        if (!animation.tracks || animation.tracks.length <= 0) continue;
+        for (const t in animation.tracks) {
+            const track = animation.tracks[t];
+            const objectName = track["__objectName"] ?? track.name.substring(0, track.name.indexOf("."));
+            const obj = gltf.scene.getObjectByName(objectName);
+            if (!obj) {
+                // console.warn("could not find " + objectName, animation, gltf.scene);
+                continue;
+            }
+            let animationComponent = findAnimationGameObjectInParent(obj);
+            if (!animationComponent) {
+                animationComponent = addNewComponent(gltf.scene, new Animation());
+            }
+            const animations = animationComponent.animations = animationComponent.animations || [];
+            animation["name_animator"] = animationComponent.name;
+            // console.log(objectName, obj, animator.name, animations.length);
+            if (animations.indexOf(animation) < 0) {
+                animations.push(animation);
+            }
+        }
+    }
+    function findAnimationGameObjectInParent(obj) {
+        if (!obj) return;
+        const components = obj.userData?.components;
+        if (components && components.length > 0) {
+            for (let i = 0; i < components.length; i++) {
+                const component = components[i];
+                // console.log(component);
+                if (component instanceof Animator || component instanceof Animation) {
+                    return obj;;
+                }
+            }
         }
+        return findAnimationGameObjectInParent(obj.parent);
     }
-});
+}

package/src/engine-components/Component.ts

@@ -63,8 +63,9 @@ export abstract class GameObject extends Object3D implements Object3D, IGameObje
 
     /** Run a callback for all components of the provided type on the provided object and its children (if recursive is true)
      * @param instance object to run the method on
-     * @param cb callback to run on each component
+     * @param cb callback to run on each component, "return undefined;" to continue and "return <anything>;" to break the loop
      * @param recursive if true, the method will be run on all children as well
+     * @returns the last return value of the callback
      */
     public static foreachComponent(instance: Object3D, cb: (comp: Component) => any, recursive: boolean = true): any {
         return foreachComponent(instance, cb as (comp: IComponent) => any, recursive);

package/src/engine-components/Gizmos.ts

@@ -21,7 +21,7 @@ export class BoxGizmo extends Behaviour {
     onEnable(): void {
         if (this.isGizmo && !params.showGizmos) return;
         if (!this._gizmoObject) {
-            if (this.objectBounds && this.gameObject["isMesh"] === true) {
+            if (this.objectBounds) {
                 this._gizmoObject = new THREE.BoxHelper(this.gameObject, this.color ?? 0xffff00);
             }
             else {

package/src/engine-components/NestedGltf.ts

@@ -43,6 +43,8 @@ export class NestedGltf extends Behaviour {
                 res.matrixAutoUpdate = true;
                 res.layers.disableAll();
                 res.layers.set(this.layer);
+
+                this.dispatchEvent(new CustomEvent("loaded", { detail: {instance: res, assetReference: this.filePath }}));
             }
             if (debug) console.log("Nested loading done:", this.filePath?.uri ?? this.filePath, res);
         }

package/src/engine-components/export/usdz/ThreeUSDZExporter.ts

@@ -1299,7 +1299,7 @@ function buildMaterial( material: MeshStandardMaterial, textures, quickLookCompa
 
 	} else {
 
-		inputs.push( `${pad}float inputs:roughness = ${material.roughness}` );
+		inputs.push( `${pad}float inputs:roughness = ${material.roughness !== undefined ? material.roughness : 1 }` );
 
 	}
 
@@ -1311,7 +1311,7 @@ function buildMaterial( material: MeshStandardMaterial, textures, quickLookCompa
 
 	} else {
 
-		inputs.push( `${pad}float inputs:metallic = ${material.metalness}` );
+		inputs.push( `${pad}float inputs:metallic = ${material.metalness !== undefined ? material.metalness : 0 }` );
 
 	}
 

package/src/engine-components/postprocessing/Effects/ColorAdjustments.ts

@@ -63,7 +63,8 @@ export class ColorAdjustments extends PostProcessingEffect {
         this.postExposure!.onValueChanged = v => {
             if (this.context.renderer.toneMapping === NoToneMapping)
                 this.context.renderer.toneMapping = LinearToneMapping;
-            this.context.renderer.toneMappingExposure = v;
+            if (this.postExposure.overrideState)
+                this.context.renderer.toneMappingExposure = v;
         }
         this.contrast!.onValueChanged = v => {
             brightnesscontrast.contrast = v;