@needle-tools/engine 2.65.2-pre → 2.67.0-pre

package/src/engine/extensions/extensions.ts

@@ -8,11 +8,26 @@ import { NEEDLE_gameobject_data } from "./NEEDLE_gameobject_data";
 import { NEEDLE_persistent_assets } from "./NEEDLE_persistent_assets";
 // import { KHR_animation_pointer } from "./KHR_animation_pointer";
 import { NEEDLE_lightmaps } from "../extensions/NEEDLE_lightmaps";
-import { SourceIdentifier } from "../engine_types";
+import { Constructor, ConstructorConcrete, SourceIdentifier } from "../engine_types";
 import { Context } from "../engine_setup";
 import { NEEDLE_lighting_settings } from "./NEEDLE_lighting_settings";
 import { NEEDLE_render_objects } from "./NEEDLE_render_objects";
 import { NEEDLE_progressive } from "./NEEDLE_progressive";
+import { InternalUsageTrackerPlugin } from "./usage_tracker";
+import { isUsageTrackingEnabled } from "../engine_assetdatabase";
+import { GLTFLoaderPlugin } from "three/examples/jsm/loaders/GLTFLoader";
+
+const _addedCustomExtension = new Array<ConstructorConcrete<GLTFLoaderPlugin>>();
+
+export function addCustomExtension(ext: ConstructorConcrete<GLTFLoaderPlugin>) {
+    if (!_addedCustomExtension.includes(ext))
+        _addedCustomExtension.push(ext);
+}
+export function removeCustomExtension(ext: ConstructorConcrete<GLTFLoaderPlugin>) {
+    const index = _addedCustomExtension.indexOf(ext);
+    if (index >= 0)
+        _addedCustomExtension.splice(index, 1);
+}
 
 export function registerComponentExtension(loader: GLTFLoader): NEEDLE_components {
     const ext = new NEEDLE_components();
@@ -23,6 +38,8 @@ export function registerComponentExtension(loader: GLTFLoader): NEEDLE_component
     return ext;
 }
 
