@needle-tools/engine 3.9.0-alpha → 3.9.1-alpha

package/src/engine/engine_loaders.ts

@@ -13,7 +13,7 @@ const DEFAULT_DRACO_DECODER_LOCATION ='https://www.gstatic.com/draco/versioned/d
 const DEFAULT_KTX2_TRANSCODER_LOCATION ='https://www.gstatic.com/basis-universal/versioned/2021-04-15-ba1c3e4/';
 
 let dracoLoader: DRACOLoader;
-let meshoptDecoder: MeshoptDecoder;
+let meshoptDecoder: typeof MeshoptDecoder;
 let ktx2Loader: KTX2Loader;
 
 export function setDracoDecoderPath(path: string | undefined) {

package/src/engine-components/Camera.ts

@@ -40,7 +40,7 @@ export class Camera extends Behaviour implements ICamera {
     }
     @serializable()
     set fieldOfView(val: number | undefined) {
-        const changed = this._fov != val;
+        const changed = this.fieldOfView != val;
         this._fov = val;
         if (changed && this._cam) {
             if (this._cam instanceof PerspectiveCamera) {
@@ -300,8 +300,11 @@ export class Camera extends Behaviour implements ICamera {
             if (debug) console.log("Camera does not exist (apply clear flags)")
             return;
         }
-        if (debug)
-            showBalloonMessage("apply Camera clear flags: " + this._clearFlags);
+
+        // restore previous fov (e.g. when user was in VR or AR and the camera's fov has changed)
+        this.fieldOfView = this._fov;
+        
+        if (debug) showBalloonMessage("apply Camera clear flags: " + this._clearFlags);
         switch (this._clearFlags) {
             case ClearFlags.Skybox:
                 if (Camera.backgroundShouldBeTransparent(this.context)) {

package/src/engine-components/ParticleSystem.ts

@@ -75,7 +75,7 @@ export class ParticleSystemRenderer extends Behaviour {
 
         if (!ParticleSystemRenderer._havePatchedQuarkShaders) {
             ParticleSystemRenderer._havePatchedQuarkShaders = true;
-            
+
             // HACK patch three.quarks fo three152+, see https://github.com/Alchemist0823/three.quarks/issues/56#issuecomment-1560825038
             const _rebuild = TrailBatch.prototype.rebuildMaterial;
             TrailBatch.prototype.rebuildMaterial = function () {
@@ -130,13 +130,17 @@ export class ParticleSystemRenderer extends Behaviour {
 class MinMaxCurveFunction implements FunctionValueGenerator {
 
     private _curve: MinMaxCurve;
+    private _factor: number;
 
-    constructor(curve: MinMaxCurve) { this._curve = curve; }
+    constructor(curve: MinMaxCurve, factor: number = 1) {
+        this._curve = curve;
+        this._factor = factor;
+    }
 
     type: "function" = "function";
 
     genValue(t: number): number {
-        return this._curve.evaluate(t, Math.random());
+        return this._curve.evaluate(t, Math.random()) * this._factor;
     }
     toJSON(): FunctionJSON {
         throw new Error("Method not implemented.");
@@ -416,7 +420,7 @@ class VelocityBehaviour extends ParticleSystemBaseBehaviour {
     initialize(particle: Particle): void {
         const simulationSpeed = this.system.main.simulationSpeed;
 
-        const factor = 1 * simulationSpeed;
+        const factor = 1;
         particle.startSpeed = this.system.main.startSpeed.evaluate(Math.random(), Math.random()) * factor;
         particle.velocity.copy(this.system.shape.getDirection(particle.position)).multiplyScalar(particle.startSpeed);
         if (this.system.inheritVelocity?.enabled) {
@@ -425,16 +429,16 @@ class VelocityBehaviour extends ParticleSystemBaseBehaviour {
         if (!particle[$startVelocity]) particle[$startVelocity] = particle.velocity.clone();
         else particle[$startVelocity].copy(particle.velocity);
 
-        const gravityFactor = this.system.main.gravityModifier.evaluate(Math.random(), Math.random()) / (9.81 * 2);
+        const gravityFactor = this.system.main.gravityModifier.evaluate(Math.random(), Math.random());
         particle[$gravityFactor] = gravityFactor * simulationSpeed;
-        particle[$gravitySpeed] = 1;
+        particle[$gravitySpeed] = gravityFactor * simulationSpeed * .5
 
         particle[$velocityLerpFactor] = Math.random();
         this.system.velocityOverLifetime?.init(particle);
 
         this._gravityDirection.set(0, -1, 0);
         if (this.system.main.simulationSpace === ParticleSystemSimulationSpace.Local)
-            this._gravityDirection.applyQuaternion(this.system.worldQuaternionInverted);
+            this._gravityDirection.applyQuaternion(this.system.worldQuaternionInverted).normalize();
     }
 
     update(particle: Particle, delta: number): void {
@@ -444,10 +448,9 @@ class VelocityBehaviour extends ParticleSystemBaseBehaviour {
         const baseVelocity = particle[$startVelocity];
         let gravityFactor = particle[$gravityFactor];
         if (gravityFactor !== 0) {
-            // gravityFactor *= -1;
-            temp3.copy(this._gravityDirection).multiplyScalar(gravityFactor * particle[$gravitySpeed]);
-            particle[$gravitySpeed] += delta;
-            if (debug) Gizmos.DrawDirection(particle.position, temp3, 0x0000ff, 0, false, 10);
+            const factor = gravityFactor * particle[$gravitySpeed];
+            temp3.copy(this._gravityDirection).multiplyScalar(factor);
+            particle[$gravitySpeed] += delta * .05;
             baseVelocity.add(temp3);
         }
         particle.velocity.copy(baseVelocity);
@@ -931,10 +934,10 @@ export class ParticleSystem extends Behaviour implements IParticleSystem {
         const duration = this.main.duration;
         const lifetime = this.main.startLifetime.getMax();
         const maxDurationToPrewarm = 1000;
-        const timeToSimulate = Math.min(duration, lifetime, maxDurationToPrewarm);
+        const timeToSimulate = Math.min(Math.max(duration, lifetime) / Math.max(.01, this.main.simulationSpeed), maxDurationToPrewarm);
         const framesToSimulate = Math.ceil(timeToSimulate / dt);
         const startTime = Date.now();
-        if (debug)
+        if (debug || this.name === "Snow")
             console.log(`Particles ${this.name} - Prewarm for ${framesToSimulate} frames (${timeToSimulate} sec). Duration: ${duration}, Lifetime: ${lifetime}`);
         for (let i = 0; i < framesToSimulate; i++) {
             if (this.currentParticles >= this.maxParticles) break;

package/src/engine-components/SceneSwitcher.ts

@@ -38,6 +38,13 @@ export class SceneSwitcher extends Behaviour {
     @serializable()
     queryParameterName: string = "scene";
 
+    /** 
+     * when enabled the scene name will be used as the query parameter (otherwise the scene index will be used)
+     * Needs `queryParameterName` set
+     * */
+    @serializable()
+    useSceneName: boolean = true;
+
     @serializable()
     clamp: boolean = true;
 
@@ -281,9 +288,15 @@ export class SceneSwitcher extends Behaviour {
                 if (this.useSceneLighting)
                     this.context.sceneLighting.enable(scene)
                 if (this.useHistory && index >= 0) {
+                    // take the index as the query parameter value
+                    let queryParameterValue = index.toString();
+                    // unless the user defines that he wants to use the scene name
+                    if (this.useSceneName) {
+                        queryParameterValue = sceneUriToName(scene.uri);
+                    }
                     // save the loaded scene as an url parameter
                     if (this.queryParameterName?.length)
-                        setParamWithoutReload(this.queryParameterName, index.toString(), this.useHistory);
+                        setParamWithoutReload(this.queryParameterName, queryParameterValue, this.useHistory);
                     // or set the history state without updating the url parameter
                     else {
                         const lastState = history.state;
@@ -328,9 +341,11 @@ export class SceneSwitcher extends Behaviour {
             }
             else {
                 // Try to find a scene with a matching name
+                // we don't care about casing. e.g. Scene1 and scene1 should both match
+                const lowerCaseValue = value.toLowerCase();
                 for (let i = 0; i < this.scenes.length; i++) {
                     const scene = this.scenes[i];
-                    if (scene.uri.toLowerCase().includes(value)) {
+                    if (sceneUriToName(scene.uri).toLowerCase().includes(lowerCaseValue)) {
                         return this.select(i);;
                     }
                 }
@@ -349,6 +364,13 @@ export class SceneSwitcher extends Behaviour {
 }
 
 
+function sceneUriToName(uri: string): string {
+    const name = uri.split("/").pop();
+    let value = name?.split(".").shift();
+    if (value?.length) return value;
+    return uri;
+}
+
 
 
 class PreLoadScheduler {

package/src/engine-components/webxr/WebXR.ts

@@ -21,7 +21,7 @@ import { showBalloonWarning } from '../../engine/debug';
 const debugWebXR = getParam("debugwebxr");
 
 export async function detectARSupport() {
-    if(isMozillaXR()) return true;
+    if (isMozillaXR()) return true;
     if ("xr" in navigator) {
         //@ts-ignore
         return (await navigator["xr"].isSessionSupported('immersive-ar')) === true;
@@ -136,7 +136,7 @@ export class WebXR extends Behaviour {
         return arButton;
     }
 
-    private static onModifyAROptions(options){
+    private static onModifyAROptions(options) {
         WebXR.dispatchEvent(WebXREvent.ModifyAROptions, options);
     }
 
@@ -255,11 +255,10 @@ export class WebXR extends Behaviour {
         this.context.appendHTMLElement(buttonsContainer);
 
         const forceButtons = debugWebXR;
-        if(debugWebXR) console.log("ARSupported?", arSupported, "VRSupported?", vrSupported);
+        if (debugWebXR) console.log("ARSupported?", arSupported, "VRSupported?", vrSupported);
 
         // AR support
-        if (forceButtons || (this.createARButton && this.enableAR && arSupported)) 
-        {
+        if (forceButtons || (this.createARButton && this.enableAR && arSupported)) {
             arButton = WebXR.createARButton(this);
             this._arButton = arButton;
             buttonsContainer.appendChild(arButton);
@@ -271,7 +270,7 @@ export class WebXR extends Behaviour {
             this._vrButton = vrButton;
             buttonsContainer.appendChild(vrButton);
         }
-        
+
         setTimeout(() => {
             WebXR.resetButtonStyles(vrButton);
             WebXR.resetButtonStyles(arButton);
@@ -289,11 +288,11 @@ export class WebXR extends Behaviour {
         // TODO: figure out why screen is black if we enable the code written here
         // const referenceSpace = renderer.xr.getReferenceSpace();
         const session = this.context.renderer.xr.getSession();
-        
+
 
         if (session) {
             const pose = frame.getViewerPose(this.context.renderer.xr.getReferenceSpace());
-            if(!pose) return;
+            if (!pose) return;
             this._currentHeadPose = pose;
             const transform: XRRigidTransform = pose?.transform;
             if (transform) {
@@ -356,7 +355,7 @@ export class WebXR extends Behaviour {
             this._originalCameraRotation.copy(getWorldQuaternion(this.context.mainCamera));
             this._originalCameraParent = this.context.mainCamera.parent;
         }
-        if(this.Rig){
+        if (this.Rig) {
             this._originalXRRigParent = this.Rig.parent;
             this._originalXRRigPosition.copy(this.Rig.position);
             this._originalXRRigRotation.copy(this.Rig.quaternion);
@@ -415,9 +414,9 @@ export class WebXR extends Behaviour {
         const xr = this.context.renderer.xr;
         if (this.context.mainCamera) {
             const cam = xr.getCamera() as WebXRArrayCamera;
-            if(debugWebXR) console.log("WebXRCamera", cam);
+            if (debugWebXR) console.log("WebXRCamera", cam);
             const cull = this.context.mainCameraComponent?.cullingMask;
-            if(cam && cull !== undefined){
+            if (cam && cull !== undefined) {
                 for (const c of cam.cameras) {
                     c.layers.mask = cull;
                 }
@@ -467,8 +466,14 @@ export class WebXR extends Behaviour {
 
         const wasInAR = this._isInAR;
 
-        if (this._isInAR && session) {
-            this.webAR?.onEnd(session);
+        if (session) {
+            if (this._isInAR) {
+                this.webAR?.onEnd(session);
+            }
+            else {
+                // if in VR we want to restore the FOV
+                this.context.mainCameraComponent?.applyClearFlagsIfIsActiveCamera();
+            }
         }
 
         this._isInAR = false;
@@ -491,7 +496,7 @@ export class WebXR extends Behaviour {
             this.context.mainCamera.scale.set(1, 1, 1);
         }
 
-        if(wasInAR){
+        if (wasInAR) {
             this._originalXRRigParent?.add(this.rig);
             this.rig.position.copy(this._originalXRRigPosition);
             this.rig.quaternion.copy(this._originalXRRigRotation);