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

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@needle-tools/engine",
-    "version": "2.54.2-pre",
+    "version": "2.55.0-pre",
     "description": "Needle Engine is a web-based runtime for 3D apps. It runs on your machine for development, and can be deployed anywhere. It is flexible, extensible, and collaboration and XR come naturally.",
     "main": "dist/needle-engine.js",
     "module": "src/needle-engine.ts",

package/src/engine/engine_lightdata.ts

@@ -33,7 +33,7 @@ export class LightDataRegistry implements ILightDataRegistry {
     }
 
     registerTexture(sourceId: SourceIdentifier, type: LightmapType, tex: Texture, index: number) {
-        if (debugLightmap) console.log("Registering lightmap", sourceId, LightmapType[type], tex);
+        if (debugLightmap) console.log("Registering ", LightmapType[type], tex, sourceId);
         if (!this._lightmaps.has(sourceId))
             this._lightmaps.set(sourceId, new Map());
         const map = this._lightmaps.get(sourceId);

package/src/engine/engine_mainloop_utils.ts

@@ -68,6 +68,12 @@ export function processNewScripts(context: Context) {
                 new_scripts_buffer.splice(i, 1);
                 i--; continue;
             }
+            if (script.registering) {
+                try {
+                    script.registering();
+                }
+                catch (err) { console.error(err); }
+            }
             // console.log(script, script.gameObject)
             // TODO: we should not call awake on components with inactive gameobjects
             if (script.__internalAwake !== undefined) {

package/src/engine/engine_physics.ts

@@ -15,9 +15,10 @@ import {
 import { InstancingUtil } from './engine_instancing';
 import { foreachComponent } from './engine_gameobject';
 
-import RAPIER, { ActiveEvents, Collider, ColliderDesc, EventQueue, JointData, RigidBody, RigidBodyType, World } from '@dimforge/rapier3d-compat';
-import { CollisionDetectionMode } from '../engine/engine_physics.types';
+import RAPIER, { ActiveEvents, CoefficientCombineRule, Collider, ColliderDesc, EventQueue, JointData, RigidBody, RigidBodyType, World } from '@dimforge/rapier3d-compat';
+import { CollisionDetectionMode, PhysicsMaterialCombine } from '../engine/engine_physics.types';
 import { Gizmos } from './engine_gizmos';
+import { Mathf } from './engine_math';
 export type Rapier = typeof RAPIER;
 
 
@@ -354,7 +355,7 @@ export class Physics {
         this.createCollider(collider, desc, center);
     }
 
-    addMeshCollider(collider: ICollider, mesh: Mesh, convex: boolean, scale:Vector3) {
+    addMeshCollider(collider: ICollider, mesh: Mesh, convex: boolean, scale: Vector3) {
         const geo = mesh.geometry;
         if (!geo) {
             if (debugPhysics) console.warn("Missing mesh geometry", mesh.name);
@@ -405,7 +406,7 @@ export class Physics {
         matrix.decompose(this._tempPosition, this._tempQuaternion, this._tempScale);
         getWorldScale(collider.gameObject, this._tempScale);
         if (center) {
-            center.multiply( this._tempScale);
+            center.multiply(this._tempScale);
             this._tempPosition.x -= center.x;
             this._tempPosition.y += center.y;
             this._tempPosition.z += center.z;
@@ -414,6 +415,42 @@ export class Physics {
         desc.setRotation(this._tempQuaternion);
         desc.setSensor(collider.isTrigger);
 
+        // TODO: we might want to update this if the material changes
+        const physicsMaterial = collider.sharedMaterial;
+        if (physicsMaterial) {
+            CoefficientCombineRule
+            desc.setRestitution(physicsMaterial.bounciness);
+            switch (physicsMaterial.bounceCombine) {
+                case PhysicsMaterialCombine.Average:
+                    desc.setRestitutionCombineRule(CoefficientCombineRule.Average);
+                    break;
+                case PhysicsMaterialCombine.Maximum:
+                    desc.setRestitutionCombineRule(CoefficientCombineRule.Max);
+                    break;
+                case PhysicsMaterialCombine.Minimum:
+                    desc.setRestitutionCombineRule(CoefficientCombineRule.Min);
+                    break;
+                case PhysicsMaterialCombine.Multiply:
+                    desc.setRestitutionCombineRule(CoefficientCombineRule.Multiply);
+                    break;
+            }
+            desc.setFriction(physicsMaterial.dynamicFriction);
+            switch (physicsMaterial.frictionCombine) {
+                case PhysicsMaterialCombine.Average:
+                    desc.setFrictionCombineRule(CoefficientCombineRule.Average);
+                    break;
+                case PhysicsMaterialCombine.Maximum:
+                    desc.setFrictionCombineRule(CoefficientCombineRule.Max);
+                    break;
+                case PhysicsMaterialCombine.Minimum:
+                    desc.setFrictionCombineRule(CoefficientCombineRule.Min);
+                    break;
+                case PhysicsMaterialCombine.Multiply:
+                    desc.setFrictionCombineRule(CoefficientCombineRule.Multiply);
+                    break;
+            }
+        }
+
         // if we want to use explicit mass properties, we need to set the collider density to 0
         // otherwise rapier will compute the mass properties based on the collider shape and density
         // https://rapier.rs/docs/user_guides/javascript/rigid_bodies#mass-properties
@@ -583,12 +620,17 @@ export class Physics {
     // private _lastStepTime: number | undefined = 0;
     private lines?: LineSegments;
 
-    public step(_deltaTime?: number) {
+    public step(dt?: number) {
         if (!this.world) return;
         this._isUpdatingPhysicsWorld = true;
         if (!this.eventQueue) {
             this.eventQueue = new EventQueue(false);
         }
+        if (dt) {
+            // if we make to sudden changes to the timestep the physics can get unstable
+            // https://rapier.rs/docs/user_guides/javascript/integration_parameters/#dt
+            this.world.timestep = Mathf.lerp(this.world.timestep, dt, 0.8);
+        }
         this.world.step(this.eventQueue);
         this._isUpdatingPhysicsWorld = false;
         this.updateDebugRendering(this.world);

package/src/engine/engine_physics.types.ts

@@ -1,5 +1,22 @@
 
 
+
+export enum PhysicsMaterialCombine
+{
+  Average = 0,
+  Multiply = 1,
+  Minimum = 2,
+  Maximum = 3,
+}
+
+export type PhysicsMaterial = {
+  bounceCombine: PhysicsMaterialCombine;
+  bounciness: number;
+  frictionCombine: PhysicsMaterialCombine;
+  dynamicFriction: number;
+  staticFriction: number;
+}
+
 export enum CollisionDetectionMode {
   Discrete = 0,
   Continuous = 1,

package/src/engine/engine_setup.ts

@@ -315,8 +315,8 @@ export class Context {
 			this.renderer.domElement.style.width = "100%";
 			this.renderer.domElement.style.height = "100%";
 			if (this.composer) {
-				this.composer.setSize(width, height);
-				this.composer.setPixelRatio(window.devicePixelRatio);
+				this.composer.setSize?.call(this.composer, width, height);
+				this.composer.setPixelRatio?.call(this.composer, window.devicePixelRatio);
 			}
 		}
 	}

package/src/engine/engine_time.ts

@@ -1,10 +1,15 @@
-
 import { Clock } from 'three'
+import { getParam } from './engine_utils';
+
+const debug = getParam("debugtime");
+let timeScale = 1;
+if(typeof debug === "number") timeScale = debug;
 
 export class Time {
 
     deltaTime = 0;
     time = 0;
+    timeScale = 1;
 
     /** same as frameCount */
     frame = 0;
@@ -27,6 +32,7 @@ export class Time {
         this.deltaTime = this.clock.getDelta();
         // clamp delta time because if tab is not active clock.getDelta can get pretty big
         this.deltaTime = Math.min(.1, this.deltaTime);
+        this.deltaTime *= timeScale * this.timeScale;
         if(this.deltaTime <= 0) this.deltaTime = 0.000000000001;
         this.frame += 1;
         this.time += this.deltaTime;

package/src/engine/engine_types.ts

@@ -1,6 +1,6 @@
 import { Camera, Color, Material, Object3D, Vector3, Quaternion, Ray } from "three";
 import { RGBAColor } from "../engine-components/js-extensions/RGBAColor";
-import { CollisionDetectionMode, RigidbodyConstraints } from "./engine_physics.types";
+import { CollisionDetectionMode, PhysicsMaterial, RigidbodyConstraints } from "./engine_physics.types";
 import { getWorldPosition } from "./engine_three_utils";
 import { CircularBuffer } from "./engine_utils";
 
@@ -67,6 +67,8 @@ export interface IComponent {
     __internalDestroy();
     resolveGuids?(guidsMap: GuidsMap): void;
 
+    /** experimental, called when the script is registered for the first time, this is called even if the component is not enabled. */
+    registering?();
     awake();
     onEnable();
     onDisable();
@@ -78,7 +80,7 @@ export interface IComponent {
     /** called when this.context.isPaused changes or when rendering loop changes due to changing DOM element visibility
      * e.g. when the DOM element becomes hidden or out ot view
      */
-    onPausedChanged?(isPaused:boolean, wasPaused:boolean);
+    onPausedChanged?(isPaused: boolean, wasPaused: boolean);
 
     start?(): void;
     earlyUpdate?(): void;
@@ -138,6 +140,7 @@ export declare interface ICollider extends IComponent {
     get isCollider();
     attachedRigidbody: IRigidbody | null;
     isTrigger: boolean;
+    sharedMaterial?: PhysicsMaterial;
 }
 
 export declare interface IRigidbody extends IComponent {

package/src/engine/engine_utils.ts

@@ -385,4 +385,8 @@ export function isiOS() {
 
 export function isSafari() {
     return /^((?!chrome|android).)*safari/i.test(navigator.userAgent);
+}
+
+export function isQuest() {
+    return navigator.userAgent.includes("OculusBrowser");
 }

package/src/engine-components/Collider.ts

@@ -5,6 +5,7 @@ import { Event, Mesh, Object3D, Vector3 } from "three"
 // import { IColliderProvider, registerColliderProvider } from "../engine/engine_physics";
 import { ICollider } from "../engine/engine_types";
 import { getWorldScale } from "../engine/engine_three_utils";
+import { PhysicsMaterial } from "../engine/engine_physics.types";
 
 
 export class Collider extends Behaviour implements ICollider {
@@ -18,6 +19,8 @@ export class Collider extends Behaviour implements ICollider {
     @serializable()
     isTrigger: boolean = false;
 
+    @serializable()
+    sharedMaterial?: PhysicsMaterial;
 
     awake() {
         super.awake();

package/src/engine-components/ParticleSystem.ts

@@ -548,6 +548,8 @@ export class ParticleSystem extends Behaviour implements IParticleSystem {
     private _state?: ParticlesEmissionState;
     emit(count: number) {
         if (this._particleSystem) {
+            // we need to call update the matrices etc e.g. if we call emit from a physics callback
+            this.onUpdate();
             count = Math.min(count, this.maxParticles - this.currentParticles);
             if (!this._state) this._state = new ParticlesEmissionState();
             this._state.waitEmiting = count;
@@ -768,6 +770,14 @@ export class ParticleSystem extends Behaviour implements IParticleSystem {
     }
 
     onBeforeRender() {
+        this.onUpdate();
+        const dt = this.deltaTime;
+        this._batchSystem?.update(dt);
+        this._time += dt;
+        if (this._time > this.duration) this._time = 0;
+    }
+
+    private onUpdate(){
         if (this._bursts) {
             this.emission.bursts = this._bursts;
             delete this._bursts;
@@ -796,17 +806,12 @@ export class ParticleSystem extends Behaviour implements IParticleSystem {
             this._container.matrix.identity();
             this._container.matrix.scale(scale);
         }
-
         this.emission.system = this;
-        const dt = this.deltaTime;
         this._interface.update();
         this.shape.update(this, this.context, this.main.simulationSpace, this.gameObject);
         this.noise.update(this.context);
         this.inheritVelocity?.update(this.context);
         this.velocityOverLifetime.update(this);
-        this._batchSystem?.update(dt);
-        this._time += dt;
-        if (this._time > this.duration) this._time = 0;
     }
 
     private addSubParticleSystems() {

package/src/engine-components/ParticleSystemModules.ts

@@ -6,6 +6,11 @@ import { AnimationCurve } from "./AnimationCurve";
 import { Vec2, Vec3 } from "../engine/engine_types";
 import { Context } from "../engine/engine_setup";
 import { EmitterShape, FrameOverLife, Particle, ShapeJSON } from "three.quarks";
+import { createNoise4D, NoiseFunction4D } from 'simplex-noise';
+import { Gizmos } from "../engine/engine_gizmos";
+import { getParam } from "../engine/engine_utils";
+
+const debug = getParam("debugparticles");
 
 declare type Color4 = { r: number, g: number, b: number, a: number };
 declare type ColorKey = { time: number, color: Color4 };
@@ -457,10 +462,10 @@ export class SizeOverLifetimeModule {
 
 export class ShapeModule implements EmitterShape {
 
+    // Emittershape start
     get type(): string {
         return ParticleSystemShapeType[this.shapeType];
     }
-
     initialize(particle: Particle): void {
         this.getPosition();
         particle.position.copy(this._vector);
@@ -471,6 +476,7 @@ export class ShapeModule implements EmitterShape {
     clone(): EmitterShape {
         return new ShapeModule();
     }
+    // EmitterShape end
 
     @serializable()
     shapeType: ParticleSystemShapeType = ParticleSystemShapeType.Box;
@@ -574,16 +580,12 @@ export class ShapeModule implements EmitterShape {
                     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;
+                    this.randomSpherePoint(this.position, radius, this.radiusThickness, this.arc, this._vector, this.scale);
                     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;
+                    this._temp.copy(this.scale);
+                    this._temp.z = 0;
+                    this.randomSpherePoint(this.position, radius, this.radiusThickness, this.arc, this._vector, this._temp);
                     break;
                 default:
                     this._vector.set(0, 0, 0);
@@ -600,6 +602,7 @@ export class ShapeModule implements EmitterShape {
             this._vector.applyEuler(this._rotation);
 
         if (isWorldSpace) {
+            this._vector.applyQuaternion(this.system.worldQuaternion);
             this._vector.add(this.system.worldPos);
         }
     }
@@ -607,7 +610,8 @@ export class ShapeModule implements EmitterShape {
 
 
     private _dir: Vector3 = new Vector3();
-    getDirection(position): Vector3 {
+
+    getDirection(pos: Vec3): Vector3 {
         if (!this.enabled) {
             this._dir.set(0, 0, 1);
             return this._dir;
@@ -623,10 +627,11 @@ export class ShapeModule implements EmitterShape {
                 break;
             case ParticleSystemShapeType.Circle:
             case ParticleSystemShapeType.Sphere:
-                const rx = position.x;
-                const ry = position.y;
-                const rz = position.z;
-                this._dir.set(rx, ry, rz).sub(this.position)
+                const rx = pos.x;
+                const ry = pos.y;
+                const rz = pos.z;
+                this._dir.set(rx, ry, rz)
+                this._dir.sub(this.position)
                 break;
             default:
                 this._dir.set(0, 0, 1);
@@ -640,7 +645,10 @@ export class ShapeModule implements EmitterShape {
         this._dir.normalize();
         this.spherizeDirection(this._dir, this.sphericalDirectionAmount);
         this.randomizeDirection(this._dir, this.randomDirectionAmount);
-        // Gizmos.DrawDirection(position, this._dir, 0xff0000, .5);
+        if (debug) {
+            Gizmos.DrawSphere(pos, .01, 0x883300, .5, true);
+            Gizmos.DrawDirection(pos, this._dir, 0x883300, .5, true);
+        }
         return this._dir;
     }
 
@@ -677,15 +685,15 @@ export class ShapeModule implements EmitterShape {
         dir.lerp(v, amount);
     }
 
-    private randomSpherePoint(pos: Vec3, radius: number, thickness: number, arc: number, vec: Vec3) {
+    private randomSpherePoint(pos: Vec3, radius: number, thickness: number, arc: number, vec: Vec3, scale: Vec3) {
         const u = Math.random();
         const v = Math.random();
         const theta = 2 * Math.PI * u * (arc / 360);
         const phi = Math.acos(2 * v - 1);
         const r = Mathf.lerp(1, 1 - (Math.pow(1 - Math.random(), Math.PI)), thickness) * (radius);
-        const x = pos.x + (-r * Math.sin(phi) * Math.cos(theta));
-        const y = pos.y + (r * Math.sin(phi) * Math.sin(theta));
-        const z = pos.z + (r * Math.cos(phi));
+        const x = pos.x + scale.x * (-r * Math.sin(phi) * Math.cos(theta));
+        const y = pos.y + scale.y * (r * Math.sin(phi) * Math.sin(theta));
+        const z = pos.z + scale.z * (r * Math.cos(phi));
         vec.x = x;
         vec.y = y;
         vec.z = z;
@@ -738,7 +746,6 @@ export class ShapeModule implements EmitterShape {
 
 
 
-import { createNoise4D, NoiseFunction4D } from 'simplex-noise';
 
 export class NoiseModule {
     @serializable()

package/src/engine-components/Renderer.ts

@@ -229,6 +229,12 @@ export class Renderer extends Behaviour implements IRenderer {
 
     allowProgressiveLoading: boolean = true;
 
+    registering() {
+        if (!this.enabled) {
+            this.setVisibility(false);
+        }
+    }
+
     awake() {
         this.clearInstancingState();
 

package/src/engine-components/RigidBody.ts

@@ -359,26 +359,7 @@ export class Rigidbody extends Behaviour implements IRigidbody {
     /**d
      * @deprecated not used anymore
      */
-    public setBodyFromGameObject(_velocity: THREE.Vector3 | null | { x: number, y: number, z: number } = null) {
-        if (this.gameObject && !this.destroyed) {
-            // this.context.physics.updateBody(this);
-            // this._ignoreChange = true;
-            // const wp = this.worldPosition;
-            // this.body.position.set(wp.x, wp.y, wp.z);
-            // const wr = this.worldQuaternion;
-            // this.body.quaternion.set(wr.x, wr.y, wr.z, wr.w);
-
-            // if (velocity) {
-            //     Rigidbody.copyVector3.set(velocity.x, velocity.y, velocity.z);
-            //     this._smoothedVelocity.lerp(Rigidbody.copyVector3, this.context.time.deltaTime / .1);
-            //     const sm = this._smoothedVelocity;
-            //     this.body.velocity.x = sm.x;
-            //     this.body.velocity.y = sm.y;
-            //     this.body.velocity.z = sm.z;
-            // }
-            // this._ignoreChange = false;
-        }
-    }
+    public setBodyFromGameObject(_velocity: THREE.Vector3 | null | { x: number, y: number, z: number } = null) { }
 
 
 

package/src/engine-components/SyncedTransform.ts

@@ -268,7 +268,6 @@ export class SyncedTransform extends Behaviour {
             if (this.rb) {
                 this.rb.isKinematic = this._model.isOwned ?? false;
                 this.rb.setVelocity(0, 0, 0);
-                this.rb.setBodyFromGameObject();
             }
             return;
         }
@@ -288,7 +287,6 @@ export class SyncedTransform extends Behaviour {
                     console.log("RESET", this.name)
                 this.gameObject.position.set(0, 1, 0);
                 this.rb.setVelocity(0, 0, 0);
-                this.rb.setBodyFromGameObject();
             }
         }
 
@@ -300,7 +298,7 @@ export class SyncedTransform extends Behaviour {
                 console.log("send update", this.context.connection.connectionId, this.guid, this.gameObject.name, this.gameObject.guid);
 
             if (this.overridePhysics && this.rb) {
-                this.rb.setBodyFromGameObject();
+                // this.rb.setBodyFromGameObject();
             }
 
             this._needsUpdate = false;