+
+
 class PointerResolver {
     resolvePath(path: string) {
         if (path.includes('/extensions/builtin_components/'))
@@ -42,6 +59,10 @@ export function registerExtensions(loader: GLTFLoader, context: Context, sourceI
     loader.register(p => new NEEDLE_render_objects(p, sourceId));
     loader.register(p => new NEEDLE_progressive(p, sourceId, context));
     loader.register(p => new EXT_texture_exr(p));
+    if (isUsageTrackingEnabled()) loader.register(p => new InternalUsageTrackerPlugin(p))
+
+    for (const ext of _addedCustomExtension)
+        loader.register(p => new ext(p));
 
     const setPointerResolverFunction = loader["setAnimationPointerResolver"];
     if (typeof setPointerResolverFunction === "function")

package/src/engine/extensions/usage_tracker.ts

@@ -0,0 +1,91 @@
+
+import { GLTF, GLTFLoaderPlugin, GLTFParser } from "three/examples/jsm/loaders/GLTFLoader";
+import { Group, Mesh, Object3D, SkinnedMesh } from "three";
+import { getParam } from "../engine_utils";
+
+
+const $loadingId = Symbol("gltf-loader-internal-usage-tracker");
+const debug = getParam("debugusers");
+
+export class InternalUsageTrackerPlugin implements GLTFLoaderPlugin {
+
+    static isLoading(object: object) {
+        return InternalUsageTrackerPlugin._loadingProcesses > 0;
+        return object[$loadingId] !== undefined;
+    }
+    private static _loadingProcesses = 0;
+
+    private readonly parser: GLTFParser;
+    private readonly _getDependency: any;
+    private readonly _loadingId: string;
+    private _loadedObjects: Set<object> = new Set();
+
+    constructor(parser: GLTFParser) {
+        this.parser = parser;
+        this._getDependency = this.parser.getDependency;
+        this._loadingId = Date.now().toString()
+    }
+
+    beforeRoot() {
+        InternalUsageTrackerPlugin._loadingProcesses++;
+        const self = this;
+        // Patch parser get dependency to track all objects that have been loaded or created
+        const getDependency = this._getDependency;
+        this.parser.getDependency = function (type: string, index: number) {
+            const promise = getDependency.call(this, type, index);
+            promise.then((result) => {
+                if (result) {
+                    self._loadedObjects.add(result);
+                    result[$loadingId] = self._loadingId;
+                }
+                return result;
+            });
+            return promise;
+        };
+        return null;
+    }
+
+    afterRoot(_result: GLTF) {
+        InternalUsageTrackerPlugin._loadingProcesses--;
+        // reset original method
+        this.parser.getDependency = this._getDependency;
+
+        // Cleanup usage of objects that have not been used in a scene
+        for (const loaded of this._loadedObjects) {
+            delete loaded[$loadingId];
+
+            if (loaded instanceof Object3D) {
+                if (!loaded.parent) {
+                    if (loaded instanceof Mesh) {
+                        if (debug) console.warn("> GLTF LOADER: Mesh not used in scene!", loaded);
+                        loaded.material = null;
+                        loaded.geometry = null;
+                    }
+                }
+            }
+        }
+        return null;
+    }
+
+
+
+
+
+    // private readonly _creatingNodeMesh: Map<number, CreateNodeMesh> = new Map();
+
+    // createNodeMesh(_nodeIndex: number): CreateNodeMesh | null {
+    //     // if (!this.parser) return null;
+    //     // let process = this._creatingNodeMesh.get(nodeIndex);
+    //     // if (process) return process;
+
+    //     // process = this.parser.createNodeMesh(nodeIndex)?.then((mesh) => {
+    //     //     console.log("createNodeMesh", nodeIndex, mesh);
+    //     //     return mesh;
+    //     // }) as CreateNodeMesh;
+    //     // this._creatingNodeMesh.set(nodeIndex, process);
+    //     // return process;
+    // }
+
+
+}
+

package/src/engine-components/Animator.ts

@@ -73,7 +73,6 @@ export class Animator extends Behaviour {
     /**@deprecated use getBool */
     GetBool(name: string | number) { return this.getBool(name); }
     getBool(name: string | number): boolean {
-        console.log("name", name);
         return this.runtimeAnimatorController?.getBool(name) ?? false;
     }
 

package/src/engine-components/AnimatorController.ts

@@ -768,6 +768,7 @@ class RootMotionAction {
     }
 
     onAfterUpdate() {
+        if (!this.action) return;
         const weight = this.action.getEffectiveWeight();
         this.positionChange.multiplyScalar(weight);
         this.rotationChange.slerp(RootMotionAction.identityQuaternion, 1 - weight);
@@ -836,6 +837,7 @@ class RootMotionHandler {
 
     private findRootTrack(clip: AnimationClip, name: string) {
         const tracks = clip.tracks;
+        if (!tracks) return null;
         for (const track of tracks) {
             if (track.name.endsWith(name)) {
                 // if (track.name.includes("Hips"))

package/src/engine-components/AudioSource.ts

@@ -65,7 +65,7 @@ export class AudioSource extends Behaviour {
             if (fn == undefined) return;
             if (AudioSource._userInteractionRegistered) return;
             AudioSource._userInteractionRegistered = true;
-            console.log("registered interaction, can play audio now");
+            if(debug) console.log("🔊 registered interaction, can play audio now");
             document.removeEventListener('pointerdown', fn);
             document.removeEventListener('click', fn);
             document.removeEventListener('dragstart', fn);

package/src/engine-components/Camera.ts

@@ -5,11 +5,12 @@ import { RGBAColor } from "./js-extensions/RGBAColor";
 import { Context, XRSessionMode } from "../engine/engine_setup";
 import { ICamera } from "../engine/engine_types"
 import { showBalloonMessage } from "../engine/debug/debug";
-import { getWorldPosition } from "../engine/engine_three_utils";
+import { getWorldPosition, Graphics } from "../engine/engine_three_utils";
 import { Gizmos } from "../engine/engine_gizmos";
 
 import { EquirectangularReflectionMapping, OrthographicCamera, PerspectiveCamera, Ray, sRGBEncoding, Vector3 } from "three";
 import { OrbitControls } from "./OrbitControls";
+import { RenderTexture } from "../engine/engine_texture";
 
 export enum ClearFlags {
     Skybox = 1,
@@ -151,6 +152,15 @@ export class Camera extends Behaviour implements ICamera {
         this.applyClearFlagsIfIsActiveCamera();
     }
 
+    @serializable(RenderTexture)
+    public set targetTexture(rt: RenderTexture | null) {
+        this._targetTexture = rt;
+    }
+    public get targetTexture(): RenderTexture | null {
+        return this._targetTexture;
+    }
+    private _targetTexture: RenderTexture | null = null;
+
     private _backgroundColor?: RGBAColor;
     private _fov?: number;
     private _cam: THREE.PerspectiveCamera | THREE.OrthographicCamera | null = null;
@@ -217,6 +227,28 @@ export class Camera extends Behaviour implements ICamera {
         this.context.removeCamera(this);
     }
 
+    onBeforeRender() {
+        if (this._cam) {
+            if (this._targetTexture) {
+                if (this.context.isManagedExternally) {
+                    // TODO: rendering with r3f renderer does throw an shader error for some reason?
+                    if (!this["_warnedAboutExternalRenderer"]) {
+                        this["_warnedAboutExternalRenderer"] = true;
+                        console.warn("Rendering with external renderer is not supported yet. This may not work or throw errors. Please remove the the target texture from your camera: " + this.name, this.targetTexture)
+                    }
+                }
+
+                // TODO: optimize to not render twice if this is already the main camera. In that case we just want to blit
+                const composer = this.context.composer;
+                const useNormalRenderer = true;// this.context.isInXR || !composer;
+                const renderer = useNormalRenderer ? this.context.renderer : composer;
+                if (renderer) {
+                    this._targetTexture.render(this.context.scene, this._cam, renderer)
+                }
+            }
+        }
+    }
+
     buildCamera() {
         if (this._cam) return;
 
@@ -262,43 +294,51 @@ export class Camera extends Behaviour implements ICamera {
     }
 
     applyClearFlagsIfIsActiveCamera() {
+        if (this.context.mainCameraComponent === this) {
+            this.applyClearFlags();
+        }
+    }
+
+    applyClearFlags() {
+        if (!this._cam) {
+            if (debug) console.log("Camera does not exist (apply clear flags)")
+            return;
+        }
         if (debug)
-            showBalloonMessage("apply Camera clear flags");
-        if (this._cam && this.context.mainCameraComponent === this) {
-            switch (this._clearFlags) {
-                case ClearFlags.Skybox:
-                    if (Camera.backgroundShouldBeTransparent(this.context)) {
-                        if (!this.ARBackgroundAlpha || this.ARBackgroundAlpha < 0.001) {
-                            this.context.scene.background = null;
-                            this.context.renderer.setClearColor(0x000000, 0);
-                            return;
-                        }
-                    }
-                    this.enableSkybox();
-
-                    if (this._backgroundBlurriness !== undefined)
-                        this.context.scene.backgroundBlurriness = this._backgroundBlurriness;
-                    if (this._backgroundIntensity !== undefined)
-                        //@ts-ignore
-                        this.context.scene.backgroundIntensity = this._backgroundIntensity;
-
-                    break;
-                case ClearFlags.SolidColor:
-                    if (this._backgroundColor) {
-                        let alpha = this._backgroundColor.alpha;
-                        // when in WebXR use ar background alpha override or set to 0
-                        if (Camera.backgroundShouldBeTransparent(this.context)) {
-                            alpha = this.ARBackgroundAlpha ?? 0;
-                        }
+            showBalloonMessage("apply Camera clear flags: " + this._clearFlags);
+        switch (this._clearFlags) {
+            case ClearFlags.Skybox:
+                if (Camera.backgroundShouldBeTransparent(this.context)) {
+                    if (!this.ARBackgroundAlpha || this.ARBackgroundAlpha < 0.001) {
                         this.context.scene.background = null;
-                        this.context.renderer.setClearColor(this._backgroundColor, alpha);
+                        this.context.renderer.setClearColor(0x000000, 0);
+                        return;
                     }
-                    break;
-                case ClearFlags.Uninitialized:
-                    this.context.scene.background = null
-                    this.context.renderer.setClearColor(0x000000, 0);
-                    break;
-            }
+                }
+                this.enableSkybox();
+
+                if (this._backgroundBlurriness !== undefined)
+                    this.context.scene.backgroundBlurriness = this._backgroundBlurriness;
+                if (this._backgroundIntensity !== undefined)
+                    //@ts-ignore
+                    this.context.scene.backgroundIntensity = this._backgroundIntensity;
+
+                break;
+            case ClearFlags.SolidColor:
+                if (this._backgroundColor) {
+                    let alpha = this._backgroundColor.alpha;
+                    // when in WebXR use ar background alpha override or set to 0
+                    if (Camera.backgroundShouldBeTransparent(this.context)) {
+                        alpha = this.ARBackgroundAlpha ?? 0;
+                    }
+                    this.context.scene.background = null;
+                    this.context.renderer.setClearColor(this._backgroundColor, alpha);
+                }
+                break;
+            case ClearFlags.Uninitialized:
+                this.context.scene.background = null
+                this.context.renderer.setClearColor(0x000000, 0);
+                break;
         }
     }
 
@@ -309,7 +349,7 @@ export class Camera extends Behaviour implements ICamera {
     }
 
     /** Returns true when in XR on a pass through device where the background shouldbe invisible */
-    static backgroundShouldBeTransparent(context:Context) {
+    static backgroundShouldBeTransparent(context: Context) {
         const session = context.renderer.xr?.getSession();
         if (!session) return false;
         const environmentBlendMode = session.environmentBlendMode;
@@ -330,7 +370,7 @@ export class Camera extends Behaviour implements ICamera {
                 }
             }
         }
-        
+
         return transparent;
     }
 }

package/src/engine-components/CharacterController.ts

@@ -86,6 +86,9 @@ export class CharacterControllerInput extends Behaviour {
     @serializable()
     jumpForce: number = 1;
 
+    @serializable()
+    doubleJumpForce: number = 2;
+
     @serializable(Animator)
     animator?: Animator;
 
@@ -106,7 +109,7 @@ export class CharacterControllerInput extends Behaviour {
 
         if (this.controller?.isGrounded) {
             this._jumpCount = 0;
-            this.animator?.SetBool("doubleJump", false);
+            if (this.doubleJumpForce > 0) this.animator?.setBool("doubleJump", false);
         }
 
         const forward = this.context.input.isKeyPressed("w");
@@ -121,8 +124,8 @@ export class CharacterControllerInput extends Behaviour {
         this._currentSpeed.z += step * this.movementSpeed * this.context.time.deltaTime;
 
         // if (!this.controller || this.controller.isGrounded)
-        this.animator?.SetBool("running", step != 0);
-        this.animator?.SetBool("jumping", this.controller?.isGrounded === true && jump);
+        this.animator?.setBool("running", step != 0);
+        this.animator?.setBool("jumping", this.controller?.isGrounded === true && jump);
 
         this._temp.copy(this._currentSpeed);
         this._temp.applyQuaternion(this.gameObject.quaternion);
@@ -146,9 +149,9 @@ export class CharacterControllerInput extends Behaviour {
 
         if (this.controller && jump && this.jumpForce > 0) {
             let canJump = this.controller?.isGrounded;
-            if (!this.controller?.isGrounded && this._jumpCount === 1) {
+            if (this.doubleJumpForce > 0 && !this.controller?.isGrounded && this._jumpCount === 1) {
                 canJump = true;
-                this.animator?.SetBool("doubleJump", true);
+                this.animator?.setBool("doubleJump", true);
             }
 
             if (canJump) {
@@ -156,8 +159,8 @@ export class CharacterControllerInput extends Behaviour {
                 // TODO: factor in mass
                 const rb = this.controller.rigidbody;
                 // const fullJumpHoldLength = .1;
-                const factor = this._jumpCount === 2 ? 2 : 1;// Mathf.clamp((this.context.time.time - this._jumpDownTime), 0, fullJumpHoldLength) / fullJumpHoldLength;
-                rb.applyImpulse(new Vector3(0, 1, 0).multiplyScalar(this.jumpForce * factor));
+                const factor = this._jumpCount === 2 ? this.doubleJumpForce : this.jumpForce;// Mathf.clamp((this.context.time.time - this._jumpDownTime), 0, fullJumpHoldLength) / fullJumpHoldLength;
+                rb.applyImpulse(new Vector3(0, 1, 0).multiplyScalar(factor));
             }
         }
 
@@ -174,10 +177,10 @@ export class CharacterControllerInput extends Behaviour {
                 const hits = this.context.physics.raycast(this._raycastOptions);
                 this.gameObject.layers.set(currentLayer);
                 if ((hits.length && hits[0].distance > 2 || verticalSpeed < -10)) {
-                    this.animator?.SetBool("falling", true);
+                    this.animator?.setBool("falling", true);
                 }
             }
-            else this.animator?.SetBool("falling", false);
+            else this.animator?.setBool("falling", false);
         }
     }
 

package/src/engine-components/Collider.ts

@@ -1,7 +1,7 @@
 import { Behaviour } from "./Component";
 import { Rigidbody } from "./RigidBody";
 import { serializable } from "../engine/engine_serialization_decorator";
-import { Event, Mesh, Object3D, Vector3 } from "three"
+import { Event, Group, Mesh, Object3D, Vector3 } from "three"
 // import { IColliderProvider, registerColliderProvider } from "../engine/engine_physics";
 import { ICollider } from "../engine/engine_types";
 import { getWorldScale } from "../engine/engine_three_utils";
@@ -77,6 +77,7 @@ export class MeshCollider extends Collider {
 
 
     sharedMesh?: Mesh;
+
     @serializable()
     convex: boolean = false;
 
@@ -88,8 +89,21 @@ export class MeshCollider extends Collider {
                 this.sharedMesh = this.gameObject;
             }
         }
-        if (this.sharedMesh?.isMesh)
+        if (this.sharedMesh?.isMesh) {
             this.context.physics.addMeshCollider(this, this.sharedMesh, this.convex, getWorldScale(this.gameObject));
+        }
+        else {
+            const group = this.sharedMesh as any as Group;
+            if (group?.isGroup) {
+                console.warn(`MeshCollider mesh is a group \"${this.sharedMesh?.name}\", adding all children as colliders. This is currently not fully supported (colliders can not be removed from world again)`, this)
+                for (const ch in group.children) {
+                    const child = group.children[ch] as Mesh;
+                    if (child.isMesh) {
+                        this.context.physics.addMeshCollider(this, child, this.convex, getWorldScale(this.gameObject));
+                    }
+                }
+            }
+        }
     }
 }