@needle-tools/engine 2.35.5-pre → 2.37.0-pre

package/src/engine/engine_physics.types.ts

@@ -0,0 +1,19 @@
+
+
+export enum CollisionDetectionMode {
+  Discrete = 0,
+  Continuous = 1,
+}
+
+export enum RigidbodyConstraints {
+  None = 0,
+  FreezePositionX = 2,
+  FreezePositionY = 4,
+  FreezePositionZ = 8,
+  FreezePosition = 14,
+  FreezeRotationX = 16,
+  FreezeRotationY = 32,
+  FreezeRotationZ = 64,
+  FreezeRotation = 112,
+  FreezeAll = 126,
+}

package/src/engine/engine_serialization_core.ts

@@ -3,13 +3,15 @@ import { getParam } from "./engine_utils";
 import { Object3D } from "three";
 import { Context } from "./engine_setup";
 import { isPersistentAsset } from "./extensions/NEEDLE_persistent_assets";
-import { SourceIdentifier } from "./engine_types";
+import { IComponent, SourceIdentifier } from "./engine_types";
 import { debugExtension } from "../engine/engine_default_parameters";
 import { LogType, showBalloonMessage } from "./debug/debug";
 import { isLocalNetwork } from "./engine_networking_utils";
+import { $BuiltInTypeFlag } from "./engine_typestore";
 
 const debug = getParam("debugserializer");
 
+
 export type Constructor<T> = { new(...args: any[]): T };
 export declare type NodeToObjectMap = { [nodeId: string]: Object3D };
 export declare type ObjectToNodeMap = { [uuid: string]: number };
@@ -324,8 +326,16 @@ export function deserializeObject(obj: ISerializable, serializedData: object, co
     return true;
 }
 
+const blockChecks = getParam("noerrors");
 function checkObjectAssignments(obj: any, _serializedData?: any) {
-    if(isLocalNetwork() === false) return;
+    if(blockChecks) return;
+    if (isLocalNetwork() === false) return;
+    if (!obj) return;
+
+    // ignore builtin components that we dont want to check
+    if(obj.constructor && obj.constructor[$BuiltInTypeFlag] === true) return;
+
+    const typeName = obj.constructor?.name as string;
     // test if any object reference is missing serializable
     const ownKeys = Object.getOwnPropertyNames(obj);
     for (const key of ownKeys) {
@@ -337,18 +347,16 @@ function checkObjectAssignments(obj: any, _serializedData?: any) {
                 if (typeof value["node"] === "number" || typeof value["guid"] === "string") {
                     const hasOtherKeys = Object.keys(value).length > 1;
                     if (!hasOtherKeys) {
-                        const typeName = obj.constructor?.name;
-                        showBalloonMessage(`<strong>Missing serialization for object reference!</strong>\n\nPlease change to: \n@serializable(Object3D)\n${key}? : Object3D;\n\nin script ${typeName}.ts\n<a href="https://docs.needle.tools/serializeable">documentation</a>`, LogType.Warn);
-                        console.warn(obj);
+                        showBalloonMessage(`<strong>Missing serialization for object reference!</strong>\n\nPlease change to: \n@serializable(Object3D)\n${key}? : Object3D;\n\nin script ${typeName}.ts\n<a href="https://docs.needle.tools/serializeable" target="_blank">documentation</a>`, LogType.Warn);
+                        console.warn(typeName, key, obj[key], obj);
                     }
                 }
             }
         }
         else if (typeof value === "string") {
             if (value.endsWith(".gltf") || value.endsWith(".glb")) {
-                const typeName = obj.constructor?.name;
-                showBalloonMessage(`<strong>Missing serialization for object reference!</strong>\n\nPlease change to: \n@serializable(AssetReference)\n${key}? : AssetReference;\n\nin script ${typeName}.ts\n<a href="https://docs.needle.tools/serializeable">documentation</a>`, LogType.Warn);
-                console.warn(obj);
+                showBalloonMessage(`<strong>Missing serialization for object reference!</strong>\n\nPlease change to: \n@serializable(AssetReference)\n${key}? : AssetReference;\n\nin script ${typeName}.ts\n<a href="https://docs.needle.tools/serializeable" target="_blank">documentation</a>`, LogType.Warn);
+                console.warn(typeName, key, obj[key], obj);
             }
         }
     }
