@needle-tools/engine 2.36.0-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,7 +3,7 @@ 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";
@@ -11,6 +11,7 @@ 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 };
@@ -516,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) */
@@ -540,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;
@@ -550,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);

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,8 +100,8 @@ export declare interface ILight extends IComponent {
 }
 
 export declare interface ISharedMaterials {
-    [num:number] : Material;
-    get length() : number;
+    [num: number]: Material;
+    get length(): number;
 }
 
 export declare interface IRenderer extends IComponent {
@@ -110,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;
@@ -117,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) {
@@ -187,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_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);
@@ -268,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
@@ -321,7 +321,7 @@ export class Watch implements IWatch {
     apply() {
         for (const w of this._watches) {
             w.apply();
-        }   
+        }
     }
 
     revoke() {

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-components/Animation.ts

@@ -5,6 +5,7 @@ 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;
@@ -13,8 +14,8 @@ export declare class PlayOptions {
     startTime?: number;
     endTime?: number;
     clampWhenFinished?: boolean;
-    minMaxSpeed?: Vector2;
-    minMaxOffsetNormalized?: Vector2;
+    minMaxSpeed?: Vec2;
+    minMaxOffsetNormalized?: Vec2;
 }
 
 export class Animation extends Behaviour {
@@ -24,11 +25,8 @@ export class Animation extends Behaviour {
     @serializeable()
     randomStartTime: boolean = true;
 
-    @serializeable(Vector2)
-    minMaxSpeed?: Vector2;
-
-    @serializeable(Vector2)
-    minMaxOffsetNormalized?: Vector2;
+    minMaxSpeed?: Vec2;
+    minMaxOffsetNormalized?: Vec2;
 
     private _tempAnimationClipBeforeGameObjectExisted: AnimationClip | null = null;
     get clip(): AnimationClip | null {
@@ -129,9 +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;
+        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);
@@ -163,8 +161,8 @@ export class Animation extends Behaviour {
         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?.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/BoxHelperComponent.ts

@@ -55,6 +55,7 @@ export class BoxHelperComponent extends Behaviour {
         // this.tp.applyMatrix4(obj.matrixWorld);
         // console.log(this.tp);
         // console.log(this.box?.min, this.box?.max, this.tp.min, this.tp.max);
+        this.updateBox();
         return this.box?.intersectsBox(BoxHelperComponent.testBox);
     }
 

package/src/engine-components/Collider.ts

@@ -1,8 +1,7 @@
 import { Behaviour } from "./Component";
 import { Rigidbody } from "./RigidBody";
 import { serializeable } from "../engine/engine_serialization_decorator";
-import { Event, Object3D, Vector3 } from "three"
-import { Shape } from "cannon-es";
+import { Event, Mesh, Object3D, Vector3 } from "three"
 import { IColliderProvider, registerColliderProvider } from "../engine/engine_physics";
 import { ICollider } from "../engine/engine_types";
 import { getComponentInChildren } from "../engine/engine_components";
@@ -25,14 +24,14 @@ export class Collider extends Behaviour implements ICollider {
     @serializeable()
     isTrigger: boolean = false;
 
-    protected _shape: Shape | null = null;
 
     awake() {
         super.awake();
-        this._shape = null;
+        if (!this.attachedRigidbody)
+            this.attachedRigidbody = this.gameObject.getComponentInParent(Rigidbody);
     }
 
-    start(){
+    start() {
         if (!this.attachedRigidbody)
             this.attachedRigidbody = this.gameObject.getComponentInParent(Rigidbody);
     }
@@ -44,9 +43,7 @@ export class Collider extends Behaviour implements ICollider {
     }
 
     onDisable() {
-        if (this._shape) {
-
-        }
+        this.context.physics.removeBody(this);
     }
 
 }
@@ -61,14 +58,8 @@ export class SphereCollider extends Collider {
 
     onEnable() {
         super.onEnable();
-        if (!this._shape)
-            this._shape = this.context.physics.addSphereCollider(this.gameObject, this.center, this.radius, this.attachedRigidbody);
+        this.context.physics.addSphereCollider(this, this.center, this.radius);
     }
-
-    // onDisable() {
-    //     // if (this._shape)
-    //     //     this.context.physics.removeShape(this.gameObject, this._shape);
-    // }
 }
 
 export class BoxCollider extends Collider {
@@ -80,22 +71,31 @@ export class BoxCollider extends Collider {
 
     onEnable() {
         super.onEnable();
-        if (!this._shape)
-            this._shape = this.context.physics.addBoxCollider(this.gameObject, this.isTrigger, this.center, this.size, this.attachedRigidbody);
+        this.context.physics.addBoxCollider(this, this.center, this.size);
     }
-
-    // onDisable() {
-    //     // if (this._shape) {
-    //     //     this.context.physics.removeShape(this.gameObject, this._shape);
-    //     // }
-    // }
 }
 
 
-// export class MeshCollider extends Collider {
+export class MeshCollider extends Collider {
 
-//     onEnable() {
-//         if (this.enabled)
-//             this.context.physics.addMeshCollider(this.gameObject);
-//     }
-// }
+
+    sharedMesh?: Mesh;
+    @serializeable()
+    convex: boolean = false;
+
+    awake(){
+        console.log(this);
+    }
+
+    onEnable() {
+        super.onEnable();
+        if (!this.sharedMesh?.isMesh) {
+            // HACK using the renderer mesh
+            if (this.gameObject instanceof Mesh) {
+                this.sharedMesh = this.gameObject;
+            }
+        }
+        if (this.sharedMesh?.isMesh)
+            this.context.physics.addMeshCollider(this, this.sharedMesh, this.convex);
+    }
+}