@needle-tools/engine 2.52.0-pre → 2.54.2-pre

package/src/engine/extensions/extensions.ts

@@ -12,7 +12,7 @@ import { 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_deferred_texture } from "./NEEDLE_deferred_texture";
+import { NEEDLE_progressive } from "./NEEDLE_progressive";
 
 export function registerComponentExtension(loader: GLTFLoader): NEEDLE_components {
     const ext = new NEEDLE_components();
@@ -40,7 +40,7 @@ export function registerExtensions(loader: GLTFLoader, context: Context, sourceI
     loader.register(p => new NEEDLE_lighting_settings(p, sourceId, context));
     loader.register(p => new NEEDLE_techniques_webgl(p, sourceId));
     loader.register(p => new NEEDLE_render_objects(p, sourceId));
-    loader.register(p => new NEEDLE_deferred_texture(p, sourceId, context));
+    loader.register(p => new NEEDLE_progressive(p, sourceId, context));
     loader.register(p => new EXT_texture_exr(p));
 
     const setPointerResolverFunction = loader["setAnimationPointerResolver"];

package/src/engine-components/Camera.ts

@@ -9,6 +9,7 @@ import { 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 { Gizmos } from "../engine/engine_gizmos";
 
 export enum ClearFlags {
     Skybox = 1,
@@ -17,6 +18,7 @@ export enum ClearFlags {
 }
 
 const debug = getParam("debugcam");
+const debugscreenpointtoray = getParam("debugscreenpointtoray");
 
 export class Camera extends Behaviour implements ICamera {
 
@@ -157,14 +159,15 @@ export class Camera extends Behaviour implements ICamera {
     private static _origin: THREE.Vector3 = new THREE.Vector3();
     private static _direction: THREE.Vector3 = new THREE.Vector3();
     public screenPointToRay(x: number, y: number, ray?: Ray): Ray {
+        let cam = this.cam;
         const origin = Camera._origin;
         origin.set(x, y, -1);
         this.context.input.convertScreenspaceToRaycastSpace(origin);
+        if(debugscreenpointtoray) console.log("screenPointToRay", x.toFixed(2), y.toFixed(2), "now:", origin.x.toFixed(2), origin.y.toFixed(2), "isInXR:" + this.context.isInXR);
         origin.z = -1;
-        origin.unproject(this.cam);
-
+        origin.unproject(cam);
         const dir = Camera._direction.set(origin.x, origin.y, origin.z);
-        const camPosition = getWorldPosition(this.cam);
+        const camPosition = getWorldPosition(cam);
         dir.sub(camPosition);
         dir.normalize();
         if (ray) {
@@ -180,6 +183,17 @@ export class Camera extends Behaviour implements ICamera {
         if (!this.sourceId) {
             console.warn("Camera has no source - the camera should be exported inside a gltf", this.name);
         }
+
+        if(debugscreenpointtoray){
+            window.addEventListener("pointerdown", evt => {
+                const px = evt.clientX;
+                const py = evt.clientY;
+                console.log("touch", px.toFixed(2), py.toFixed(2))
+                const ray = this.screenPointToRay(px, py);
+                const randomHex = "#" + Math.floor(Math.random()*16777215).toString(16);
+                Gizmos.DrawRay(ray.origin, ray.direction, randomHex, 10);
+            });
+        }
     }
 
     onEnable(): void {

package/src/engine-components/GroundProjection.ts

@@ -7,6 +7,9 @@ import { Texture } from "three";
 
 export class GroundProjectedEnv extends Behaviour {
 
+    @serializable()
+    applyOnAwake: boolean = false;
+
     @serializable()
     set scale(val: number) {
         this._scale = val;
@@ -40,14 +43,23 @@ export class GroundProjectedEnv extends Behaviour {
     private _watcher?: Watch;
 
 
-    onEnable() {
-        // 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)
+    awake() {
+        if (this.applyOnAwake)
             this.updateAndCreate();
     }
 
-    start() {
-        this.updateAndCreate();
+    onEnable() {
+        // 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) {
+            if (this.applyOnAwake)
+                this.updateAndCreate();
+        }
+        if (!this._watcher) {
+            this._watcher = new Watch(this.context.scene, "environment");
+            this._watcher.subscribeWrite(_ => {
+                this.updateProjection();
+            });
+        }
     }
 
     onDisable() {
@@ -57,13 +69,7 @@ export class GroundProjectedEnv extends Behaviour {
 
     private updateAndCreate() {
         this.updateProjection();
-        if (!this._watcher) {
-            this._watcher = new Watch(this.context.scene, "environment");
-            this._watcher.subscribeWrite(_ => {
-                this.updateProjection();
-            });
-        }
-        this._watcher.apply();
+        this._watcher?.apply();
     }
 
     updateProjection() {

package/src/engine-components/Light.ts

@@ -292,6 +292,7 @@ export class Light extends Behaviour implements ILight {
 
         if (lightAlreadyCreated && !this.light) {
             this.light = this.gameObject as unknown as THREE.Light;
+            this._intensity = this.light.intensity;
 
             switch (this.type) {
                 case LightType.Directional:
@@ -346,7 +347,8 @@ export class Light extends Behaviour implements ILight {
         if (this.light) {
             if (this._intensity >= 0)
                 this.light.intensity = this._intensity;
-            else this._intensity = this.light.intensity;
+            else  
+                this._intensity = this.light.intensity;
 
             if (this.shadows !== LightShadows.None) {
                 this.light.castShadow = true;

package/src/engine-components/OrbitControls.ts

@@ -11,6 +11,9 @@ import { getParam, isMobileDevice } from "../engine/engine_utils";
 
 const freeCam = getParam("freecam");
 
+const disabledKeys = { LEFT: "", UP: "", RIGHT: "", BOTTOM: "" };
+let defaultKeys: any = undefined;
+
 export class OrbitControls extends Behaviour {
     public get controls() {
         return this._controls;
@@ -73,6 +76,7 @@ export class OrbitControls extends Behaviour {
             if (cam)
                 this._cameraObject = cam;
             this._controls = new ThreeOrbitControls(cam!, this.context.renderer.domElement);
+            if (defaultKeys === undefined) defaultKeys = { ...this._controls.keys };
         }
 
         if (this._controls) {
@@ -80,12 +84,11 @@ export class OrbitControls extends Behaviour {
                 this.enablePan = true;
                 this.enableZoom = true;
                 this.middleClickToFocus = true;
-                if(isMobileDevice()) this.doubleClickToFocus = true;
+                if (isMobileDevice()) this.doubleClickToFocus = true;
             }
 
             this._controls.enableDamping = this.enableDamping;
-            //@ts-ignore (not in types)
-            this._controls.enableKeys = this.enableKeys;
+            this._controls.keys = this.enableKeys ? defaultKeys : disabledKeys;
             this._controls.autoRotate = this.autoRotate;
             this._controls.autoRotateSpeed = this.autoRotateSpeed;
             this._controls.enableZoom = this.enableZoom;
@@ -164,6 +167,7 @@ export class OrbitControls extends Behaviour {
             this._inputs += 1;
         }
         if (this._inputs > 0) {
+            this.autoRotate = false;
             this._controls.autoRotate = false;
             this._lerpCameraToTarget = false;
             this._lerpToTargetPosition = false;

package/src/engine-components/ParticleSystemModules.ts

@@ -517,9 +517,9 @@ export class ShapeModule implements EmitterShape {
     private readonly _worldSpaceMatrixInverse: Matrix4 = new Matrix4();
 
 
-    constructor() {
-        // console.log(this);
-    }
+    // constructor() {
+    //     console.log(this);
+    // }
 
     update(system: IParticleSystem, _context: Context, simulationSpace: ParticleSystemSimulationSpace, obj: Object3D) {
         this.system = system;
@@ -534,6 +534,16 @@ export class ShapeModule implements EmitterShape {
         }
     }
 
+    private updateRotation() {
+        const isRotated = this.rotation.x !== 0 || this.rotation.y !== 0 || this.rotation.z !== 0;
+        if (isRotated) {
+            this._rotation.x = Mathf.toRadians(this.rotation.x);
+            this._rotation.y = -Mathf.toRadians(this.rotation.y);
+            this._rotation.z = -Mathf.toRadians(this.rotation.z);
+        }
+        return isRotated;
+    }
+
     /** nebula implementations: */
 
     /** initializer implementation */
@@ -544,61 +554,52 @@ export class ShapeModule implements EmitterShape {
         return this._vector;
     }
     getPosition(): void {
-        if (!this.enabled) {
-            this._vector.set(0, 0, 0);
-            return;
-        }
+        this._vector.set(0, 0, 0);
         const pos = this._temp.copy(this.position);
         const isWorldSpace = this._space === ParticleSystemSimulationSpace.World;
         if (isWorldSpace) {
             pos.applyQuaternion(this.system.worldQuaternion);
         }
-
-        const isRotated = this.rotation.x !== 0 || this.rotation.y !== 0 || this.rotation.z !== 0;
-        if (isRotated) {
-            this._rotation.x = Mathf.toRadians(this.rotation.x);
-            this._rotation.y = -Mathf.toRadians(this.rotation.y);
-            this._rotation.z = -Mathf.toRadians(this.rotation.z);
-        }
-
         let radius = this.radius;
         if (isWorldSpace) radius *= this.system.worldScale.x;
-        switch (this.shapeType) {
-            case ParticleSystemShapeType.Box:
-                this._vector.x = Math.random() * this.scale.x - this.scale.x / 2;
-                this._vector.y = Math.random() * this.scale.y - this.scale.y / 2;
-                this._vector.z = Math.random() * this.scale.z - this.scale.z / 2;
-                this._vector.add(pos);
-                break;
-            case ParticleSystemShapeType.Cone:
-                this.randomConePoint(this.position, this.angle, radius, this.radiusThickness, this.arc, this.arcMode, this._vector);
-                break;
-            case ParticleSystemShapeType.Sphere:
-                this.randomSpherePoint(this.position, radius, this.radiusThickness, this.arc, this._vector);
-                this._vector.x *= this.scale.x;
-                this._vector.y *= this.scale.y;
-                this._vector.z *= this.scale.z;
-                break;
-            case ParticleSystemShapeType.Circle:
-                this.randomSpherePoint(this.position, radius, this.radiusThickness, this.arc, this._vector);
-                this._vector.x *= this.scale.x;
-                this._vector.y *= this.scale.y;
-                this._vector.z *= 0;
-                break;
-            default:
-                this._vector.set(0, 0, 0);
-                break;
-            // case ParticleSystemShapeType.Hemisphere:
-            //     randomSpherePoint(this.position.x, this.position.y, this.position.z, this.radius, this.radiusThickness, 180, this._vector);
-            //     break;
-        }
+        if (this.enabled) {
+            switch (this.shapeType) {
+                case ParticleSystemShapeType.Box:
+                    this._vector.x = Math.random() * this.scale.x - this.scale.x / 2;
+                    this._vector.y = Math.random() * this.scale.y - this.scale.y / 2;
+                    this._vector.z = Math.random() * this.scale.z - this.scale.z / 2;
+                    this._vector.add(pos);
+                    break;
+                case ParticleSystemShapeType.Cone:
+                    this.randomConePoint(this.position, this.angle, radius, this.radiusThickness, this.arc, this.arcMode, this._vector);
+                    break;
+                case ParticleSystemShapeType.Sphere:
+                    this.randomSpherePoint(this.position, radius, this.radiusThickness, this.arc, this._vector);
+                    this._vector.x *= this.scale.x;
+                    this._vector.y *= this.scale.y;
+                    this._vector.z *= this.scale.z;
+                    break;
+                case ParticleSystemShapeType.Circle:
+                    this.randomSpherePoint(this.position, radius, this.radiusThickness, this.arc, this._vector);
+                    this._vector.x *= this.scale.x;
+                    this._vector.y *= this.scale.y;
+                    this._vector.z *= 0;
+                    break;
+                default:
+                    this._vector.set(0, 0, 0);
+                    break;
+                // case ParticleSystemShapeType.Hemisphere:
+                //     randomSpherePoint(this.position.x, this.position.y, this.position.z, this.radius, this.radiusThickness, 180, this._vector);
+                //     break;
+            }
 
-        this.randomizePosition(this._vector, this.randomPositionAmount);
+            this.randomizePosition(this._vector, this.randomPositionAmount);
+        }
 
-        if (isRotated)
+        if (this.updateRotation())
             this._vector.applyEuler(this._rotation);
 
-        if (this._space === ParticleSystemSimulationSpace.World) {
+        if (isWorldSpace) {
             this._vector.add(this.system.worldPos);
         }
     }
@@ -634,6 +635,8 @@ export class ShapeModule implements EmitterShape {
         if (this._space === ParticleSystemSimulationSpace.World) {
             this._dir.applyMatrix4(this._worldSpaceMatrixInverse);
         }
+        if (this.updateRotation())
+            this._dir.applyEuler(this._rotation);
         this._dir.normalize();
         this.spherizeDirection(this._dir, this.sphericalDirectionAmount);
         this.randomizeDirection(this._dir, this.randomDirectionAmount);

package/src/engine-components/Renderer.ts

@@ -7,7 +7,7 @@ import { getParam } from "../engine/engine_utils";
 import { serializable } from "../engine/engine_serialization_decorator";
 import { AxesHelper, Material, Mesh, Object3D, SkinnedMesh, Texture, Vector4 } from "three";
 import { NEEDLE_render_objects } from "../engine/extensions/NEEDLE_render_objects";
-import { NEEDLE_deferred_texture } from "../engine/extensions/NEEDLE_deferred_texture";
+import { NEEDLE_progressive } from "../engine/extensions/NEEDLE_progressive";
 import { NEED_UPDATE_INSTANCE_KEY } from "../engine/engine_instancing";
 import { IRenderer, ISharedMaterials } from "../engine/engine_types";
 import { debug, ReflectionProbe } from "./ReflectionProbe";
@@ -463,14 +463,10 @@ export class Renderer extends Behaviour implements IRenderer {
         if (!suppressProgressiveLoading && material._didRequestTextureLOD === undefined && this.allowProgressiveLoading) {
             material._didRequestTextureLOD = 0;
             if (debugProgressiveLoading) {
-                console.log("Load material LOD (with delay)", material.name);
-                setTimeout(() => {
-                    NEEDLE_deferred_texture.assignTextureLOD(this.context, this.sourceId, material);
-                }, 2000);
-            }
-            else {
-                NEEDLE_deferred_texture.assignTextureLOD(this.context, this.sourceId, material);
+                console.log("Load material LOD", material.name);
             }
+            NEEDLE_progressive.assignTextureLOD(this.context, this.sourceId, material);
+
         }
 
         if (material.envMapIntensity !== undefined) {
@@ -549,10 +545,10 @@ export class Renderer extends Behaviour implements IRenderer {
             // update the reflection probe right before rendering
             // if we do it immediately the reflection probe might not be enabled yet 
             // (since this method is called from onEnable)
-            this.startCoroutine(this._updateReflectionProbe(), FrameEvent.OnBeforeRender);
+            this.startCoroutine(this._updateReflectionProbe(), FrameEvent.LateUpdate);
         }
     }
-    private *_updateReflectionProbe(){
+    private *_updateReflectionProbe() {
         const obj = this.probeAnchor || this.gameObject;
         const isAnchor = this.probeAnchor ? true : false;
         this._reflectionProbe = ReflectionProbe.get(obj, this.context, isAnchor);

package/src/engine-components/Voip.ts

@@ -307,6 +307,11 @@ export class Voip extends Behaviour {
             return;
         }
 
+        if (utils.isiOS() && utils.isSafari()) {
+            console.log("VOIP is currently not supported on Safari iOS")
+            return;
+        }
+
         this.peer = new Peer();
         navigator["getUserMedia"] = (navigator["getUserMedia"] || navigator["webkitGetUserMedia"] || navigator["mozGetUserMedia"] || navigator["msGetUserMedia"]);
 
@@ -360,10 +365,15 @@ export class Voip extends Behaviour {
     onDisable(): void {
         console.log("TODO: close all");
         for (const key in this.currentIncomingCalls) {
-            const call = this.currentIncomingCalls[key];
-            call?.close();
-            const con = this.connections[key];
-            con?.close();
+            try {
+                const call = this.currentIncomingCalls[key];
+                call?.close();
+                const con = this.connections[key];
+                con?.close();
+            }
+            catch (err) {
+                console.error(err);
+            }
         }
     }
 

package/src/engine-components/Volume.ts

@@ -93,7 +93,14 @@ export class VolumeProfile {
                 // three.js range goes from 0..inf
                 if (debug)
                     console.log(colorAdjustments.postExposure);
-                const exposure = Math.pow(2, colorAdjustments.postExposure?.value ?? 0);
+                let exposure = 1;
+                // convert to linear
+                if (colorAdjustments.postExposure)
+                    exposure = Math.pow(2, colorAdjustments.postExposure.value);
+                // ACES applies a factor of roughly 1.666 ( /= .6 )
+                if (context.renderer.toneMapping === ACESFilmicToneMapping) {
+                    // exposure /= Math.PI / 2;
+                }
                 const useExposure = colorAdjustments.postExposure?.overrideState && !remove;
                 context.renderer.toneMappingExposure = useExposure ? exposure : 1;
                 if (!context.renderer.toneMapping)

package/src/engine-components/WebXR.ts

@@ -86,7 +86,7 @@ export class WebXR extends Behaviour {
         return listener;
     }
 
-    public static createVRButton(webXR: WebXR, opts?: CreateButtonOptions): HTMLButtonElement {
+    public static createVRButton(webXR: WebXR, opts?: CreateButtonOptions): HTMLButtonElement | HTMLAnchorElement {
         if (!WebXR.XRSupported) {
             console.warn("WebXR is not supported on this device");
         }
@@ -102,7 +102,7 @@ export class WebXR extends Behaviour {
         return vrButton;
     }
 
-    public static createARButton(webXR: WebXR, opts?: CreateButtonOptions): HTMLButtonElement {
+    public static createARButton(webXR: WebXR, opts?: CreateButtonOptions): HTMLButtonElement | HTMLAnchorElement {
         webXR.__internalAwake();
         const domOverlayRoot = webXR.webAR?.getAROverlayContainer();
         const features: any = {};