@needle-tools/engine 2.42.0-pre → 2.44.0-pre

package/src/engine/engine_serialization_builtin_serializer.ts

@@ -194,71 +194,73 @@ class EventListSerializer extends TypeSerializer {
             if (debugExtension)
                 console.log("DESERIALIZE EVENT", data);
             const fns = new Array<CallInfo>();
-            for (const call of data.calls) {
-                if (debugExtension)
-                    console.log(call);
-                let target = componentSerializer.findObjectForGuid(call.target, context.root);
-                // if the object is not found in the current glb try find it in the whole scene
-                if (!target && context.context?.scene) {
-                    target = componentSerializer.findObjectForGuid(call.target, context.context?.scene);
-                }
-                const hasMethod = call.method?.length > 0;
-                if (target && hasMethod) {
-                    const printWarningMethodNotFound = () => console.warn(`Could not find method ${call.method} on object ${target.name}`, target, typeof target[call.method]);
-                    if (typeof target[call.method] !== "function") {
-                        let foundMethod = false;
-                        // test if the target method is actually a property setter
-                        // in which case we want to remove the leading set prefix and see if the method or property exists
-                        if (call.method.startsWith("set_") && call.method.length > 4) {
-                            call.method = call.method.substring(4);
-                            if (target[call.method] !== undefined) foundMethod = true;
+            if (data.calls && Array.isArray(data.calls)) {
+                for (const call of data.calls) {
+                    if (debugExtension)
+                        console.log(call);
+                    let target = componentSerializer.findObjectForGuid(call.target, context.root);
+                    // if the object is not found in the current glb try find it in the whole scene
+                    if (!target && context.context?.scene) {
+                        target = componentSerializer.findObjectForGuid(call.target, context.context?.scene);
+                    }
+                    const hasMethod = call.method?.length > 0;
+                    if (target && hasMethod) {
+                        const printWarningMethodNotFound = () => console.warn(`Could not find method ${call.method} on object ${target.name}`, target, typeof target[call.method]);
+                        if (typeof target[call.method] !== "function") {
+                            let foundMethod = false;
+                            // test if the target method is actually a property setter
+                            // in which case we want to remove the leading set prefix and see if the method or property exists
+                            if (call.method.startsWith("set_") && call.method.length > 4) {
+                                call.method = call.method.substring(4);
+                                if (target[call.method] !== undefined) foundMethod = true;
+                            }
+                            if (!foundMethod)
+                                printWarningMethodNotFound();
                         }
-                        if (!foundMethod)
-                            printWarningMethodNotFound();
                     }
-                }
-                let fn: CallInfo | undefined;
-                let args = call.argument;
-                if (call.argument !== undefined) {
-                    if (typeof args === "object") {
-                        args = objectSerializer.onDeserialize(call.argument, context);
-                        if (!args) args = componentSerializer.onDeserialize(call.argument, context);
+                    let fn: CallInfo | undefined;
+                    let args = call.argument;
+                    if (call.argument !== undefined) {
+                        if (typeof args === "object") {
+                            args = objectSerializer.onDeserialize(call.argument, context);
+                            if (!args) args = componentSerializer.onDeserialize(call.argument, context);
+                        }
+                        fn = new CallInfo(hasMethod ? (...args) => invokeFunction(...args) : undefined, call.enabled);
                     }
-                    fn = new CallInfo(hasMethod ? (...args) => invokeFunction(...args) : undefined, call.enabled);
-                }
-                else
-                    fn = new CallInfo(hasMethod ? (...args) => invokeFunction(...args) : undefined, call.enabled);
+                    else
+                        fn = new CallInfo(hasMethod ? (...args) => invokeFunction(...args) : undefined, call.enabled);
 
 
-                // TODO: move this into the event list directly 
-                // this scope should not stay in the serializer.
-                // the event list should be able to modify the args that were set in unity if necessary
-                // and pass them on to the component
-                const invokeFunction = (...forwardedArgs) => {
-                    const method = target[call.method];
+                    // TODO: move this into the event list directly 
+                    // this scope should not stay in the serializer.
+                    // the event list should be able to modify the args that were set in unity if necessary
+                    // and pass them on to the component
+                    const invokeFunction = (...forwardedArgs) => {
+                        const method = target[call.method];
 
-                    if (typeof method === "function") {
-                        if (args !== undefined)
-                            method?.call(target, args);
-                        else // support invoking EventList with any number of arguments (if none were declared in unity)
-                            method?.call(target, ...forwardedArgs);
-                    }
-                    else // the target "method" can be a property too
-                    {
-                        target[call.method] = args;
-                    }
-                };
+                        if (typeof method === "function") {
+                            if (args !== undefined)
+                                method?.call(target, args);
+                            else // support invoking EventList with any number of arguments (if none were declared in unity)
+                                method?.call(target, ...forwardedArgs);
+                        }
+                        else // the target "method" can be a property too
+                        {
+                            target[call.method] = args;
+                        }
+                    };
 
-                if (!fn.method)
-                    fn["__debuginfo"] = context.object?.name;
-                if (!target || !fn.method) {
-                    const debugInfo = context.object ? "Current object: " + context.object.name + ", " + context.object["guid"] : null;
-                    if (!target)
-                        console.warn("EventList is missing target - will be ignored", call.target, debugInfo, data);
-                    else console.warn("EventList method not found: \"" + call.method + "\" on", target);
+                    if (!fn.method)
+                        fn["__debuginfo"] = context.object?.name;
+                    if (!target || !fn.method) {
+                        const debugInfo = context.object ? "Current object: " + context.object.name + ", " + context.object["guid"] : null;
+                        if (!target)
+                            console.warn("EventList is missing target - will be ignored", call.target, debugInfo, data);
+                        else console.warn("EventList method not found: \"" + call.method + "\" on", target);
+                    }
+                    else
+                        fns.push(fn);
                 }
-                else
-                    fns.push(fn);
             }
             const evt: EventList = new EventList(fns);
             if (debugExtension)

package/src/engine/engine_three_utils.ts

@@ -1,10 +1,9 @@
 import * as THREE from "three";
 import { Mathf } from "./engine_math"
-import { WebGLRenderTarget, WebGLRenderer, Vector3, Quaternion, Uniform, Texture, Material, ShaderMaterial, CanvasTexture } from "three";
+import { WebGLRenderTarget, WebGLRenderer, Vector3, Quaternion, Uniform, Texture, Material, ShaderMaterial, CanvasTexture, AnimationAction } from "three";
 import { CircularBuffer } from "./engine_utils";
 
 
-
 const flipYQuat: Quaternion = new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), Math.PI);
 export function lookAtInverse(obj: THREE.Object3D, target: Vector3) {
 
@@ -177,6 +176,16 @@ export function logHierarchy(root: THREE.Object3D | null | undefined, collapsibl
 }
 
 
+export function isAnimationAction(obj:object){
+    if(obj){
+        // this doesnt work :(
+        // return obj instanceof AnimationAction;
+        // instead we do this:
+        const act = obj as AnimationAction;
+        return act.blendMode !== undefined && act.clampWhenFinished !== undefined && act.enabled !== undefined && act.fadeIn !== undefined && act.getClip !== undefined;
+    }
+    return false;
+}
 
 
 

package/src/engine/engine_time.ts

@@ -27,6 +27,7 @@ export class Time {
         this.deltaTime = this.clock.getDelta();
         // clamp delta time because if tab is not active clock.getDelta can get pretty big
         this.deltaTime = Math.min(.1, this.deltaTime);
+        if(this.deltaTime <= 0) this.deltaTime = 0.000000000001;
         this.frame += 1;
         this.time += this.deltaTime;
 

package/src/engine/extensions/NEEDLE_techniques_webgl.ts

@@ -57,6 +57,16 @@ enum CullMode {
     Front = 1,
     Back = 2,
 }
+enum ZTestMode {
+    Never = 1,
+    Less = 2,
+    Equal = 3,
+    LEqual = 4,
+    Greater = 5,
+    NotEqual = 6,
+    GEqual = 7,
+    Always = 8,
+}
 
 export class CustomShader extends RawShaderMaterial {
 
@@ -446,6 +456,7 @@ export class NEEDLE_techniques_webgl implements GLTFLoaderPlugin {
                     //     "USE_SHADOWMAP" : true
                     // },
                 });
+
             const culling = uniforms["_Cull"]?.value;
             switch (culling) {
                 case CullMode.Off:
@@ -462,6 +473,38 @@ export class NEEDLE_techniques_webgl implements GLTFLoaderPlugin {
                     break;
             }
 
+            const zTest = uniforms["_ZTest"]?.value as ZTestMode;
+            switch (zTest) {
+                case ZTestMode.Equal:
+                    material.depthTest = true;
+                    material.depthFunc = THREE.EqualDepth;
+                    break;
+                case ZTestMode.NotEqual:
+                    material.depthTest = true;
+                    material.depthFunc = THREE.NotEqualDepth;
+                    break;
+                case ZTestMode.Less:
+                    material.depthTest = true;
+                    material.depthFunc = THREE.LessDepth;
+                    break;
+                case ZTestMode.LEqual:
+                    material.depthTest = true;
+                    material.depthFunc = THREE.LessEqualDepth;
+                    break;
+                case ZTestMode.Greater:
+                    material.depthTest = true;
+                    material.depthFunc = THREE.GreaterDepth;
+                    break;
+                case ZTestMode.GEqual:
+                    material.depthTest = true;
+                    material.depthFunc = THREE.GreaterEqualDepth;
+                    break;
+                case ZTestMode.Always:
+                    material.depthTest = false;
+                    material.depthFunc = THREE.AlwaysDepth;
+                    break;
+            }
+
             material.transparent = isTransparent;
             if (isTransparent)
                 material.depthWrite = false;
@@ -490,7 +533,6 @@ export class NEEDLE_techniques_webgl implements GLTFLoaderPlugin {
             if (debug)
                 console.log(material.uuid, uniforms);
 
-
             createUniformProperties(material);
 
             resolve(material);

package/src/engine-components/Animation.ts

@@ -6,6 +6,9 @@ import { serializeable } from "../engine/engine_serialization_decorator";
 import { InstancingUtil } from "../engine/engine_instancing";
 import { Mathf } from "../engine/engine_math";
 import { Vec2 } from "../engine/engine_types";
+import { getParam } from "../engine/engine_utils";
+
+const debug = getParam("debuganimation");
 
 export declare class PlayOptions {
     fadeDuration?: number;
@@ -28,21 +31,30 @@ export class Animation extends Behaviour {
     minMaxSpeed?: Vec2;
     minMaxOffsetNormalized?: Vec2;
 
+    @serializeable()
+    loop: boolean = true;
+
+    @serializeable()
+    clampWhenFinished: boolean = false;
+
     private _tempAnimationClipBeforeGameObjectExisted: AnimationClip | null = null;
     get clip(): AnimationClip | null {
         return this.animations?.length ? this.animations[0] : null;
     }
     set clip(val: AnimationClip | null) {
-        if (!this.gameObject) {
+        if (!this.__didAwake) {
+            if (debug) console.log("Assign clip during serialization", val);
             this._tempAnimationClipBeforeGameObjectExisted = val;
             return;
         }
         if (!val) return;
+        if (debug) console.log("Assign clip", val, Boolean(this.gameObject));
         if (!this.gameObject.animations) this.gameObject.animations = [];
         this.gameObject.animations.push(val);
     }
 
     set animations(animations: THREE.AnimationClip[]) {
+        if (debug) console.log("assign animations", animations);
         this.gameObject.animations = animations;
     }
 
@@ -120,9 +132,10 @@ export class Animation extends Behaviour {
         return false;
     }
 
-    play(clipOrNumber: AnimationClip | number | string, options?: PlayOptions): Promise<AnimationAction> | void {
+    play(clipOrNumber: AnimationClip | number | string | undefined, options?: PlayOptions): Promise<AnimationAction> | void {
         this.init();
         if (!this.mixer) return;
+        if (clipOrNumber === undefined) clipOrNumber = 0;
         let clip: AnimationClip | undefined = clipOrNumber as AnimationClip;
         if (typeof clipOrNumber === 'number') {
             if (clipOrNumber >= this.animations.length) return;
@@ -138,6 +151,8 @@ export class Animation extends Behaviour {
         if (!options) options = {};
         if (!options.minMaxOffsetNormalized) options.minMaxOffsetNormalized = this.minMaxOffsetNormalized;
         if (!options.minMaxSpeed) options.minMaxSpeed = this.minMaxSpeed;
+        if (!options.loop) options.loop = this.loop;
+        if (!options.clampWhenFinished) options.clampWhenFinished = this.clampWhenFinished;
         for (const act of this.actions) {
             if (act.getClip() === clip) {
                 return this.internalOnPlay(act, options);
@@ -176,6 +191,7 @@ export class Animation extends Behaviour {
 
         if (options?.loop !== undefined)
             action.loop = options.loop ? THREE.LoopRepeat : THREE.LoopOnce;
+        else action.loop = THREE.LoopOnce;
         action.play();
         // console.log("PLAY", action.getClip().name, action)
 

package/src/engine-components/AnimatorController.ts

@@ -7,6 +7,7 @@ import * as THREE from "three";
 import { TypeStore } from "../engine/engine_typestore";
 import { assign } from "../engine/engine_serialization_core";
 import { Mathf } from "../engine/engine_math";
+import { isAnimationAction } from "../engine/engine_three_utils";
 
 const debug = getParam("debuganimatorcontroller");
 const debugRootMotion = getParam("debugrootmotion");
@@ -122,7 +123,10 @@ export class AnimatorController {
             // dont clone three Objects
             if (_value.type === "Object3D" || _value.isObject3D === true) return false;
             // dont clone AnimationAction
-            if (_value?.constructor?.name === "AnimationAction") return false;
+            if (isAnimationAction(_value)) { //.constructor.name === "AnimationAction") {
+                console.log(_value);
+                return false;
+            }
             // dont clone AnimationClip
             if (_value["tracks"] !== undefined) return false;
             return true;

package/src/engine-components/Camera.ts

@@ -80,6 +80,19 @@ export class Camera extends Behaviour implements ICamera {
     @serializeable()
     public ARBackgroundAlpha: number = 0;
 
+    @serializeable()
+    public set cullingMask(val: number) {
+        this._cullingMask = val;
+        if (this._cam) {
+            this._cam.layers.mask = val;
+        }
+    }
+    public get cullingMask(): number {
+        if (this._cam) return this._cam.layers.mask;
+        return this._cullingMask;
+    }
+    private _cullingMask: number = 0xffffffff;
+
     private _nearClipPlane: number = 0.1;
     private _farClipPlane: number = 1000;
 
@@ -95,7 +108,7 @@ export class Camera extends Behaviour implements ICamera {
         }
         else this._backgroundColor.copy(val);
         // set background color to solid if provided color doesnt have any alpha channel
-        if(val.alpha === undefined) this._backgroundColor.alpha = 1;
+        if (val.alpha === undefined) this._backgroundColor.alpha = 1;
         this.applyClearFlagsIfIsActiveCamera();
     }
 
@@ -113,10 +126,6 @@ export class Camera extends Behaviour implements ICamera {
     }
 
 
-    // constructor(){
-    //     super();
-    //     console.log(this);
-    // }
 
     awake() {
         if (!this.sourceId) {
@@ -146,6 +155,7 @@ export class Camera extends Behaviour implements ICamera {
         let cam: THREE.PerspectiveCamera | THREE.OrthographicCamera | null = null;
         if (cameraAlreadyCreated) {
             cam = this.gameObject as any;
+            cam?.layers.enableAll();
         }
         else
             cam = this.gameObject.children[0] as THREE.PerspectiveCamera | THREE.OrthographicCamera | null;
@@ -167,11 +177,8 @@ export class Camera extends Behaviour implements ICamera {
         }
         this._cam = cam;
 
-        // workaround for layers in three affecting visibility by default
-        // we should probably export this info from unity as well
-        if (this.layer === 0) {
-            this._cam.layers.enableAll();
-        }
+        this._cam.layers.mask = this._cullingMask;
+
         if (this.tag == "MainCamera") {
             this.context.setCurrentCamera(this);
         }