@needle-tools/engine 2.38.0-pre.2 → 2.40.0-pre

package/src/engine/engine_three_utils.ts

@@ -1,31 +1,7 @@
 import * as THREE from "three";
 import { Mathf } from "./engine_math"
 import { Vector3, Quaternion, Uniform } from "three";
-
-class CircularBuffer<T> {
-    private _factory: () => T;
-    private _cache: T[] = [];
-    private _maxSize: number;
-    private _index: number = 0;
-
-    constructor(factory: () => T, maxSize: number) {
-        this._factory = factory;
-        this._maxSize = maxSize;
-    }
-
-    get(): T {
-        let i = this._index++;
-        if (i >= this._cache.length) {
-            if (i >= this._maxSize) {
-                i = this._index = 0;
-            }
-            else {
-                this._cache.push(this._factory());
-            }
-        }
-        return this._cache[i];
-    }
-}
+import { CircularBuffer } from "./engine_utils";
 
 
 
@@ -39,10 +15,6 @@ export function lookAtInverse(obj: THREE.Object3D, target: Vector3) {
 
 const _worldPositions = new CircularBuffer(() => new THREE.Vector3(), 100);
 
-
-
-
-
 export function getWorldPosition(obj: THREE.Object3D, vec: THREE.Vector3 | null = null, updateParents: boolean = true): THREE.Vector3 {
     const wp = vec ?? _worldPositions.get();
     if (!obj) return wp.set(0, 0, 0);

package/src/engine/engine_types.ts

@@ -1,6 +1,8 @@
 import { Camera, Color, Material, Object3D, Vector3, Quaternion } from "three";
 import { RGBAColor } from "../engine-components/js-extensions/RGBAColor";
 import { CollisionDetectionMode, RigidbodyConstraints } from "./engine_physics.types";
+import { getWorldPosition } from "./engine_three_utils";
+import { CircularBuffer } from "./engine_utils";
 
 /** 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;
@@ -40,7 +42,7 @@ export interface IComponent {
     get name(): string;
     get layer(): number;
     get destroyed(): boolean;
-    get tag() : string;
+    get tag(): string;
 
     context: any;
 
@@ -84,7 +86,7 @@ export interface IComponent {
 
 
 export declare interface ICamera extends IComponent {
-    get isCamera() : boolean;
+    get isCamera(): boolean;
     applyClearFlagsIfIsActiveCamera(): unknown;
     buildCamera();
     get cam(): Camera;
@@ -147,34 +149,51 @@ export declare type ICollisionContext = {
 }
 
 
+export type Vec2 = {
+    x: number,
+    y: number
+}
+
 export type Vec3 = {
     x: number,
     y: number,
     z: number
 }
 
-export type Vec2 = {
-    x: number,
-    y: number
-}
+const contactsVectorBuffer = new CircularBuffer(() => new Vector3(), 20);
 
 export class ContactPoint {
 
-    readonly localPoint: Vec3;
+    private readonly _point: Vec3;
+    private readonly _normal: Vec3;
+
     readonly distance: number;
-    readonly normal: Vec3;
+    readonly impulse: number;
+    readonly friction: number;
 
-    constructor(localPt: Vec3, dist: number, normal: Vec3) {
-        this.localPoint = localPt;
-        this.distance = dist;
-        this.normal = normal;
+    /** worldspace point */
+    get point() {
+        const target = contactsVectorBuffer.get();
+        return target.set(this._point.x, this._point.y, this._point.z);
+    }
+
+    /** worldspace normal */
+    get normal() {
+        const target = contactsVectorBuffer.get();
+        return target.set(this._normal.x, this._normal.y, this._normal.z);
     }
 
+    constructor(point: Vec3, dist: number, normal: Vec3, impulse: number, friction: number) {
+        this._point = point;
+        this.distance = dist;
+        this._normal = normal;
+        this.impulse = impulse;
+        this.friction = friction;
+    }
 }
 
 /// all info in here must be readonly because the object is only created once per started collision
 export class Collision {
-
     readonly contacts: ContactPoint[];
 
     constructor(obj: Object3D, otherCollider: ICollider, contacts: ContactPoint[]) {
@@ -203,7 +222,7 @@ export class Collision {
         return this.collider?.attachedRigidbody;
     }
 
-    
+
 
     // private _normal?: Vector3;
     // get normal(): Vector3 {

package/src/engine/engine_utils.ts

@@ -14,6 +14,33 @@ export function isDebugMode(): boolean {
 
 
 
+export class CircularBuffer<T> {
+    private _factory: () => T;
+    private _cache: T[] = [];
+    private _maxSize: number;
+    private _index: number = 0;
+
+    constructor(factory: () => T, maxSize: number) {
+        this._factory = factory;
+        this._maxSize = maxSize;
+    }
+
+    get(): T {
+        let i = this._index++;
+        if (i >= this._cache.length) {
+            if (i >= this._maxSize) {
+                i = this._index = 0;
+            }
+            else {
+                this._cache.push(this._factory());
+            }
+        }
+        return this._cache[i];
+    }
+}
+
+
+
 let saveParams: boolean = false;
 const requestedParams: Array<string> = [];
 setTimeout(() => {

package/src/engine/extensions/NEEDLE_lightmaps.ts

@@ -51,7 +51,7 @@ export class NEEDLE_lightmaps implements GLTFLoaderPlugin {
             const ext: LightmapExtension = extensions[EXTENSION_NAME];
             if (ext) {
                 const arr = ext.textures;
-                if (!arr.length) {
+                if (!arr?.length) {
                     return null;
                 }
                 if (debug)

package/src/engine-components/Component.ts

@@ -309,14 +309,17 @@ class Component implements IComponent, EventTarget {
     /** called on a component with a map of old to new guids (e.g. when instantiate generated new guids and e.g. timeline track bindings needs to remape them) */
     resolveGuids?(guidsMap: GuidsMap): void;
 
-    // TODO: can we not have these and then check in update loop if they are implemented (magick methods) ?
+    /** called once when the component becomes active for the first time */
     awake() { }
-    // update() { }
+    /** called every time when the component gets enabled (this is invoked after awake and before start) */
     onEnable() { }
     onDisable() { }
     onDestroy() {
         this.__destroyed = true;
     }
+    /** called when you decorate fields with the @validate() decorator
+     * @param field the name of the field that was changed
+     */
     onValidate?(prop?: string): void;
     start?(): void;
     earlyUpdate?(): void;
@@ -350,20 +353,35 @@ class Component implements IComponent, EventTarget {
         this.__internalDestroy();
     }
 
+    
+    
+    /** @internal */
     protected __didAwake: boolean = false;
+    
+    /** @internal */
     private __didStart: boolean = false;
+    
+    /** @internal */
     protected __didEnable: boolean = false;
+    
+    /** @internal */
     protected __isEnabled: boolean | undefined = undefined;
+    
+    /** @internal */
     private __destroyed: boolean = false;
-
+    
+    /** @internal */
     get __internalDidAwakeAndStart() { return this.__didAwake && this.__didStart; }
 
-
+    
+    /** @internal */
     constructor() {
         // super();
         this.__internalNewInstanceCreated();
     }
 
+    
+    /** @internal */
     __internalNewInstanceCreated() {
         this.__didAwake = false;
         this.__didStart = false;
@@ -373,6 +391,8 @@ class Component implements IComponent, EventTarget {
         // this.__internalResetsCachedPhysicsData();
     }
 
+    
+    /** @internal */
     __internalAwake() {
         if (this.__didAwake) return;
         // console.log("__internalAwake");
@@ -382,12 +402,16 @@ class Component implements IComponent, EventTarget {
         this.awake();
     }
 
+    
+    /** @internal */
     __internalStart() {
         if (this.__didStart) return;
         this.__didStart = true;
         if (this.start) this.start();
     }
 
+    
+    /** @internal */
     __internalEnable(): boolean {
         if (this.__didEnable) return false;
         // console.trace("INTERNAL ENABLE");
@@ -398,6 +422,7 @@ class Component implements IComponent, EventTarget {
         return true;
     }
 
+    /** @internal */
     __internalDisable() {
         if (!this.__didEnable) return;
         this.__didEnable = false;
@@ -408,6 +433,7 @@ class Component implements IComponent, EventTarget {
         this.__isEnabled = false;
     }
 
+    /** @internal */
     __internalDestroy() {
         if (this.__destroyed) return;
         this.__destroyed = true;

package/src/engine-components/Joints.ts

@@ -13,9 +13,6 @@ export abstract class Joint extends Behaviour {
     private _rigidBody: Rigidbody | null = null;
 
 
-    @serializeable(Vector3)
-    connectedAnchor?: Vector3;
-
     onEnable() {
         if (!this._rigidBody) this._rigidBody = this.gameObject.getComponent(Rigidbody);
         if (this.rigidBody && this.connectedBody)
@@ -24,8 +21,9 @@ export abstract class Joint extends Behaviour {
 
     private *create() {
         yield;
-        if (this.rigidBody && this.connectedBody)
-            this.createJoint(this.rigidBody, this.connectedBody);
+        if (this.rigidBody && this.connectedBody) {
+            this.createJoint(this.rigidBody, this.connectedBody)
+        }
     }
 
     protected abstract createJoint(self: Rigidbody, other: Rigidbody);
@@ -34,7 +32,21 @@ export abstract class Joint extends Behaviour {
 export class FixedJoint extends Joint {
 
     protected createJoint(self: Rigidbody, other: Rigidbody) {
-        if (this.connectedAnchor)
-            this.context.physics.addFixedJoint(self, other, this.connectedAnchor);
+        this.context.physics.addFixedJoint(self, other);
     }
+}
+
+export class HingeJoint extends Joint {
+
+    @serializeable(Vector3)
+    anchor?: Vector3;
+
+    @serializeable(Vector3)
+    axis?: Vector3;
+
+    protected createJoint(self: Rigidbody, other: Rigidbody) {
+        if (this.axis && this.anchor)
+            this.context.physics.addHingeJoint(self, other, this.anchor, this.axis);
+    }
+
 }

package/src/engine-components/Light.ts

@@ -272,7 +272,7 @@ export class Light extends Behaviour implements ILight {
     }
 
     private *_updateLightIntensityInARRoutine() {
-        while (this.context.isInXR) {
+        while (this.context.isInAR) {
             yield;
             this.updateIntensity();
             for (let i = 0; i < 30; i++) yield;

package/src/engine-components/codegen/components.ts

@@ -39,6 +39,7 @@ export { GroundProjectedEnv } from "../GroundProjection";
 export { Interactable } from "../Interactable";
 export { UsageMarker } from "../Interactable";
 export { FixedJoint } from "../Joints";
+export { HingeJoint } from "../Joints";
 export { Light } from "../Light";
 export { LODModel } from "../LODGroup";
 export { LODGroup } from "../LODGroup";