@@ -509,6 +517,10 @@ function setBuffer(value): Array<any> {
 }
 
 
+/** set to true while assigning properties during instantiation. 
+ * Used for validate decorator to not invoke callbacks on components that are currently in the process of being built */
+export const $isAssigningProperties = Symbol("assigned component properties");
+
 // const developmentMode = getParam("dev")
 
 /** Object.assign behaviour but check if property is writeable (e.g. getter only properties are skipped) */
@@ -533,6 +545,7 @@ export function assign(target: any, source: any) {
     // if (developmentMode)
     //     onlyDeclared = false;
 
+    target[$isAssigningProperties] = true;
     for (const key of Object.keys(source)) {
         const desc = getPropertyDescriptor(target, key);
         if (onlyDeclared && desc === undefined) continue;
@@ -543,6 +556,7 @@ export function assign(target: any, source: any) {
             target[key] = source[key];
         }
     }
+    delete target[$isAssigningProperties];
 }
 
 // we need to recurse because the property might be defined in a base class

package/src/engine/engine_setup.ts

@@ -400,6 +400,10 @@ export class Context {
 	}
 
 	private async internalOnCreate(buildScene: (context: Context, opts?: LoadingOptions) => Promise<void>, opts?: LoadingOptions) {
+
+		// TODO: we could configure if we need physics
+		await this.physics.createWorld();
+
 		// load and create scene
 		let prepare_succeeded = true;
 		try {
@@ -562,7 +566,7 @@ export class Context {
 		this.executeCoroutines(FrameEvent.LateUpdate);
 
 		try {
-			const physicsSteps = 2;
+			const physicsSteps = 1;
 			const dt = this.time.deltaTime / physicsSteps;
 			for (let i = 0; i < physicsSteps; i++) {
 				this.physics.step(dt);
@@ -600,7 +604,7 @@ export class Context {
 		this._isRendering = true;
 		this.renderRequiredTextures();
 		if (!this.isManagedExternally) {
-			if (this.composer) {
+			if (this.composer && !this.isInXR) {
 				this.composer.render();
 			}
 			else if (this.mainCamera) {

package/src/engine/engine_time.ts

@@ -5,6 +5,8 @@ export class Time {
 
     deltaTime = 0;
     time = 0;
+
+    /** same as frameCount */
     frame = 0;
 
     get realtimeSinceStartup(): number {

package/src/engine/engine_types.ts

@@ -1,6 +1,6 @@
-import { Camera, Color, Material, Object3D, Vector3 } from "three";
-import { Body, ContactEquation } from "cannon-es";
+import { Camera, Color, Material, Object3D, Vector3, Quaternion } from "three";
 import { RGBAColor } from "../engine-components/js-extensions/RGBAColor";
+import { CollisionDetectionMode, RigidbodyConstraints } from "./engine_physics.types";
 
 /** used to find data registered via gltf files e.g. find lightmaps for a Renderer component that were shipped inside a gltf */
 export declare type SourceIdentifier = string;
@@ -58,9 +58,10 @@ export interface IComponent {
     onDisable();
     onDestroy();
 
+    /** called for properties decorated with the @validate decorator */
+    onValidate?(property?: string);
+
     start?(): void;
-    // available update loop events:
-    // earlyUpdate, update, lateUpdate, onBeforeRender, onAfterRender
     earlyUpdate?(): void;
     update?(): void;
     lateUpdate?(): void;
@@ -69,17 +70,15 @@ export interface IComponent {
 
     onCollisionEnter?(col: Collision);
     onCollisionExit?(col: Collision);
-    onCollisionExitRaw?(col: Collision);
     onCollisionStay?(col: Collision);
 
-    onTriggerEnter?(col: Collision);
-    onTriggerStay?(col: Collision);
-    onTriggerExit?(col: Collision);
-
-    __internalHandleCollision(col: Collision, isTriggerCollision: boolean);
-    __internalHandleExitCollisionEvent(obj: Object3D, isTriggerCollision: boolean);
+    onTriggerEnter?(col: ICollider);
+    onTriggerStay?(col: ICollider);
+    onTriggerExit?(col: ICollider);
 
     get forward(): Vector3;
+    get worldPosition(): Vector3;
+    get worldQuaternion(): Quaternion;
 }
 
 
@@ -101,7 +100,8 @@ export declare interface ILight extends IComponent {
 }
 
 export declare interface ISharedMaterials {
-    [num:number] : Material;
+    [num: number]: Material;
+    get length(): number;
 }
 
 export declare interface IRenderer extends IComponent {
@@ -109,6 +109,10 @@ export declare interface IRenderer extends IComponent {
     get sharedMaterials(): ISharedMaterials;
 }
 
+// export declare interface IPhysicsComponent extends IComponent {
+//     get type() : string;
+// }
+
 export declare interface ICollider extends IComponent {
     get isCollider();
     attachedRigidbody: IRigidbody | null;
@@ -116,67 +120,98 @@ export declare interface ICollider extends IComponent {
 }
 
 export declare interface IRigidbody extends IComponent {
-    initialize(): void;
-    body;
+    constraints: RigidbodyConstraints;
+    isKinematic: boolean;
+    mass: number;
+    drag: number;
+    angularDrag: number;
+    useGravity: boolean;
+    collisionDetectionMode: CollisionDetectionMode;
+
+    lockPositionX: boolean;
+    lockPositionY: boolean;
+    lockPositionZ: boolean;
+    lockRotationX: boolean;
+    lockRotationY: boolean;
+    lockRotationZ: boolean;
 }
 
 
+export const $physicsKey = Symbol("object");
 
 
+export declare type ICollisionContext = {
+    getCollider(obj: Object3D): ICollider;
+}
 
 
-
-export const $physicsKey = Symbol("object");
-
-export declare type CannonCollision = {
-    body: Body;
-    contact: ContactEquation;
-    target: Body;
-    type: string;
+export type Vec3 = {
+    x: number,
+    y: number,
+    z: number
 }
 
-export declare type ICollisionContext = {
-    getCollider(obj: Object3D): ICollider;
+export type Vec2 = {
+    x: number,
+    y: number
 }
 
-export class Collision {
+export class ContactPoint {
 
-    get __internalCollision(): CannonCollision {
-        return this.collision;
-    }
+    readonly localPoint: Vec3;
+    readonly distance: number;
+    readonly normal: Vec3;
 
-    get __internalInvertedSourceReceiver(): boolean {
-        return this.invert;
+    constructor(localPt: Vec3, dist: number, normal: Vec3) {
+        this.localPoint = localPt;
+        this.distance = dist;
+        this.normal = normal;
     }
 
-    private readonly invert: boolean;
-    private readonly collision: CannonCollision;
-    private readonly targetBody: Body;
-    private readonly context: ICollisionContext;
+}
 
-    readonly me: Object3D;
+/// all info in here must be readonly because the object is only created once per started collision
+export class Collision {
+
+    private readonly contacts: ContactPoint[];
 
-    private _normal?: Vector3;
-    get normal(): Vector3 {
-        if (!this._normal) {
-            const vec = this.collision.contact.ni;
-            this._normal = new Vector3(vec.x, vec.y, vec.z);
-        }
-        return this._normal;
+    constructor(obj: Object3D, otherCollider: ICollider, contacts: ContactPoint[]) {
+        this.me = obj;
+        this._collider = otherCollider;
+        this._gameObject = otherCollider.gameObject;
+        this.contacts = contacts;
     }
 
-    private _collider?: ICollider;
+    readonly me: Object3D;
+    private _collider: ICollider;
+
+    /** the collider the collision happened with */
     get collider(): ICollider {
-        if (!this._collider) {
-            this._collider = this.context.getCollider(this.gameObject);
-        }
         return this._collider;
     }
 
+    /** the object the collision happened with */
+    private _gameObject: Object3D;
     get gameObject(): Object3D {
-        return this.targetBody[$physicsKey];
+        return this._gameObject;
+    }
+
+    /** the rigidbody we hit, null if none attached */
+    get rigidBody(): IRigidbody | null {
+        return this.collider?.attachedRigidbody;
     }
 
+
+    // private _normal?: Vector3;
+    // get normal(): Vector3 {
+    //     if (!this._normal) {
+    //         const vec = this.collision.contact.ni;
+    //         this._normal = new Vector3(vec.x, vec.y, vec.z);
+    //     }
+    //     return this._normal;
+    // }
+
+
     // private _point?: Vector3;
     // get point(): Vector3 {
     //     if (!this._point) {
@@ -186,12 +221,4 @@ export class Collision {
     //     }
     //     return this._point;
     // }
-
-    constructor(obj: Object3D, collision: CannonCollision, context: ICollisionContext, invert: boolean = false) {
-        this.me = obj;
-        this.collision = collision;
-        this.context = context;
-        this.targetBody = invert ? collision.target : collision.body;
-        this.invert = invert;
-    }
 }

package/src/engine/engine_typestore.ts

@@ -18,4 +18,6 @@ class _TypeStore {
     }
 }
 
+export const $BuiltInTypeFlag = Symbol("BuiltInType");
+
 export const TypeStore = new _TypeStore();

package/src/engine/engine_util_decorator.ts

@@ -0,0 +1,69 @@
+import { $isAssigningProperties } from "./engine_serialization_core";
+import { LogType, showBalloonMessage } from "./debug/debug";
+import { IComponent } from "./engine_types";
+
+
+declare type setter = (v: any) => void;
+declare type getter = () => any;
+
+/** create accessor callbacks for a field */
+export const validate = function (set?: setter, get?: getter) {
+    // "descriptor : undefined" prevents @validate() to be added to property getters or setters
+    return function (target: IComponent | any, propertyKey: string, descriptor?: undefined) {
+        createPropertyWrapper(target, propertyKey, descriptor, set, get);
+    }
+}
+
+
+function createPropertyWrapper(target: IComponent | any, propertyKey: string, descriptor?: PropertyDescriptor,
+    set?: setter,
+    get?: getter) {
+
+    if (!get && !set && !target.onValidate) return;
+
+    // this is not undefined when its a property getter or setter already and not just a field
+    // we currently only support validation of fields
+    if (descriptor !== undefined) {
+        console.error("Invalid usage of validate decorator. Only fields can be validated.", target, propertyKey, descriptor);
+        showBalloonMessage("Invalid usage of validate decorator. Only fields can be validated. Property: " + propertyKey, LogType.Error);
+        return;
+    }
+
+    if (target.__internalAwake) {
+        // this is the hidden key we save the original property to
+        const $prop = Symbol(propertyKey);
+        // save the original awake method
+        // we need to delay decoration until the object has been created
+        const awake = target.__internalAwake;
+        target.__internalAwake = function () {
+
+            // only build wrapper once per type
+            if (this[$prop] === undefined) {
+
+                // make sure the field is initialized in a hidden property
+                this[$prop] = this[propertyKey];
+
+                Object.defineProperty(this, propertyKey, {
+                    set: function (v) {
+                        if (this[$isAssigningProperties] === true) {
+                            this[$prop] = v;
+                        }
+                        else {
+                            set?.call(this, v);
+                            const oldValue = this[$prop];
+                            this[$prop] = v;
+                            this.onValidate?.call(this, propertyKey, oldValue);
+                        }
+                    },
+                    get: function () {
+                        get?.call(this);
+                        return this[$prop];
+                    },
+                });
+            }
+
+            // call the original awake method
+            awake.call(this);
+        };
+    }
+}

package/src/engine/engine_utils.ts

@@ -217,7 +217,7 @@ export function getPath(source: SourceIdentifier | undefined, uri: string): stri
 // }
 
 
-export type WriteCallback = (data: any) => void;
+export type WriteCallback = (data: any, prop: string) => void;
 
 export interface IWatch {
     subscribeWrite(callback: WriteCallback);
@@ -226,6 +226,7 @@ export interface IWatch {
     dispose();
 }
 
+
 // TODO: make it possible to add multiple watches to the same object property
 class WatchImpl implements IWatch {
     subscribeWrite(callback: WriteCallback) {
@@ -236,14 +237,14 @@ class WatchImpl implements IWatch {
     constructor(object: object, prop: string) {
         this._object = object;
         this._prop = prop;
-        this._wrapperProp = "__$_NEEDLE_" + prop;
+        this._wrapperProp = Symbol("$" + prop);
         this.apply();
     }
 
     private _applied: boolean = false;
     private _object: any;
     private _prop: string;
-    private _wrapperProp: string;
+    private _wrapperProp: symbol;
 
     apply() {
         if (this._applied) return;
@@ -267,7 +268,7 @@ class WatchImpl implements IWatch {
         const setter = (value) => {
             object[this._wrapperProp] = value;
             for (const write of this.writeCallbacks) {
-                write(value);
+                write(value, this._prop);
             }
         }
         // add the wrapper to the object
@@ -320,7 +321,7 @@ export class Watch implements IWatch {
     apply() {
         for (const w of this._watches) {
             w.apply();
-        }   
+        }
     }
 
     revoke() {

package/src/engine/extensions/EXT_texture_exr.js

@@ -32,7 +32,7 @@ export class EXT_texture_exr {
 		const extension = textureDef.extensions[ name ];
 
 		// TODO should the loader be cached here?
-		let loader = new EXRLoader(parser.options.manager);
+		const loader = new EXRLoader(parser.options.manager);
 
 		if(debug) console.log("EXT_texture_exr.loadTexture", extension, loader);
 

package/src/engine/extensions/NEEDLE_animator_controller_model.ts

@@ -97,7 +97,7 @@ export declare type Motion = {
     action_loopback?: AnimationAction,
 }
 
-export function createMotion(name:string, id? : InstantiateIdProvider): Motion {
+export function createMotion(name: string, id?: InstantiateIdProvider): Motion {
     return {
         name: "",
         isLooping: false,
@@ -123,6 +123,7 @@ export declare type Transition = {
     hasExitTime: number,
     destinationState: number | State,
     conditions: Condition[],
+    // isAny?: boolean
 }
 
 export declare type Condition = {

package/src/engine/extensions/NEEDLE_gameobject_data.ts

@@ -66,6 +66,8 @@ export class NEEDLE_gameobject_data implements GLTFLoaderPlugin {
 
     private applyExtensionData(node: Object3D, ext: GameObjectData) {
         node.userData.layer = ext.layers;
+        node.layers.disableAll();
+        node.layers.set(ext.layers);
         node.userData.tag = ext.tag;
         node.userData.hideFlags = ext.hideFlags;
         node.userData.static = ext.static;

package/src/engine/extensions/NEEDLE_techniques_webgl.ts

@@ -203,6 +203,9 @@ export class CustomShader extends RawShaderMaterial {
         if (this.uniforms["_TimeParameters"]) {
             this.uniforms["_TimeParameters"].value = context.rendererData.timeVec4;
         }
+        else if (this.uniforms["_Time"]) {
+            this.uniforms["_Time"].value = context.rendererData.timeVec4;
+        }
 
         const mainLight: ILight | null = context.mainLight;
         if (mainLight) {
@@ -327,6 +330,10 @@ export class NEEDLE_techniques_webgl implements GLTFLoaderPlugin {
 
             const uniforms: {} = {};
             const techniqueUniforms = technique.uniforms;
+
+            if (vert.includes("_Time"))
+                uniforms["_Time"] = { value: new THREE.Vector4(0, 0, 0, 0) };
+
             for (const u in techniqueUniforms) {
                 const uniformName = u;
                 // const uniformValues = techniqueUniforms[u];

package/src/engine-components/Animation.ts

@@ -1,9 +1,11 @@
 import { Behaviour } from "./Component";
 import * as THREE from 'three'
-import { AnimationAction, AnimationClip } from "three";
+import { AnimationAction, AnimationClip, Vector2 } from "three";
 import { MixerEvent } from "./Animator";
 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";
 
 export declare class PlayOptions {
     fadeDuration?: number;
@@ -12,6 +14,8 @@ export declare class PlayOptions {
     startTime?: number;
     endTime?: number;
     clampWhenFinished?: boolean;
+    minMaxSpeed?: Vec2;
+    minMaxOffsetNormalized?: Vec2;
 }
 
 export class Animation extends Behaviour {
@@ -21,6 +25,9 @@ export class Animation extends Behaviour {
     @serializeable()
     randomStartTime: boolean = true;
 
+    minMaxSpeed?: Vec2;
+    minMaxOffsetNormalized?: Vec2;
+
     private _tempAnimationClipBeforeGameObjectExisted: AnimationClip | null = null;
     get clip(): AnimationClip | null {
         return this.animations?.length ? this.animations[0] : null;
@@ -120,6 +127,9 @@ export class Animation extends Behaviour {
             console.error("Could not find clip", clipOrNumber)
             return;
         }
+        if (!options) options = {};
+        if (!options.minMaxOffsetNormalized) options.minMaxOffsetNormalized = this.minMaxOffsetNormalized;
+        if (!options.minMaxSpeed) options.minMaxSpeed = this.minMaxSpeed;
         for (const act of this.actions) {
             if (act.getClip() === clip) {
                 return this.internalOnPlay(act, options);
@@ -150,6 +160,9 @@ export class Animation extends Behaviour {
         action.enabled = true;
         action.time = 0;
         action.timeScale = 1;
+        const clip = action.getClip();
+        if (options?.minMaxOffsetNormalized) action.time = Mathf.lerp(options.minMaxOffsetNormalized.x, options.minMaxOffsetNormalized.y, Math.random()) * clip.duration;
+        if (options?.minMaxSpeed) action.timeScale = Mathf.lerp(options.minMaxSpeed.x, options.minMaxSpeed.y, Math.random());
         if (options?.clampWhenFinished) action.clampWhenFinished = true;
         if (options?.startTime !== undefined) action.time = options.startTime;
 

package/src/engine-components/AnimatorController.ts

@@ -188,6 +188,8 @@ export class AnimatorController {
 
     private evaluateTransitions() {
 
+        const currentLayer = 0;
+
         let didEnterStateThisFrame = false;
         if (!this._activeState) {
             this.setStartTransition();
@@ -200,8 +202,11 @@ export class AnimatorController {
         let index = 0;
         for (const transition of state.transitions) {
             ++index;
-            // transition without exit time and without condition are ignored
-            if (!transition.hasExitTime && transition.conditions.length <= 0) continue;
+            // transition without exit time and without condition that transition to itself are ignored
+            if (!transition.hasExitTime && transition.conditions.length <= 0) {
+                // if (this._activeState && this.getState(transition.destinationState, currentLayer)?.hash === this._activeState.hash)
+                    continue;
+            }
 
             let allConditionsAreMet = true;
             for (const cond of transition.conditions) {
@@ -213,7 +218,7 @@ export class AnimatorController {
             if (!allConditionsAreMet) continue;
 
             if (debug && allConditionsAreMet) {
-                console.log("All conditions are met", transition.conditions, action);
+                console.log("All conditions are met", transition);
             }
 
             // disable triggers
@@ -279,17 +284,22 @@ export class AnimatorController {
 
     }
 
+    private getState(state : State | number, layerIndex:number) : State | null {
+        if (typeof state === "number") {
+            if (state == -1) state = this.model.layers[layerIndex].stateMachine.defaultState; // exit state -> entry state
+            state = this.model.layers[layerIndex].stateMachine.states[state];
+        }
+        return state;
+    }
+
     private transitionTo(state: State | number, durationInSec: number, offsetNormalized: number) {
 
         if (!this.animator) return;
 
         const layerIndex = 0;
 
-        if (typeof state === "number") {
-            if (state == -1) state = this.model.layers[layerIndex].stateMachine.defaultState; // exit state -> entry state
-            state = this.model.layers[layerIndex].stateMachine.states[state];
-        }
-
+        state = this.getState(state, layerIndex) as State;
+        
         if (!state?.motion || !state.motion.clip) {
             // if(debug) console.warn("State has no clip or motion", state);
             return;
@@ -409,7 +419,7 @@ export class AnimatorController {
             const sm = layer.stateMachine;
             for (let index = 0; index < sm.states.length; index++) {
                 const state = sm.states[index];
-                
+
                 // ensure we have a motion even if none was exported
                 if (!state.motion) {
                     state.motion = createMotion(state.name);