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

package/src/engine-components/NavMesh.ts

@@ -1,118 +1,117 @@
 
-import { Behaviour, GameObject } from "./Component";
-/*
-import { Pathfinding, PathfindingHelper } from 'three-pathfinding';
-import * as THREE from 'three';
-import { mergeBufferGeometries } from 'three/examples/jsm/utils/BufferGeometryUtils'
-*/
-export class NavMesh extends Behaviour {
-/*
-    public meshes: THREE.Object3D[] = [];
-
-    private pathfinding: Pathfinding | null = null;
-    private zones: string[] = [];
-
-    onEnable(): void {
-
-        this.pathfinding = new Pathfinding();
-        const ZONE = 'zone';
-        const geometries : THREE.BufferGeometry[] = [];
-        if (this.meshes && this.meshes.length > 0) {
-            for (let i = 0; i < this.meshes.length; i++) {
-                const obj = this.meshes[i] as THREE.Mesh;
-                if (!obj) continue;
-                const geo = obj.geometry;
-                if (!geo) continue;
-                const copy : THREE.BufferGeometry = {...geo};
-                // const copy = geo;
-                const attributesCopy = {...copy.attributes};
-                copy.attributes = attributesCopy;
-                if(attributesCopy.uv2) delete attributesCopy.uv2;
-                // copy.applyMatrix4(obj.matrixWorld);
-                geometries.push(copy);
-                // obj.updateMatrixWorld();
-                // singleGeometry.merge(geo);
-                // console.log(singleGeometry, geo);
-            }
-        }
-        const mesh = mergeBufferGeometries(geometries);
-        const zone = Pathfinding.createZone(mesh);
-        const name = ZONE;
-        this.zones.push(name);
-        this.pathfinding.setZoneData(name, zone);
-
-        // const target = new THREE.Vector3(2, 0, 2);
-        // const groupID = this.pathfinding.getGroup(ZONE, target);
-        // const path = this.pathfinding.findPath(this.worldPosition, target, ZONE, groupID);
-        // console.log(path, this.pathfinding);
-    }
-
-    public tryFindPath(from: THREE.Vector3, to: THREE.Vector3): THREE.Vector3[] | null {
-        const zone = this.zones[0];
-        const groupId = this.pathfinding.getGroup(zone, to);
-        const path = this.pathfinding.findPath(from, to, zone, groupId);
-        return path;
-    }
-    */
-}
-
-// import { input } from "../engine/engine_input";
-import { Physics, RaycastOptions } from "../engine/engine_physics"
-// import { time } from "../engine/engine_time";
-// import { scene } from "../engine/engine_setup";
-import { Quaternion } from "math/Quaternion";
-import {SyncedTransform} from "./SyncedTransform";
-
-export class NavMeshAgent extends Behaviour {
-    /*
-    public navMesh: NavMesh | null = null;
-
-    private currentPath: THREE.Vector3[] | null = null;
-    private helper : PathfindingHelper | null = null;
-
-    onEnable(): void {
-        this.helper = new PathfindingHelper();
-        scene.add(this.helper);
-    }
-
-    update(): void {
-        if (input.mouseClick) {
-            if (this.navMesh) {
-                const from = this.worldPosition;
-                const opts = new RaycastOptions();
-                opts.setMask(RaycastOptions.AllLayers);
-                const hits = Physics.raycast(opts);
-                if (hits.length > 0) {
-                    const to = hits[0].point;
-                    this.helper.setPlayerPosition(from);
-                    this.helper.setTargetPosition(to);
-                    this.currentPath = this.navMesh.tryFindPath(from, to);
-                    this.helper.setPath(this.currentPath);
-                    // console.log(...this.currentPath);
-
-                    const sync = GameObject.getComponent(this.gameObject, SyncedTransform);
-                    if(sync) sync.requestOwnership();
-                }
-            }
-        }
-
-        if (this.currentPath && this.currentPath.length > 0) {
-
-            const wp = this.worldPosition;
-            const target = this.currentPath[0];
-            this.worldPosition = wp.lerp(target, time.deltaTime*2);
-
-            this.gameObject.lookAt(target);
-            // const vec = target.clone().sub(wp);
-            // const wr = this.worldQuaternion;
-            // wr.slerp(rot, time.deltaTime*5);
-            // this.worldQuaternion = wr;
-
-            if (wp.distanceTo(this.currentPath[0]) < 0.1)
-                this.currentPath.shift();
+// import { Behaviour, GameObject } from "./Component";
+// /*
+// import { Pathfinding, PathfindingHelper } from 'three-pathfinding';
+// import * as THREE from 'three';
+// import { mergeBufferGeometries } from 'three/examples/jsm/utils/BufferGeometryUtils'
+// */
+// export class NavMesh extends Behaviour {
+// /*
+//     public meshes: THREE.Object3D[] = [];
+
+//     private pathfinding: Pathfinding | null = null;
+//     private zones: string[] = [];
+
+//     onEnable(): void {
+
+//         this.pathfinding = new Pathfinding();
+//         const ZONE = 'zone';
+//         const geometries : THREE.BufferGeometry[] = [];
+//         if (this.meshes && this.meshes.length > 0) {
+//             for (let i = 0; i < this.meshes.length; i++) {
+//                 const obj = this.meshes[i] as THREE.Mesh;
+//                 if (!obj) continue;
+//                 const geo = obj.geometry;
+//                 if (!geo) continue;
+//                 const copy : THREE.BufferGeometry = {...geo};
+//                 // const copy = geo;
+//                 const attributesCopy = {...copy.attributes};
+//                 copy.attributes = attributesCopy;
+//                 if(attributesCopy.uv2) delete attributesCopy.uv2;
+//                 // copy.applyMatrix4(obj.matrixWorld);
+//                 geometries.push(copy);
+//                 // obj.updateMatrixWorld();
+//                 // singleGeometry.merge(geo);
+//                 // console.log(singleGeometry, geo);
+//             }
+//         }
+//         const mesh = mergeBufferGeometries(geometries);
+//         const zone = Pathfinding.createZone(mesh);
+//         const name = ZONE;
+//         this.zones.push(name);
+//         this.pathfinding.setZoneData(name, zone);
+
+//         // const target = new THREE.Vector3(2, 0, 2);
+//         // const groupID = this.pathfinding.getGroup(ZONE, target);
+//         // const path = this.pathfinding.findPath(this.worldPosition, target, ZONE, groupID);
+//         // console.log(path, this.pathfinding);
+//     }
+
+//     public tryFindPath(from: THREE.Vector3, to: THREE.Vector3): THREE.Vector3[] | null {
+//         const zone = this.zones[0];
+//         const groupId = this.pathfinding.getGroup(zone, to);
+//         const path = this.pathfinding.findPath(from, to, zone, groupId);
+//         return path;
+//     }
+//     */
+// }
+
+// // import { input } from "../engine/engine_input";
+// import { Physics, RaycastOptions } from "../engine/engine_physics"
+// // import { time } from "../engine/engine_time";
+// // import { scene } from "../engine/engine_setup";
+// import {SyncedTransform} from "./SyncedTransform";
+
+// export class NavMeshAgent extends Behaviour {
+//     /*
+//     public navMesh: NavMesh | null = null;
+
+//     private currentPath: THREE.Vector3[] | null = null;
+//     private helper : PathfindingHelper | null = null;
+
+//     onEnable(): void {
+//         this.helper = new PathfindingHelper();
+//         scene.add(this.helper);
+//     }
+
+//     update(): void {
+//         if (input.mouseClick) {
+//             if (this.navMesh) {
+//                 const from = this.worldPosition;
+//                 const opts = new RaycastOptions();
+//                 opts.setMask(RaycastOptions.AllLayers);
+//                 const hits = Physics.raycast(opts);
+//                 if (hits.length > 0) {
+//                     const to = hits[0].point;
+//                     this.helper.setPlayerPosition(from);
+//                     this.helper.setTargetPosition(to);
+//                     this.currentPath = this.navMesh.tryFindPath(from, to);
+//                     this.helper.setPath(this.currentPath);
+//                     // console.log(...this.currentPath);
+
+//                     const sync = GameObject.getComponent(this.gameObject, SyncedTransform);
+//                     if(sync) sync.requestOwnership();
+//                 }
+//             }
+//         }
+
+//         if (this.currentPath && this.currentPath.length > 0) {
+
+//             const wp = this.worldPosition;
+//             const target = this.currentPath[0];
+//             this.worldPosition = wp.lerp(target, time.deltaTime*2);
+
+//             this.gameObject.lookAt(target);
+//             // const vec = target.clone().sub(wp);
+//             // const wr = this.worldQuaternion;
+//             // wr.slerp(rot, time.deltaTime*5);
+//             // this.worldQuaternion = wr;
+
+//             if (wp.distanceTo(this.currentPath[0]) < 0.1)
+//                 this.currentPath.shift();
 
             
-        }
-    }
-    */
-}
+//         }
+//     }
+//     */
+// }

package/src/engine-components/NestedGltf.ts

@@ -41,6 +41,8 @@ export class NestedGltf extends Behaviour {
                 res.matrix.identity();
                 res.applyMatrix4(matrix);
                 res.matrixAutoUpdate = true;
+                res.layers.disableAll();
+                res.layers.set(this.layer);
             }
             this.destroy();
             if (debug) console.log("Nested loading done:", this.filePath?.uri ?? this.filePath, res);

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;
+            }
+        }
+    }
+}