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

package/src/engine/engine_types.ts

@@ -102,6 +102,7 @@ export declare interface ILight extends IComponent {
 
 export declare interface ISharedMaterials {
     [num:number] : Material;
+    get length() : number;
 }
 
 export declare interface IRenderer extends IComponent {

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_utils.ts

@@ -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;

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_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,10 @@
 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";
 
 export declare class PlayOptions {
     fadeDuration?: number;
@@ -12,6 +13,8 @@ export declare class PlayOptions {
     startTime?: number;
     endTime?: number;
     clampWhenFinished?: boolean;
+    minMaxSpeed?: Vector2;
+    minMaxOffsetNormalized?: Vector2;
 }
 
 export class Animation extends Behaviour {
@@ -21,6 +24,12 @@ export class Animation extends Behaviour {
     @serializeable()
     randomStartTime: boolean = true;
 
+    @serializeable(Vector2)
+    minMaxSpeed?: Vector2;
+
+    @serializeable(Vector2)
+    minMaxOffsetNormalized?: Vector2;
+
     private _tempAnimationClipBeforeGameObjectExisted: AnimationClip | null = null;
     get clip(): AnimationClip | null {
         return this.animations?.length ? this.animations[0] : null;
@@ -120,6 +129,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 +162,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);

package/src/engine-components/BoxHelperComponent.ts

@@ -9,12 +9,12 @@ const gizmos = getParam("gizmos");
 export class BoxHelperComponent extends Behaviour {
 
     private box: THREE.Box3 | null = null;
-    private testBox: THREE.Box3 = new THREE.Box3();
+    private static testBox: THREE.Box3 = new THREE.Box3();
     private _lastMatrixUpdateFrame: number = -1;
     private static _position: THREE.Vector3 = new THREE.Vector3();
     private static _size: THREE.Vector3 = new THREE.Vector3(.01, .01, .01);
 
-    public isInBox(obj: THREE.Object3D): boolean | undefined {
+    public isInBox(obj: THREE.Object3D, scaleFactor? : number): boolean | undefined {
         if (!obj) return undefined;
 
         // if (!obj.geometry.boundingBox) obj.geometry.computeBoundingBox();
@@ -23,22 +23,39 @@ export class BoxHelperComponent extends Behaviour {
         if (!this.box) {
             this.box = new THREE.Box3();
         }
-        this.updateBox(false);
 
-        if (obj.type === "Mesh")
-            this.testBox.setFromObject(obj);
+        if (obj.type === "Mesh") {
+            BoxHelperComponent.testBox.setFromObject(obj);
+        }
+        else if (obj.type === "Group") {
+            if (obj.children.length > 0) {
+                BoxHelperComponent.testBox.setFromCenterAndSize(
+                    BoxHelperComponent._position.set(0, 0, 0),
+                    BoxHelperComponent._size.set(0, 0, 0)
+                );
+                for (let i = 0; i < obj.children.length; i++) {
+                    const ch = obj.children[i];
+                    if (ch.type === "Mesh") {
+                        BoxHelperComponent.testBox.expandByObject(obj);
+                    }
+                }
+            }
+        }
         else {
             const wp = getWorldPosition(obj, BoxHelperComponent._position);
             const size = getWorldScale(obj, BoxHelperComponent._size);
-            this.testBox.setFromCenterAndSize(wp, size);
+            if(scaleFactor !== undefined) size.multiplyScalar(scaleFactor);
+            BoxHelperComponent.testBox.setFromCenterAndSize(wp, size);
         }
 
+        // console.log("Obj box:", obj.name, obj.uuid, BoxHelperComponent.testBox.getCenter(new THREE.Vector3()), BoxHelperComponent.testBox.getSize(new THREE.Vector3()),
+        // "\nTest box:", this.box.getCenter(new THREE.Vector3()), this.box.getSize(new THREE.Vector3()), this.context.time.frameCount);
         // this.tp.copy(obj.geometry.boundingBox);
         // // this.tp.setFromCenterAndSize(obj.position, obj.scale);
         // this.tp.applyMatrix4(obj.matrixWorld);
         // console.log(this.tp);
         // console.log(this.box?.min, this.box?.max, this.tp.min, this.tp.max);
-        return this.box?.intersectsBox(this.testBox);
+        return this.box?.intersectsBox(BoxHelperComponent.testBox);
     }
 
     public intersects(box: THREE.Box3): boolean {
@@ -51,9 +68,12 @@ export class BoxHelperComponent extends Behaviour {
             this.box = new THREE.Box3();
         }
         if (force || this.context.time.frameCount != this._lastMatrixUpdateFrame) {
+            const firstUpdate = this._lastMatrixUpdateFrame < 0;
             this._lastMatrixUpdateFrame = this.context.time.frameCount;
-            this.box.setFromCenterAndSize(new THREE.Vector3(0, 0, 0), new THREE.Vector3(1, 1, 1));
-            this.box.applyMatrix4(this.gameObject.matrixWorld);
+            const updateParents: boolean = firstUpdate; // updating parents seems to cause falsely calculated positions sometimes?
+            const wp = getWorldPosition(this.gameObject, BoxHelperComponent._position, updateParents);
+            const size = getWorldScale(this.gameObject, BoxHelperComponent._size);
+            this.box.setFromCenterAndSize(wp, size);
         }
         return this.box;
     }

package/src/engine-components/Component.ts

@@ -8,7 +8,7 @@ import { Object3D } from "three";
 import { syncDestroy, syncInstantiate } from "../engine/engine_networking_instantiate";
 import { ConstructorConcrete, SourceIdentifier, IComponent, IGameObject, Constructor, GuidsMap, UIDProvider, Collision } from "../engine/engine_types";
 import { addNewComponentInstance, destroyComponentInstance, findObjectOfType, findObjectsOfType, getComponent, getComponentInChildren, getComponentInParent, getComponents, getComponentsInChildren, getComponentsInParent, getOrAddComponent, moveComponentInstance, removeComponent } from "../engine/engine_components";
-import { findByGuid, destroy, InstantiateOptions, instantiate, HideFlags, foreachComponent, markAsInstancedRendered, isActiveInHierarchy, isActiveSelf, isUsingInstancing } from "../engine/engine_gameobject";
+import { findByGuid, destroy, InstantiateOptions, instantiate, HideFlags, foreachComponent, markAsInstancedRendered, isActiveInHierarchy, isActiveSelf, isUsingInstancing, setActive } from "../engine/engine_gameobject";
 
 
 // export interface ISerializationCallbackReceiver {
@@ -23,10 +23,10 @@ abstract class GameObject extends THREE.Object3D implements THREE.Object3D, IGam
 
     guid: string | undefined;
 
-    public static setActive(go: THREE.Object3D, active: boolean, processStart: boolean = true) {
+    public static setActive(go: THREE.Object3D, active: boolean, processStart: boolean = true, setVisible: boolean = true) {
         if (!go) return;
-        go.visible = active;
-        main.updateActiveInHierarchyWithoutEventCall(go);
+        setActive(go, active, setVisible);
+        main.updateIsActive(go);
         if (active && processStart)
             main.processStart(Context.Current, go);
     }
@@ -82,10 +82,12 @@ abstract class GameObject extends THREE.Object3D implements THREE.Object3D, IGam
             context = Context.Current;
         }
         parent.add(instance);
-        main.updateActiveInHierarchyWithoutEventCall(instance);
+        setActive(instance, true);
+        main.updateIsActive(instance);
         if (context) {
             GameObject.foreachComponent(instance, (comp: Component) => {
                 main.addScriptToArrays(comp, context!);
+                if(comp.__internalDidAwakeAndStart) return;
                 if (context!.new_script_start.includes(comp) === false) {
                     context!.new_script_start.push(comp as Behaviour);
                 }
@@ -102,6 +104,8 @@ abstract class GameObject extends THREE.Object3D implements THREE.Object3D, IGam
     public static remove(instance: THREE.Object3D | null | undefined) {
         if (!instance) return;
         instance.parent?.remove(instance);
+        setActive(instance, false);
+        main.updateIsActive(instance);
         GameObject.foreachComponent(instance, (comp) => {
             main.processRemoveFromScene(comp);
         }, true);
@@ -354,6 +358,8 @@ class Component implements IComponent, EventTarget {
     protected __isEnabled: boolean | undefined = undefined;
     private __destroyed: boolean = false;
 
+    get __internalDidAwakeAndStart() { return this.__didAwake && this.__didStart; }
+
     __internalNewInstanceCreated() {
         this.__didAwake = false;
         this.__didStart = false;

package/src/engine-components/GroundProjection.ts

@@ -41,12 +41,13 @@ export class GroundProjectedEnv extends Behaviour {
 
 
     onEnable() {
-        this.updateProjection();
-        if (!this._watcher) {
-            this._watcher = new Watch(this.context.scene, "environment");
-            this._watcher.subscribeWrite(this.updateProjection.bind(this));
-        }
-        this._watcher.apply();
+        // TODO: if we do this in the first frame we can not disable it again. Something buggy with the watch?!
+        if (this.context.time.frameCount > 0)
+            this.updateAndCreate();
+    }
+
+    start() {
+        this.updateAndCreate();
     }
 
     onDisable() {
@@ -54,8 +55,22 @@ export class GroundProjectedEnv extends Behaviour {
         this.env?.removeFromParent();
     }
 
+    private updateAndCreate() {
+        this.updateProjection();
+        if (!this._watcher) {
+            this._watcher = new Watch(this.context.scene, "environment");
+            this._watcher.subscribeWrite(_ => {
+                this.updateProjection();
+            });
+        }
+        this._watcher.apply();
+    }
+
     updateProjection() {
-        if (!this.context.scene.environment) return;
+        if (!this.context.scene.environment) {
+            this.env?.removeFromParent();
+            return;
+        }
         if (!this.env || this.context.scene.environment !== this._lastEnvironment) {
             console.log("Create/Update Ground Projection", this.context.scene.environment.name);
             this.env = new GroundProjection(this.context.scene.environment);

package/src/engine-components/ReflectionProbe.ts

@@ -0,0 +1,141 @@
+import { Behaviour } from "./Component";
+import { Box3, Color, EquirectangularReflectionMapping, LineBasicMaterial, Material, MeshStandardMaterial, Object3D, sRGBEncoding, Texture, Vector3, WebGLCubeRenderTarget, WebGLRenderTarget } from "three";
+import { serializeable } from "../engine/engine_serialization";
+import { Context } from "../engine/engine_setup";
+import { getWorldPosition, getWorldScale } from "../engine/engine_three_utils";
+import { IRenderer } from "../engine/engine_types";
+import { BoxHelperComponent } from "./BoxHelperComponent";
+import { getParam } from "../engine/engine_utils";
+
+export const debug = getParam("debugreflectionprobe");
+const disable = getParam("noreflectionprobe");
+
+export class ReflectionProbe extends Behaviour {
+
+    private static _probes: Map<Context, ReflectionProbe[]> = new Map();
+
+    public static get(object: Object3D | null | undefined, context: Context, isAnchor:boolean): ReflectionProbe | null {
+        if (!object || object.isObject3D !== true) return null;
+        if (disable) return null;
+        const probes = ReflectionProbe._probes.get(context);
+        if (probes) {
+            for (const probe of probes) {
+                if (!probe.__didAwake) probe.__internalAwake();
+                if (probe.enabled && probe.isInBox(object, isAnchor ? .00000001 : undefined)) {
+                    if (debug) console.log("Found reflection probe", object.name, probe.name);
+                    return probe;
+                }
+            }
+        }
+        if (debug)
+            console.debug("Did not find reflection probe", object.name, isAnchor, object);
+        return null;
+    }
+
+
+
+    private _texture!: Texture;
+    set texture(tex: Texture) {
+        this._texture = tex;
+    }
+    get texture(): Texture {
+        return this._texture;
+    }
+
+    @serializeable(Vector3)
+    center?: Vector3;
+    @serializeable(Vector3)
+    size?: Vector3;
+
+    private _boxHelper?: BoxHelperComponent;
+
+    private isInBox(obj: Object3D, scaleFactor?: number) {
+        return this._boxHelper?.isInBox(obj, scaleFactor);
+    }
+
+    constructor() {
+        super();
+        if (!ReflectionProbe._probes.has(this.context)) {
+            ReflectionProbe._probes.set(this.context, []);
+        }
+        ReflectionProbe._probes.get(this.context)?.push(this);
+    }
+
+    awake() {
+        this._boxHelper = this.gameObject.addNewComponent(BoxHelperComponent) as BoxHelperComponent;
+        this._boxHelper.updateBox(true);
+        if (debug)
+            this._boxHelper.showHelper(0x555500, true);
+
+        if (this.texture) {
+            this.texture.mapping = EquirectangularReflectionMapping;
+            this.texture.encoding = sRGBEncoding;
+            // this.texture.rotation = Math.PI;
+            // this.texture.flipY = true;
+            this.texture.needsUpdate = true;
+        }
+    }
+
+    onDestroy() {
+        const probes = ReflectionProbe._probes.get(this.context);
+        if (probes) {
+            const index = probes.indexOf(this);
+            if (index >= 0) {
+                probes.splice(index, 1);
+            }
+        }
+    }
+
+
+    // when objects are rendered and they share material
+    // and some need reflection probe and some don't
+    // we need to make sure we don't override the material but use a copy
+
+    private static _rendererMaterialsCache: Map<IRenderer, Array<{ orig: Material, copy: Material }>> = new Map();
+
+    onSet(_rend: IRenderer) {
+        if (disable) return;
+        if (_rend.sharedMaterials?.length <= 0) return;
+        if (!this.texture) return;
+
+        let rendererCache = ReflectionProbe._rendererMaterialsCache.get(_rend);
+        if (!rendererCache) {
+            rendererCache = [];
+            ReflectionProbe._rendererMaterialsCache.set(_rend, rendererCache);
+        }
+
+        // TODO: dont clone material for every renderer that uses reflection probes, we can do it once per material when they use the same reflection texture
+
+        // need to make sure materials are not shared when using reflection probes
+        // otherwise some renderers outside of the probe will be affected or vice versa
+        for (let i = 0; i < _rend.sharedMaterials.length; i++) {
+            const orig = _rend.sharedMaterials[i];
+            if (!orig) continue;
+            if (orig["envMap"] === undefined) continue;
+            let cached = rendererCache[i];
+            let copy = cached?.copy;
+            if (!cached) {
+                const clone = orig.clone();
+                copy = clone;
+                rendererCache.push({ orig, copy });
+
+                copy["__reflection_probe"] = this;
+                copy["envMap"] = this.texture;
+
+                if (debug)
+                    console.log("Set reflection", _rend.name, _rend.guid);
+            }
+            _rend.sharedMaterials[i] = copy;
+        }
+    }
+
+    onUnset(_rend: IRenderer) {
+        const rendererCache = ReflectionProbe._rendererMaterialsCache.get(_rend);
+        if (rendererCache) {
+            for (let i = 0; i < rendererCache.length; i++) {
+                const cached = rendererCache[i];
+                _rend.sharedMaterials[i] = cached.orig;
+            }
+        }
+    }
+}