@needle-tools/engine 3.37.3-alpha → 3.37.4-alpha

package/src/engine/engine_types.ts

@@ -1,3 +1,4 @@
+import type { QueryFilterFlags } from "@dimforge/rapier3d-compat";
 import { Camera, Color, Material, Mesh, Object3D, Quaternion, Ray, Scene, WebGLRenderer } from "three";
 import { Vector3 } from "three";
 import { type GLTF as GLTF3 } from "three/examples/jsm/loaders/GLTFLoader.js";
@@ -251,12 +252,14 @@ export declare interface ICollider extends IComponent {
     updatePhysicsMaterial(): void;
     /** The collider membership indicates what groups the collider is part of (e.g. group 2 and 3)     
      * An `undefined` array indicates that the collider is part of all groups  
-     * Note: Make sure to call updateProperties after having changed this property
+     * Note: Make sure to call updateProperties after having changed this property  
+     * Default: [0]
     */
     membership?: number[];
     /** The collider filter indicates what groups the collider can interact with (e.g. group 3 and 4)   
      * An `undefined` array indicates that the collider can interact with all groups   
-     * Note: Make sure to call updateProperties after having changed this property
+     * Note: Make sure to call updateProperties after having changed this property  
+     * Default: undefined
     */
     filter?: number[];
 }
