@needle-tools/engine 3.2.6-alpha → 3.2.8-alpha

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@needle-tools/engine",
-    "version": "3.2.6-alpha",
+    "version": "3.2.8-alpha",
     "description": "Needle Engine is a web-based runtime for 3D apps. It runs on your machine for development with great integrations into editors like Unity or Blender - and can be deployed onto any device! It is flexible, extensible and networking and XR are built-in",
     "main": "dist/needle-engine.umd.cjs",
     "type": "module",

package/src/engine/codegen/register_types.js

@@ -1,5 +1,5 @@
 import { TypeStore } from "./../engine_typestore"
-
+
 // Import types
 import { __Ignore } from "../../engine-components/codegen/components";
 import { AlignmentConstraint } from "../../engine-components/AlignmentConstraint";
@@ -187,7 +187,7 @@ import { XRGrabModel } from "../../engine-components/webxr/WebXRGrabRendering";
 import { XRGrabRendering } from "../../engine-components/webxr/WebXRGrabRendering";
 import { XRRig } from "../../engine-components/webxr/WebXRRig";
 import { XRState } from "../../engine-components/XRFlag";
-
+
 // Register types
 TypeStore.add("__Ignore", __Ignore);
 TypeStore.add("AlignmentConstraint", AlignmentConstraint);

package/src/engine/engine_input.ts

@@ -79,6 +79,20 @@ export class Input extends EventTarget {
             this.context.domElement.style.cursor = "default";
     }
 
