@needle-tools/engine 3.11.2-beta → 3.11.3-beta

package/src/engine-components/CharacterController.ts

@@ -1,4 +1,4 @@
-import { Quaternion, Ray, Vector3 } from "three";
+import { Quaternion, Ray, Vector2, Vector3 } from "three";
 import { Mathf } from "../engine/engine_math.js";
 import { serializable } from "../engine/engine_serialization.js";
 import { Collision } from "../engine/engine_types.js";
@@ -99,6 +99,48 @@ export class CharacterControllerInput extends Behaviour {
 
     lookForward: boolean = true;
 
+    awake(){
+        this._currentRotation = new Quaternion();
+    }
+
+    update(){
+        const input = this.context.input;
+        if(input.isKeyPressed("KeyW"))
+            this.moveInput.y += 1;
+        else if(input.isKeyPressed("KeyS"))
+            this.moveInput.y -= 1;
+        if(input.isKeyPressed("KeyD"))
+            this.lookInput.x += 1;
+        else if(input.isKeyPressed("KeyA"))
+            this.lookInput.x -= 1;
+
+        this.jumpInput ||= input.isKeyDown("Space");
+    }
+
+    move(move: Vector2) {
+        this.moveInput.add(move);
+    }
+
+    look(look: Vector2) {
+        this.lookInput.add(look);
+    }
+
+    jump() {
+        this.jumpInput = true;
+    }
+
+    private lookInput: Vector2 = new Vector2(0, 0);
+    private moveInput: Vector2 = new Vector2(0, 0);
+    private jumpInput: boolean = false;
+
+    onBeforeRender() {
+        this.handleInput(this.moveInput, this.lookInput, this.jumpInput);
+
+        this.lookInput.set(0, 0);
+        this.moveInput.set(0, 0);
+        this.jumpInput = false;
+    }
+
     private _currentSpeed: Vector3 = new Vector3(0, 0, 0);
     private _currentAngularSpeed: Vector3 = new Vector3(0, 0, 0);
 
@@ -106,30 +148,16 @@ export class CharacterControllerInput extends Behaviour {
     private _jumpCount: number = 0;
     private _currentRotation!: Quaternion;
 
-    awake(){
-        this._currentRotation = new Quaternion();
-    }
-
-    update() {
+    handleInput (move: Vector2, look: Vector2, jump: boolean) {
 
         if (this.controller?.isGrounded) {
             this._jumpCount = 0;
             if (this.doubleJumpForce > 0) this.animator?.setBool("doubleJump", false);
         }
 
-        const forward = this.context.input.isKeyPressed("w");
-        const backward = this.context.input.isKeyPressed("s");
-        const rotateLeft = this.context.input.isKeyPressed("a");
-        const rotateRight = this.context.input.isKeyPressed("d");
-        const jump = this.context.input.isKeyDown(" ");
-        // if (jumpDown) this._jumpDownTime = this.context.time.time;
-        // const jumpUp = this.context.input.isKeyUp(" ");
-
-        const step = (forward ? 1 : 0) + (backward ? -1 : 0);
-        this._currentSpeed.z += step * this.movementSpeed * this.context.time.deltaTime;
+        this._currentSpeed.z += move.y * this.movementSpeed * this.context.time.deltaTime;
 
-        // if (!this.controller || this.controller.isGrounded)
-        this.animator?.setBool("running", step != 0);
+        this.animator?.setBool("running", move.length() > 0.01);
         this.animator?.setBool("jumping", this.controller?.isGrounded === true && jump);
 
         this._temp.copy(this._currentSpeed);
@@ -137,8 +165,7 @@ export class CharacterControllerInput extends Behaviour {
         if (this.controller) this.controller.move(this._temp);
         else this.gameObject.position.add(this._temp);
 
-        const rotation = (rotateLeft ? 1 : 0) + (rotateRight ? -1 : 0);
-        this._currentAngularSpeed.y += Mathf.toRadians(rotation * this.rotationSpeed) * this.context.time.deltaTime;
+        this._currentAngularSpeed.y += Mathf.toRadians(-look.x * this.rotationSpeed) * this.context.time.deltaTime;
         if (this.lookForward && Math.abs(this._currentAngularSpeed.y) < .01) {
             const forwardVector = this.context.mainCameraComponent!.forward;
             forwardVector.y = 0;

package/src/engine-components/ParticleSystem.ts

@@ -901,6 +901,7 @@ export class ParticleSystem extends Behaviour implements IParticleSystem {
 
     start() {
         this.addSubParticleSystems();
+        this.updateLayers();
     }
 
     onDestroy(): void {
@@ -959,17 +960,19 @@ export class ParticleSystem extends Behaviour implements IParticleSystem {
         }
     }
 
+    private _lastBatchesCount = -1;
     private onSimulate(dt: number) {
         if (this._batchSystem) {
+            let needsUpdate = this.context.time.frameCount % 60 === 0;
+            if(this._lastBatchesCount !== this._batchSystem.batches.length) {
+                this._lastBatchesCount = this._batchSystem.batches.length;
+                needsUpdate = true;
+            }
             // Updating layers on batches
             // TODO: figure out a better way to do this
             // Issue: https://github.com/Alchemist0823/three.quarks/issues/49
-            if (this.context.time.frameCount % 60 === 0) {
-                for (let i = 0; i < this._batchSystem.batches.length; i++) {
-                    const batch = this._batchSystem.batches[i];
-                    batch.layers.disableAll();
-                    batch.layers.set(2);
-                }
+            if (needsUpdate) {
+                this.updateLayers();
             }
             this._batchSystem.update(dt);
         }
@@ -977,6 +980,17 @@ export class ParticleSystem extends Behaviour implements IParticleSystem {
         if (this._time > this.duration) this._time = 0;
     }
 
+    private updateLayers() {
+        if (this._batchSystem) {
+            for (let i = 0; i < this._batchSystem.batches.length; i++) {
+                const batch = this._batchSystem.batches[i];
+                batch.layers.disableAll();
+                const layer = this.layer;
+                batch.layers.mask = 1 << layer;
+            }
+        }
+    }
+
     private lastMaterialVersion: number = -1;
     private onUpdate() {
         const mat = this.renderer.getMaterial(this.trails.enabled);

package/src/engine-components/SceneSwitcher.ts

@@ -246,7 +246,7 @@ export class SceneSwitcher extends Behaviour {
                 const reference = AssetReference.getOrCreate(this.sourceId ?? "", index, this.context);
                 return this.switchScene(reference);
             }
-            if (scene) index = this.scenes.indexOf(scene);
+            if (scene) index = this.scenes?.indexOf(scene);
             else return couldNotLoadScenePromise;
         }
 
@@ -437,8 +437,10 @@ class PreLoadScheduler {
     }
 
     allLoaded(): boolean {
-        for (const scene of this._switcher.scenes) {
-            if (scene?.isLoaded() === false) return false;
+        if (this._switcher.scenes) {
+            for (const scene of this._switcher.scenes) {
+                if (scene?.isLoaded() === false) return false;
+            }
         }
         return true;
     }

package/src/engine-components/export/usdz/ThreeUSDZExporter.ts

@@ -1183,9 +1183,9 @@ function buildMaterial( material: MeshBasicMaterial, textures, quickLookCompatib
 
 		const needsTextureScale = mapType !== 'normal' && (color && (color.r !== 1 || color.g !== 1 || color.b !== 1 || opacity !== 1)) || false;
 		const needsNormalScaleAndBias = mapType === 'normal';
-		const normalScaleValueString = material instanceof MeshStandardMaterial
-			? (material.normalScale ? material.normalScale.x * 2 : 2).toFixed( PRECISION )
-			: "1";
+		const normalScale = material instanceof MeshStandardMaterial ? (material.normalScale ? material.normalScale.x * 2 : 2) : 2;
+		const normalScaleValueString = normalScale.toFixed( PRECISION );
+		const normalBiasString = (-1 * (normalScale / 2)).toFixed( PRECISION );
 
 		return `
         ${needsTextureTransform ? `def Shader "Transform2d_${mapType}" (
@@ -1213,7 +1213,7 @@ function buildMaterial( material: MeshBasicMaterial, textures, quickLookCompatib
 			` : `` }
 			${needsNormalScaleAndBias ? `
 			float4 inputs:scale = (${normalScaleValueString}, ${normalScaleValueString}, ${normalScaleValueString}, 1)
-			float4 inputs:bias = (-1, -1, -1, 0)
+			float4 inputs:bias = (${normalBiasString}, ${normalBiasString}, ${normalBiasString}, 0)
 			` : `` }
             token inputs:wrapS = "${wrapS}"
             token inputs:wrapT = "${wrapT}"

package/src/engine-components/export/usdz/utils/quicklook.ts

@@ -2,8 +2,8 @@ import { Context } from "../../../../engine/engine_setup.js";
 
 
 export function ensureQuicklookLinkIsCreated(context: Context) : HTMLAnchorElement {
-    const existingLink = context.domElement.querySelector("link[rel='ar']");
-    if(existingLink) return existingLink as HTMLAnchorElement;
+    const existingLink = context.domElement.shadowRoot!.querySelector("link[rel='ar']");
+    if (existingLink) return existingLink as HTMLAnchorElement;
 
     /*
     generating this:
@@ -38,6 +38,6 @@ export function ensureQuicklookLinkIsCreated(context: Context) : HTMLAnchorEleme
     // img.src = "files/arkit.png";
     link.appendChild(img);
 
-    context.domElement.appendChild(div);
+    context.domElement.shadowRoot!.appendChild(div);
     return link as HTMLAnchorElement;
 }