@needle-tools/engine 4.1.0-beta.3 → 4.1.0-beta.5

package/src/engine/engine_types.ts

@@ -490,7 +490,7 @@ export interface IPhysicsEngine {
     addSphereCollider(collider: ICollider);
     addBoxCollider(collider: ICollider, size: Vector3);
     addCapsuleCollider(collider: ICollider, radius: number, height: number);
-    addMeshCollider(collider: ICollider, mesh: Mesh, convex: boolean, scale: Vector3);
+    addMeshCollider(collider: ICollider, mesh: Mesh, convex: boolean, scale?: Vector3 | undefined);
 
     updatePhysicsMaterial(collider: ICollider);
 

package/src/engine-components/Camera.ts

@@ -51,7 +51,7 @@ export class Camera extends Behaviour implements ICamera {
             }
         }
     }
-    /** The camera's field of view in degrees if it is a perspective camera */
+    /** The camera's field of view in degrees if it is a perspective camera. Calls updateProjectionMatrix when set */
     get fieldOfView(): number | undefined {
         if (this._cam instanceof PerspectiveCamera) {
             return this._cam.fov;
@@ -74,7 +74,7 @@ export class Camera extends Behaviour implements ICamera {
         }
     }
 
-    /** The camera's near clipping plane */
+    /** The camera's near clipping plane. Calls updateProjectionMatrix when set */
     get nearClipPlane(): number { return this._nearClipPlane; }
     @serializable()
     set nearClipPlane(val) {
@@ -87,15 +87,7 @@ export class Camera extends Behaviour implements ICamera {
     }
     private _nearClipPlane: number = 0.1;
 
-    applyClippingPlane() {
-        if (this._cam) {
-            this._cam.near = this._nearClipPlane;
-            this._cam.far = this._farClipPlane;
-            this._cam.updateProjectionMatrix();
-        }
-    }
-
-    /** The camera's far clipping plane */
+    /** The camera's far clipping plane. Calls updateProjectionMatrix when set */
     get farClipPlane(): number { return this._farClipPlane; }
     @serializable()
     set farClipPlane(val) {
@@ -108,6 +100,17 @@ export class Camera extends Behaviour implements ICamera {
     }
     private _farClipPlane: number = 1000;
 
+    /**
+     * Applys both the camera's near and far plane and calls updateProjectionMatrix on the camera.
+     */
+    applyClippingPlane() {
+        if (this._cam) {
+            this._cam.near = this._nearClipPlane;
+            this._cam.far = this._farClipPlane;
+            this._cam.updateProjectionMatrix();
+        }
+    }
+
     /** The camera's clear flags - determines if the background is a skybox or a solid color or transparent */
     @serializable()
     public get clearFlags(): ClearFlags {

package/src/engine-components/Collider.ts

@@ -207,12 +207,12 @@ export class MeshCollider extends Collider {
         const LOD = 0;
 
         if (this.sharedMesh?.isMesh) {
-            this.context.physics.engine.addMeshCollider(this, this.sharedMesh, this.convex, getWorldScale(this.gameObject));
+            this.context.physics.engine.addMeshCollider(this, this.sharedMesh, this.convex);
             NEEDLE_progressive.assignMeshLOD(this.sharedMesh, LOD).then(res => {
                 if (res && this.activeAndEnabled && this.context.physics.engine && this.sharedMesh) {
                     this.context.physics.engine.removeBody(this);
                     this.sharedMesh.geometry = res;
-                    this.context.physics.engine.addMeshCollider(this, this.sharedMesh, this.convex, getWorldScale(this.gameObject));
+                    this.context.physics.engine.addMeshCollider(this, this.sharedMesh, this.convex);
                 }
             })
         }
@@ -224,7 +224,7 @@ export class MeshCollider extends Collider {
                 for (const ch in group.children) {
                     const child = group.children[ch] as Mesh;
                     if (child.isMesh) {
-                        this.context.physics.engine.addMeshCollider(this, child, this.convex, getWorldScale(this.gameObject));
+                        this.context.physics.engine.addMeshCollider(this, child, this.convex);
                         promises.push(NEEDLE_progressive.assignMeshLOD(child, LOD));
                     }
                 }
@@ -235,7 +235,7 @@ export class MeshCollider extends Collider {
                     for (const r of res) {
                         if (r && this.activeAndEnabled) {
                             mesh.geometry = r;
-                            this.context.physics.engine?.addMeshCollider(this, mesh, this.convex, getWorldScale(this.gameObject));
+                            this.context.physics.engine?.addMeshCollider(this, mesh, this.convex);
                         }
                     }
                 });

package/src/engine-components/OrbitControls.ts

@@ -287,7 +287,7 @@ export class OrbitControls extends Behaviour implements ICameraController {
             cam = this.gameObject;
         }
         if (cam) setCameraController(cam, this, true);
-        if (!this._controls && cam instanceof PerspectiveCamera) {
+        if (!this._controls && cam instanceof Object3D) {
             this._cameraObject = cam;
             // Using the parent if possible to make it possible to disable input on the canvas
             // for having HTML content behind it and still receive input

package/src/engine-components/RigidBody.ts

@@ -324,9 +324,9 @@ export class Rigidbody extends Behaviour implements IRigidbody {
                 console.warn(`Rigidbody could not be created: Rapier physics are explicitly disabled.`);
             else {
                 MODULES.RAPIER_PHYSICS.ready().then(async () => {
-                    await delayForFrames(1);
+                    await delayForFrames(3);
                     if (!this.context.physics.engine?.getBody(this))
-                        console.warn(`Rigidbody could not be created. Ensure \"(${this.name}\" has a Collider component.`);
+                        console.warn(`Rigidbody could not be created. Ensure \"${this.name}\" has a Collider component.`);
                 })
             }
         }

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

@@ -1174,7 +1174,7 @@ declare type ImageReadbackResult = {
 	imageBitmap?: ImageBitmap;
 } 
 
-/** Reads back a texture from the GPU (can be compressed, a render texture, or aynthing), apply colorScale to it, and return CPU data for further usage. 
+/** Reads back a texture from the GPU (can be compressed, a render texture, or anything), optionally applies RGBA colorScale to it, and returns CPU data for further usage. 
  * Note that there are WebGL / WebGPU rules preventing some use of data between WebGL contexts.
 */
 async function decompressGpuTexture( texture, maxTextureSize = Infinity, renderer: WebGLRenderer | null = null, colorScale: Vector4 | undefined = undefined): Promise<ImageReadbackResult> {

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

@@ -1,3 +1,3 @@
 export { type UsdzBehaviour } from "./extensions/behavior/Behaviour.js";
-export { imageToCanvas, makeNameSafeForUSD, USDZExporter as NeedleUSDZExporter, USDDocument, USDObject, USDWriter,type USDZExporterContext } from "./ThreeUSDZExporter.js";
+export { decompressGpuTexture, imageToCanvas, makeNameSafeForUSD, USDZExporter as NeedleUSDZExporter, USDDocument, USDObject, USDWriter,type USDZExporterContext } from "./ThreeUSDZExporter.js";
 export { USDZExporter } from "./USDZExporter.js";

package/src/engine-components/particlesystem/ParticleSystem.ts

@@ -1,4 +1,4 @@
-import { AxesHelper, BackSide, Blending, BufferGeometry, FrontSide, LinearSRGBColorSpace, Material, Matrix4, Mesh, NormalBlending, Object3D, PlaneGeometry, Quaternion, SpriteMaterial, Texture, Vector3, Vector4 } from "three";
+import { AxesHelper, BackSide, Blending, BufferGeometry, FrontSide, LinearSRGBColorSpace, Material, Matrix4, Mesh, MeshBasicMaterial, MeshStandardMaterial, NormalBlending, Object3D, PlaneGeometry, Quaternion, SpriteMaterial, Texture, Vector3, Vector4 } from "three";
 import type { BatchedRenderer, Behavior, BurstParameters, EmissionState, EmitterShape, FunctionColorGenerator, FunctionJSON, FunctionValueGenerator, GeneratorMemory, Particle, ParticleSystemParameters, RecordState, TrailSettings, ValueGenerator } from "three.quarks";
 import { BatchedParticleRenderer, ConstantColor, ConstantValue, ParticleSystem as _ParticleSystem, RenderMode, TrailParticle, Vector3 as QVector3, Vector4 as QVector4 } from "three.quarks";
 
@@ -39,10 +39,10 @@ export class ParticleSystemRenderer extends Behaviour {
     renderMode?: ParticleSystemRenderMode;
 
     @serializable(Material)
-    particleMaterial?: SpriteMaterial;
+    particleMaterial?: SpriteMaterial | MeshBasicMaterial;
 
     @serializable(Material)
-    trailMaterial?: SpriteMaterial;
+    trailMaterial?: SpriteMaterial | MeshBasicMaterial;
 
     // @serializable(Mesh)
     particleMesh?: Mesh | string;
@@ -68,6 +68,7 @@ export class ParticleSystemRenderer extends Behaviour {
                 // showBalloonWarning(msg);
             }
         }
+
     }
 
     get transparent(): boolean {
@@ -80,6 +81,24 @@ export class ParticleSystemRenderer extends Behaviour {
         let material = (trailEnabled === true && this.trailMaterial) ? this.trailMaterial : this.particleMaterial;
 
         if (material) {
+
+            if (material.type === "MeshStandardMaterial") {
+                if (debug) console.debug("ParticleSystemRenderer.getMaterial: MeshStandardMaterial detected, converting to MeshBasicMaterial. See https://github.com/Alchemist0823/three.quarks/issues/101");
+                if ("map" in material && material.map) {
+                    material.map.colorSpace = LinearSRGBColorSpace;
+                    material.map.premultiplyAlpha = false;
+                }
+                const newMaterial = new MeshBasicMaterial({ map: material.map });
+                if (trailEnabled) this.trailMaterial = newMaterial;
+                else this.particleMaterial = newMaterial;
+            }
+
+            
+            if (material.map) {
+                material.map.colorSpace = LinearSRGBColorSpace;
+                material.map.premultiplyAlpha = false;
+            }
+
             if (trailEnabled) {
                 // the particle material for trails must be DoubleSide or BackSide (since otherwise the trail is invisible)
                 if (material.side === FrontSide) {
@@ -896,7 +915,7 @@ export class ParticleSystem extends Behaviour implements IParticleSystem {
         if (particleSystemBehaviour instanceof ParticleSystemBaseBehaviour) {
             particleSystemBehaviour.system = this;
         }
-        if (isDevEnvironment()) console.log("add behaviour", particleSystemBehaviour);
+        if (isDevEnvironment() || debug) console.debug("Add custom ParticleSystem Behaviour", particleSystemBehaviour);
         this._particleSystem.addBehavior(particleSystemBehaviour);
         return true;
     }
@@ -908,6 +927,7 @@ export class ParticleSystem extends Behaviour implements IParticleSystem {
         const behaviours = this._particleSystem.behaviors;
         const index = behaviours.indexOf(particleSystemBehaviour);
         if (index !== -1) {
+            if (isDevEnvironment() || debug) console.debug("Remove custom ParticleSystem Behaviour", index, particleSystemBehaviour);
             behaviours.splice(index, 1);
             return true;
         }
@@ -1145,13 +1165,9 @@ export class ParticleSystem extends Behaviour implements IParticleSystem {
         }
     }
 
-    private lastMaterialVersion: number = -1;
+    // private lastMaterialVersion: number = -1;
     private onUpdate() {
-        const mat = this.renderer.getMaterial(this.trails.enabled);
-        if (mat && mat.version != this.lastMaterialVersion && this._particleSystem) {
-            this.lastMaterialVersion = mat.version;
-            this._particleSystem.texture = this._interface.texture;
-        }
+
 
         if (this._bursts) {
             this.emission.bursts = this._bursts;

package/src/engine-components/particlesystem/ParticleSystemModules.ts

@@ -1,6 +1,6 @@
 import { createNoise4D, type NoiseFunction4D } from 'simplex-noise';
 import { BufferGeometry, Color, Euler, Matrix4, Mesh, Object3D, Quaternion, Triangle, Vector2, Vector3, Vector4 } from "three";
-import type { EmitterShape, IParticleSystem as QParticleSystem,Particle, ShapeJSON, Vector3 as QVector3, Vector4 as QVector4 } from "three.quarks";
+import type { EmitterShape, IParticleSystem as QParticleSystem, Particle, ShapeJSON, Vector3 as QVector3, Vector4 as QVector4 } from "three.quarks";
 
 import { isDevEnvironment } from '../../engine/debug/index.js';
 import { Gizmos } from "../../engine/engine_gizmos.js";
@@ -360,9 +360,16 @@ export class MinMaxGradient {
                 this.gradientMax.evaluate(t01, MinMaxGradient._temp2);
                 return MinMaxGradient._temp.lerp(MinMaxGradient._temp2, t);
 
+            case ParticleSystemGradientMode.RandomColor:
+            case "RandomColor":
+                const random_t = Math.random();
+                this.gradientMin.evaluate(t01, MinMaxGradient._temp);
+                this.gradientMax.evaluate(t01, MinMaxGradient._temp2);
+                return MinMaxGradient._temp.lerp(MinMaxGradient._temp2, random_t);
+
         }
         // console.warn("Not implemented", ParticleSystemGradientMode[this.mode]);
-        MinMaxGradient._temp.set(0xff00ff)
+        MinMaxGradient._temp.set(0xffffff)
         MinMaxGradient._temp.alpha = 1;
         return MinMaxGradient._temp;
     }