+    setPointerUsed(i: number, used: boolean = true) {
+        if (i >= this._pointerUsed.length) {
+            if (i >= this._pointerIds.length)
+                return;
+            while (this._pointerUsed.length <= i) {
+                this._pointerUsed.push(false);
+            }
+        }
+        this._pointerUsed[i] = used;
+    }
+    getPointerUsed(i: number) {
+        if (i >= this._pointerUsed.length) return false;
+        return this._pointerUsed[i];
+    }
     /** how many pointers are currently pressed */
     getPointerPressedCount(): number {
         let count = 0;
@@ -225,6 +239,7 @@ export class Input extends EventTarget {
     private _mouseWheelChanged: boolean[] = [false];
     private _mouseWheelDeltaY: number[] = [0];
     private _pointerEvent: Event[] = [];
+    private _pointerUsed: boolean[] = [];
 
     getKeyDown(): string | null {
         for (const key in this.keysPressed) {
@@ -545,6 +560,9 @@ export class Input extends EventTarget {
         // }
         this.setPointerState(evt.button, this._pointerUp, true);
 
+        while (evt.button >= this._pointerUsed.length) this._pointerUsed.push(false);
+        this.setPointerState(evt.button, this._pointerUsed, false);
+
         this.updatePointerPosition(evt);
 
         if (!this._pointerPositionDown[evt.button]) {

package/src/engine/engine_physics.ts

@@ -15,7 +15,7 @@ import {
 import { InstancingUtil } from './engine_instancing';
 import { foreachComponent } from './engine_gameobject';
 
-import RAPIER, { ActiveEvents, CoefficientCombineRule, Collider, ColliderDesc, EventQueue, JointData, QueryFilterFlags, RigidBody, RigidBodyType, ShapeColliderTOI, World } from '@dimforge/rapier3d-compat';
+import RAPIER, { ActiveCollisionTypes, ActiveEvents, CoefficientCombineRule, Collider, ColliderDesc, EventQueue, JointData, QueryFilterFlags, RigidBody, RigidBodyType, ShapeColliderTOI, World } from '@dimforge/rapier3d-compat';
 import { CollisionDetectionMode, PhysicsMaterialCombine } from '../engine/engine_physics.types';
 import { Gizmos } from './engine_gizmos';
 import { Mathf } from './engine_math';
@@ -645,6 +645,8 @@ export class Physics {
         col[$componentKey] = collider;
         collider[$bodyKey] = col;
         col.setActiveEvents(ActiveEvents.COLLISION_EVENTS);
+        // We want to receive collisitons between two triggers too
+        col.setActiveCollisionTypes(ActiveCollisionTypes.ALL);
         
         // const objectLayerMask = collider.gameObject.layers.mask;
         // const mask = objectLayerMask & ~2;
@@ -1082,7 +1084,7 @@ class PhysicsCollisionHandler {
         // if one is a trigger we dont get collisions but want to raise the trigger events
         if (self.isTrigger || other.isTrigger) {
             foreachComponent(self.gameObject, (c: IComponent) => {
-                if (c.onTriggerEnter) {
+                if (c.onTriggerEnter && !c.destroyed) {
                     c.onTriggerEnter(other);
                 }
                 this.activeTriggers.push({ collider: self, component: c, otherCollider: other });
@@ -1093,6 +1095,7 @@ class PhysicsCollisionHandler {
             // TODO: we dont respect the flip value here!
             this.world.contactPair(selfBody, otherBody, (manifold, _flipped) => {
                 foreachComponent(object, (c: IComponent) => {
+                    if(c.destroyed) return;
                     const hasDeclaredEventMethod = c.onCollisionEnter || c.onCollisionStay || c.onCollisionExit;
                     if (hasDeclaredEventMethod || debugCollisions) {
                         if (!collision) {
@@ -1137,6 +1140,7 @@ class PhysicsCollisionHandler {
     private onHandleCollisionStay() {
         for (const active of this.activeCollisionsStay) {
             const c = active.component;
+            if(c.destroyed) continue;
             if (c.activeAndEnabled && c.onCollisionStay) {
                 const arg = active.collision;
                 c.onCollisionStay(arg);
@@ -1144,6 +1148,7 @@ class PhysicsCollisionHandler {
         }
         for (const active of this.activeTriggers) {
             const c = active.component;
+            if(c.destroyed) continue;
             if (c.activeAndEnabled && c.onTriggerStay) {
                 const arg = active.otherCollider;
                 c.onTriggerStay(arg);
@@ -1152,9 +1157,15 @@ class PhysicsCollisionHandler {
     }
 
     private onCollisionEnded(self: ICollider, other: ICollider) {
+        if(self.destroyed || other.destroyed) return;
         for (let i = 0; i < this.activeCollisions.length; i++) {
             const active = this.activeCollisions[i];
             const collider = active.collider;
+            if(collider.destroyed) {
+                this.activeCollisions.splice(i, 1);
+                i--;
+                continue;
+            }
             if (collider === self && active.collision.collider === other) {
                 const c = active.component;
                 this.activeCollisions.splice(i, 1);
@@ -1168,6 +1179,11 @@ class PhysicsCollisionHandler {
         for (let i = 0; i < this.activeCollisionsStay.length; i++) {
             const active = this.activeCollisionsStay[i];
             const collider = active.collider;
+            if(collider.destroyed) {
+                this.activeCollisionsStay.splice(i, 1);
+                i--;
+                continue;
+            }
             if (collider === self && active.collision.collider === other) {
                 const c = active.component;
                 this.activeCollisionsStay.splice(i, 1);
@@ -1181,6 +1197,11 @@ class PhysicsCollisionHandler {
         for (let i = 0; i < this.activeTriggers.length; i++) {
             const active = this.activeTriggers[i];
             const collider = active.collider;
+            if(collider.destroyed) {
+                this.activeTriggers.splice(i, 1);
+                i--;
+                continue;
+            }
             if (collider === self && active.otherCollider === other) {
                 const c = active.component;
                 this.activeTriggers.splice(i, 1);

package/src/engine/extensions/NEEDLE_lighting_settings.ts

@@ -8,6 +8,7 @@ import { getParam } from "../engine_utils";
 import { Context } from "../engine_setup";
 import { LightProbe } from "three";
 import { ContextEvent, ContextRegistry } from "../engine_context_registry";
+import { Mathf } from "../engine_math";
 
 export const EXTENSION_NAME = "NEEDLE_lighting_settings";
 const debug = getParam("debugenvlight");
@@ -122,13 +123,22 @@ export class SceneLightSettings extends Behaviour {
         this.context.sceneLighting.internalUnregisterSceneLightSettings(this);
     }
 
+    private calculateIntensityFactor(col:Color){
+        const intensity = Math.max(col.r, col.g, col.b);// * 0.2126 + col.g * 0.7152 + col.b * 0.0722;
+        const factor = 2.2 * Mathf.lerp(0, 1.33, intensity); // scale based on intensity
+        return factor;
+    }
+
     onEnable(): void {
         if (debug) console.warn("💡🟡 >>> Enable lighting", this.sourceId, this);
 
         if (this.ambientMode == AmbientMode.Flat) {
             if (this.ambientLight && !this._ambientLightObj) {
-                this._ambientLightObj = new AmbientLight(this.ambientLight, this.ambientIntensity);
-                if (debug) console.log("Created ambient light", this.sourceId, this._ambientLightObj)
+                // TODO: currently ambient intensity is always exported as 1? The exported values are not correct in threejs
+                // the following calculation is a workaround to get the correct intensity
+                const factor = this.calculateIntensityFactor(this.ambientLight);
+                this._ambientLightObj = new AmbientLight(this.ambientLight, this.ambientIntensity * factor);
+                if (debug) console.log("Created ambient light", this.sourceId, this._ambientLightObj, this.ambientIntensity, factor)
             }
             if (this._ambientLightObj) {
                 this.gameObject.add(this._ambientLightObj)
@@ -139,8 +149,10 @@ export class SceneLightSettings extends Behaviour {
             if (this.ambientTrilight) {
                 const ground = this.ambientTrilight[0];
                 const sky = this.ambientTrilight[this.ambientTrilight.length - 1];
-                this._hemisphereLightObj = new HemisphereLight(sky, ground, this.ambientIntensity);
+                const factor = this.calculateIntensityFactor(sky);
+                this._hemisphereLightObj = new HemisphereLight(sky, ground, this.ambientIntensity * factor);
                 this.gameObject.add(this._hemisphereLightObj)
+                if (debug) console.log("Created hemisphere ambient light", this.sourceId, this._hemisphereLightObj, this.ambientIntensity, factor)
             }
         }
         else {

package/src/engine-components/Component.ts

@@ -9,6 +9,7 @@ import { addNewComponent, destroyComponentInstance, findObjectOfType, findObject
 import { findByGuid, destroy, InstantiateOptions, instantiate, HideFlags, foreachComponent, markAsInstancedRendered, isActiveInHierarchy, isActiveSelf, isUsingInstancing, setActive, isDestroyed } from "../engine/engine_gameobject";
 
 import { Euler, Object3D, Quaternion, Scene, Vector3 } from "three";
+import { showBalloonWarning, isDevEnvironment } from "../engine/debug";
 
 // export interface ISerializationCallbackReceiver {
 //     onBeforeSerialize?(): object | void;
@@ -470,6 +471,12 @@ export class Component implements IComponent, EventTarget {
 
     /** @internal */
     __internalEnable(): boolean {
+        if (this.__destroyed) {
+            if (isDevEnvironment()) {
+                console.warn("[Needle Engine Dev] Trying to enable destroyed component");
+            }
+            return false;
+        }
         // Don't change enable before awake
         // But a user can change enable during awake
         if (!this.__didAwake) return false;
@@ -511,6 +518,12 @@ export class Component implements IComponent, EventTarget {
         return typeof this.__isEnabled === "boolean" ? this.__isEnabled : true; // if it has no enabled field it is always enabled
     }
     set enabled(val: boolean) {
+        if (this.__destroyed) {
+            if (isDevEnvironment()) {
+                console.warn(`[Needle Engine Dev] Trying to ${val ? "enable" : "disable"} destroyed component`);
+            }
+            return;
+        }
         // when called from animationclip we receive numbers
         // due to interpolation they can be anything between 0 and 1
         if (typeof val === "number") {

package/src/engine-components/ui/EventSystem.ts

@@ -113,7 +113,7 @@ export class EventSystem extends Behaviour {
         this._selectStartFn ??= (ctrl, args: { grab: THREE.Object3D | null }) => {
             if (!args.grab) return;
             MeshUIHelper.resetLastSelected();
-            const opts = new PointerEventData();
+            const opts = new PointerEventData(this.context.input);
             opts.inputSource = ctrl;
             opts.isDown = ctrl.selectionDown;
             opts.isUp = ctrl.selectionUp;
@@ -126,7 +126,7 @@ export class EventSystem extends Behaviour {
         }
         this._selectEndFn ??= (ctrl, args: { grab: THREE.Object3D }) => {
             if (!args.grab) return;
-            const opts = new PointerEventData();
+            const opts = new PointerEventData(this.context.input);
             opts.inputSource = ctrl;
             opts.isDown = ctrl.selectionDown;
             opts.isUp = ctrl.selectionUp;
@@ -155,7 +155,7 @@ export class EventSystem extends Behaviour {
             controllerRcOpts.ray = _ctrl.getRay();
             const rc = this.performRaycast(controllerRcOpts);
             if (!rc) return;
-            const opts = new PointerEventData();
+            const opts = new PointerEventData(this.context.input);
             opts.inputSource = _ctrl;
             this.handleIntersections(rc, opts);
         };
@@ -230,7 +230,7 @@ export class EventSystem extends Behaviour {
 
         const ptr = this.context.input.getPointerEvent(pointerId);
         // console.log(ptr);
-        const args: PointerEventData = new PointerEventData(ptr);
+        const args: PointerEventData = new PointerEventData(this.context.input, ptr);
         args.inputSource = this.context.input;
         args.pointerId = pointerId;
         args.isClicked = this.context.input.getPointerClicked(pointerId)

package/src/engine-components/ui/PointerEvents.ts

@@ -7,10 +7,14 @@ export interface IInputEventArgs {
 }
 
 export class PointerEventData implements IInputEventArgs {
+
+    // TODO: should we make this a getter and return the input used state instead? -> this.context.getPointerUsed(this.pointerId);
     used: boolean = false;
 
     Use() {
         this.used = true;
+        if (this.pointerId !== undefined)
+            this.input.setPointerUsed(this.pointerId);
     }
 
     StopPropagation() {
@@ -26,10 +30,13 @@ export class PointerEventData implements IInputEventArgs {
     isPressed: boolean | undefined;
     isClicked: boolean | undefined;
 
+    private input: Input;
+
     private event?: Event;
 
-    constructor(events?: Event) {
+    constructor(input: Input, events?: Event) {
         this.event = events;
+        this.input = input;
     }
 }