@@ -278,6 +281,7 @@ export declare interface IRigidbody extends IComponent {
     drag: number;
     angularDrag: number;
     useGravity: boolean;
+    centerOfMass: Vec3;
     gravityScale: number;
     dominanceGroup: number;
 
@@ -436,12 +440,31 @@ export interface IPhysicsEngine {
     /** Fast raycast against physics colliders
      * @param origin ray origin in screen or worldspace
      * @param direction ray direction in worldspace
-     * @param maxDistance max distance to raycast
-     * @param solid if true it will also hit the collider if origin is already inside it
+     * @param options additional options
      */
-    raycast(origin?: Vec2 | Vec3, direction?: Vec3, maxDistance?: number, solid?: boolean): RaycastResult;
+    raycast(origin?: Vec2 | Vec3, direction?: Vec3, options?: {
+        maxDistance?: number,
+        /** True if you want to also hit objects when the raycast starts from inside a collider */
+        solid?: boolean,
+        queryFilterFlags?: QueryFilterFlags,
+        /** Raycast filter groups.  Groups are used to apply the collision group rules for the scene query. The scene query will only consider hits with colliders with collision groups compatible with this collision group (using the bitwise test described in the collision groups section). See https://rapier.rs/docs/user_guides/javascript/colliders#collision-groups-and-solver-groups    
+         * For example membership 0x0001 and filter 0x0002 should be 0x00010002 */
+        filterGroups?: number,
+        /** Return false to ignore this collider */
+        filterPredicate?: (collider: ICollider) => boolean
+    }): RaycastResult;
     /** raycast that also gets the normal vector. If you don't need it use raycast() */
-    raycastAndGetNormal(origin?: Vec2 | Vec3, direction?: Vec3, maxDistance?: number, solid?: boolean): RaycastResult;
+    raycastAndGetNormal(origin?: Vec2 | Vec3, direction?: Vec3, options?: {
+        maxDistance?: number,
+        /** True if you want to also hit objects when the raycast starts from inside a collider */
+        solid?: boolean,
+        queryFilterFlags?: QueryFilterFlags,
+        /** Raycast filter groups.  Groups are used to apply the collision group rules for the scene query. The scene query will only consider hits with colliders with collision groups compatible with this collision group (using the bitwise test described in the collision groups section). See https://rapier.rs/docs/user_guides/javascript/colliders#collision-groups-and-solver-groups    
+         * For example membership 0x0001 and filter 0x0002 should be 0x00010002 */
+        filterGroups?: number,
+        /** Return false to ignore this collider */
+        filterPredicate?: (collider: ICollider) => boolean
+    }): RaycastResult;
     sphereOverlap(point: Vector3, radius: number): Array<SphereOverlapResult>;
 
     // Collider methods

package/src/engine/extensions/NEEDLE_lighting_settings.ts

@@ -94,8 +94,6 @@ export class SceneLightSettings extends Behaviour {
     private _hasReflection: boolean = false;
     private _ambientLightObj?: AmbientLight;
     private _hemisphereLightObj?: HemisphereLight;
-    // used when skybox is used to support ambient intensity for "non custom shaders"
-    private _lightProbeObj?: LightProbe;
 
     awake() {
         if (this.sourceId) {
@@ -154,7 +152,6 @@ export class SceneLightSettings extends Behaviour {
             if (this._ambientLightObj) {
                 this.gameObject.add(this._ambientLightObj)
             }
-            if (this._lightProbeObj) this._lightProbeObj.removeFromParent();
         }
         else if (this.ambientMode === AmbientMode.Trilight) {
             if (this.ambientTrilight) {
@@ -180,8 +177,6 @@ export class SceneLightSettings extends Behaviour {
     onDisable() {
         if (debug)
             console.warn("💡⚫ <<< Disable lighting:", this.sourceId, this);
-        if (this._lightProbeObj)
-            this._lightProbeObj.removeFromParent();
         if (this._ambientLightObj)
             this._ambientLightObj.removeFromParent();
         if (this._hemisphereLightObj)

package/src/engine/webcomponents/needle menu/needle-menu.ts

@@ -371,7 +371,20 @@ export class NeedleMenuElement extends HTMLElement {
             width: 100%;
         }
 
-
+        @media (max-width: 300px) or (max-height: 350px){
+            .options {
+                display: none;
+                padding: 0;
+                margin: 0;
+                border: none;
+            }
+            .logo.any-options {
+                border: none !important;
+                padding: 0;
+                margin-bottom: 0 !important;
+                padding-bottom: 0 !important;
+            }
+        }
         
         /* dark mode */
         /*

package/src/engine-components/Collider.ts

@@ -15,45 +15,65 @@ import { Rigidbody } from "./RigidBody.js";
  * Collider is the base class for all colliders. A collider is a physical shape that is used to detect collisions with other objects in the scene.  
  * Colliders are used in combination with a Rigidbody to create physical interactions between objects.  
  * Colliders are registered with the physics engine when they are enabled and removed when they are disabled.
- * @category Physics
+ * @category Physics  
+ * @inheritdoc
  */
 export class Collider extends Behaviour implements ICollider {
 
+    /** @internal */
     get isCollider(): any {
         return true;
     }
 
+    /**
+     * The Rigidbody that this collider is attached to.
+     */
     @serializable(Rigidbody)
     attachedRigidbody: Rigidbody | null = null;
 
+    /**
+     * When `true` the collider will not be used for collision detection but will still trigger events.
+     */
     @serializable()
     isTrigger: boolean = false;
 
+    /**
+     * The physics material that is used for the collider. This material defines physical properties of the collider such as friction and bounciness.
+     */
     @serializable()
     sharedMaterial?: PhysicsMaterial;
 
+    /**
+     * The layers that the collider is assigned to.
+     */
     @serializable()
     membership: number[] = [0];
+
+    /**
+     * The layers that the collider will interact with.
+     * @inheritdoc
+     */
     @serializable()
     filter?: number[];
 
+    /** @internal */
     awake() {
         super.awake();
         if (!this.attachedRigidbody)
             this.attachedRigidbody = this.gameObject.getComponentInParent(Rigidbody);
     }
-
+    /** @internal */
     start() {
         if (!this.attachedRigidbody)
             this.attachedRigidbody = this.gameObject.getComponentInParent(Rigidbody);
     }
-
+    /** @internal */
     onEnable() {
         // a rigidbody is not assigned if we export an asset
         if (!this.attachedRigidbody)
             this.attachedRigidbody = this.gameObject.getComponentInParent(Rigidbody);
     }
-
+    /** @internal */
     onDisable() {
         this.context.physics.engine?.removeBody(this);
     }
@@ -63,6 +83,9 @@ export class Collider extends Behaviour implements ICollider {
         return this.context.physics.engine?.getBody(this);
     }
 
+    /**
+     * Apply the collider properties to the physics engine.
+     */
     updateProperties = () => {
         this.context.physics.engine?.updateProperties(this);
     }

package/src/engine-components/RigidBody.ts

@@ -167,8 +167,11 @@ export class Rigidbody extends Behaviour implements IRigidbody {
     @serializable()
     useGravity: boolean = true;
 
-    @serializable()
-    centerOfMass: Vector3 = new Vector3();
+    /**
+     * The center of mass is the point around which the mass of the rigid-body is evenly distributed. It is used to compute the torque applied to the rigid-body when forces are applied to it.
+     */
+    @serializable(Vector3)
+    centerOfMass: Vector3 = new Vector3(0, 0, 0);
 
     /**
      * Constraints are used to lock the position or rotation of an object in a specific axis.

package/src/engine-components/SyncedTransform.ts

@@ -282,22 +282,14 @@ export class SyncedTransform extends Behaviour {
         this.lastWorldRotation.copy(wr);
 
 
-        // if (this._model.isOwned === false && this.autoOwnership) {
-        //     this.requestOwnership();
-        // }
-
         if (!this._model) return;
-        // only run if we are the owner
+        
         if (!this._model || this._model.hasOwnership === undefined || !this._model.hasOwnership) {
-            if (this.rb) {
-                this.rb.isKinematic = this._model.isOwned ?? false;
-                this.rb.setVelocity(0, 0, 0);
-            }
+            // if we're not the owner of this synced transform then don't send any data
             return;
         }
 
         // local user is owner:
-
         if (this.rb) {
             if (this._wasKinematic !== undefined) {
                 if (debug)
@@ -305,13 +297,8 @@ export class SyncedTransform extends Behaviour {
                 this.rb.isKinematic = this._wasKinematic;
             }
 
-            // hacky reset if too far off
-            if (this.gameObject.position.distanceTo(new Vector3(0, 0, 0)) > 1000) {
-                if (debug)
-                    console.log("RESET", this.name)
-                this.gameObject.position.set(0, 1, 0);
-                this.rb.setVelocity(0, 0, 0);
-            }
+            // TODO: if the SyncedTransform has a dynamic rigidbody we should probably synchronize the Rigidbody's properties (velocity etc)
+            // Or the Rigidbody should be synchronized separately in which case the SyncedTransform should be passive
         }
 
         const updateInterval = 10;