@needle-tools/engine 3.3.0-alpha → 3.5.0-alpha

package/src/engine-components/export/usdz/extensions/behavior/Behaviour.ts

@@ -0,0 +1,181 @@
+import { Behaviour, GameObject } from "../../../../Component";
+import { USDZExporter } from "../../USDZExporter";
+import { IUSDExporterExtension } from "../../Extension";
+import { USDObject, USDWriter } from "../../ThreeUSDZExporter";
+import { BehaviorModel } from "./BehavioursBuilder";
+import { IContext } from "../../../../../engine/engine_types";
+
+export interface UsdzBehaviour {
+    createBehaviours?(ext: BehaviorExtension, model: USDObject, context: IContext): void;
+    beforeCreateDocument?(ext: BehaviorExtension, context: IContext): void;
+    afterCreateDocument?(ext: BehaviorExtension, context: IContext): void;
+}
+
+export class USDZBehaviours extends Behaviour {
+    start() {
+        const exporter = GameObject.findObjectOfType(USDZExporter);
+        if (exporter) {
+            exporter.extensions.push(new BehaviorExtension());
+        }
+    }
+}
+
+export class BehaviorExtension implements IUSDExporterExtension {
+
+    get extensionName(): string {
+        return "Behaviour";
+    }
+
+    private behaviours: BehaviorModel[] = [];
+
+    addBehavior(beh: BehaviorModel) {
+        this.behaviours.push(beh);
+    }
+
+    behaviourComponents: Array<UsdzBehaviour> = [];
+
+
+    onBeforeBuildDocument(context) {
+        context.root.traverse(e => {
+            GameObject.foreachComponent(e, (comp) => {
+                const c = comp as unknown as UsdzBehaviour;
+                if (
+                    typeof c.createBehaviours === "function" || 
+                    typeof c.beforeCreateDocument === "function" || 
+                    typeof c.afterCreateDocument === "function"
+                ) {
+                    this.behaviourComponents.push(c);
+                    c.beforeCreateDocument?.call(c, this, context);
+                }
+            }, false);
+        });
+    }
+
+    onExportObject(_object, model: USDObject, context) {
+
+        for (const beh of this.behaviourComponents) {
+            beh.createBehaviours?.call(beh, this, model, context);
+        }
+    }
+
+    onAfterBuildDocument(context) {
+        for (const beh of this.behaviourComponents) {
+            if (typeof beh.afterCreateDocument === "function")
+                beh.afterCreateDocument(this, context);
+        }
+        this.behaviourComponents.length = 0;
+    }
+
+    onAfterHierarchy(context, writer : USDWriter) {
+        if (this.behaviours?.length) {
+
+            // this.combineBehavioursWithSameTapActions();
+
+            writer.beginBlock('def Scope "Behaviors"');
+
+            for (const beh of this.behaviours)
+                beh.writeTo(this, context.document, writer);
+
+            writer.closeBlock();
+        }
+    }
+
+    // combine behaviours that have tap triggers on the same object
+    // private combineBehavioursWithSameTapActions() {
+    //     // TODO: if behaviours have different settings (e.g. one is exclusive and another one is not) this wont work - we need more logic for that
+
+    //     const combined: { [key: string]: { behaviorId: string, trigger: TriggerModel, actions: IBehaviorElement[] } } = {};
+
+    //     for (let i = this.behaviours.length - 1; i >= 0; i--) {
+    //         const beh = this.behaviours[i];
+    //         const trigger = beh.trigger as TriggerModel;
+    //         if (!Array.isArray(trigger) && TriggerBuilder.isTapTrigger(trigger)) {
+    //             const targetObject = trigger.targetId;
+    //             if (!targetObject) continue;
+    //             if (!combined[targetObject]) {
+    //                 combined[targetObject] = { behaviorId: beh.id, trigger: trigger, actions: [] };
+    //             }
+    //             const action = beh.action;
+    //             combined[targetObject].actions.push(action);
+    //             this.behaviours.splice(i, 1);
+    //         }
+    //     }
+    //     for (const key in combined) {
+    //         const val = combined[key];
+    //         console.log("Combine " + val.actions.length + " actions on " + val.trigger.id, val.actions);
+    //         const beh = new BehaviorModel(val.behaviorId, val.trigger, ActionBuilder.sequence(...val.actions));
+    //         this.behaviours.push(beh);
+    //     }
+    // }
+}
+
+
+
+
+        // const playAnimationOnTap = new BehaviorModel("b_" + model.name + "_playanim", TriggerBuilder.tapTrigger(model),
+        //     ActionBuilder.parallel(
+        //         ActionBuilder.lookAtCameraAction(model),
+        //         ActionBuilder.sequence(
+        //             //ActionBuilder.startAnimationAction(model, 0, 0, 1, false, true),
+        //             ActionBuilder.emphasize(model, 1, MotionType.Float),
+        //             ActionBuilder.waitAction(1),
+        //             ActionBuilder.emphasize(model, 1, MotionType.Blink),
+        //             ActionBuilder.waitAction(1),
+        //             ActionBuilder.emphasize(model, 1, MotionType.Jiggle),
+        //             ActionBuilder.waitAction(1),
+        //             ActionBuilder.emphasize(model, 1, MotionType.Pulse),
+        //             ActionBuilder.waitAction(1),
+        //             ActionBuilder.emphasize(model, 1, MotionType.Spin),
+        //             ActionBuilder.waitAction(1),
+        //             ActionBuilder.emphasize(model, 1, MotionType.Bounce),
+        //             ActionBuilder.waitAction(1),
+        //             ActionBuilder.emphasize(model, 1, MotionType.Flip),
+        //             ActionBuilder.waitAction(1),
+        //         ).makeLooping()
+        //     ).makeLooping()
+        // );
+        // this.behaviours.push(playAnimationOnTap);
+        // return;
+
+        // const identityMatrix = new Matrix4().identity();
+
+        // const emptyParent = new USDZObject(model.name + "_empty", model.matrix);
+        // const parent = model.parent;
+        // parent.add(emptyParent);
+        // model.matrix = identityMatrix;
+        // emptyParent.add(model);
+
+
+        // const geometry = new THREE.SphereGeometry(.6, 32, 16);
+        // const modelVariant = new USDZObject(model.name + "_variant", identityMatrix, geometry, new MeshStandardMaterial({ color: 0xff0000 }));
+        // emptyParent.add(modelVariant);
+
+        // const matrix2 = new Matrix4();
+        // matrix2.makeTranslation(.5, 0, 0);
+        // const modelVariant2 = new USDZObject(model.name + "_variant2", matrix2, geometry, new MeshStandardMaterial({ color: 0xffff00 }));
+        // emptyParent.add(modelVariant2);
+
+        // const hideVariantOnStart = new BehaviorModel("b_" + model.name + "_start", TriggerBuilder.sceneStartTrigger(), ActionBuilder.fadeAction(modelVariant, 0, false));
+        // this.behaviours.push(hideVariantOnStart);
+
+        // const showVariant = new BehaviorModel("b_" + model.name + "_show_variant", [TriggerBuilder.tapTrigger(model)], new GroupActionModel("group", [
+        //     ActionBuilder.fadeAction(model, 0, false),
+        //     ActionBuilder.fadeAction(modelVariant, 0, true),
+        // ]));
+        // this.behaviours.push(showVariant);
+
+        // const showOriginal = new BehaviorModel("b_" + model.name + "_show_original", [
+        //     TriggerBuilder.tapTrigger(modelVariant),
+        //     TriggerBuilder.tapTrigger(modelVariant2)
+        // ],
+        //     new GroupActionModel("group", [
+        //         ActionBuilder.fadeAction([modelVariant, modelVariant2], 0, false),
+        //         //ActionBuilder.waitAction(1),
+        //         ActionBuilder.fadeAction(model, 0, true),
+        //         //ActionBuilder.waitAction(.2),
+        //         ActionBuilder.startAnimationAction(model, 0, 1000, 1, false, true),
+        //         //ActionBuilder.lookAtCameraAction(model, 2, Vec3.forward, Vec3.up),
+        //         //ActionBuilder.waitAction(1),
+        //         //ActionBuilder.fadeAction(modelVariant2, 0, true),
+        //     ]).makeSequence());
+        // this.behaviours.push(showOriginal);