Needle Engine 3.37.4-alpha

Files changed (9) hide show

src/engine-components/Collider.ts +27 -4
src/engine/engine_physics_rapier.ts +48 -14
src/engine/engine_physics.ts +4 -4
src/engine/engine_types.ts +29 -6
src/engine/extensions/NEEDLE_lighting_settings.ts +0 -5
src/engine/webcomponents/needle menu/needle-menu.ts +14 -1
src/engine/codegen/register_types.ts +2 -2
src/engine-components/RigidBody.ts +5 -2
src/engine-components/SyncedTransform.ts +4 -17

src/engine-components/Collider.ts CHANGED Viewed

@@ -15,45 +15,65 @@
  * 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 @@
         return this.context.physics.engine?.getBody(this);
     }
+    /**
+     * Apply the collider properties to the physics engine.
+     */
     updateProperties = () => {
         this.context.physics.engine?.updateProperties(this);
     }

src/engine/engine_physics_rapier.ts CHANGED Viewed

@@ -1,4 +1,4 @@
-import { ActiveCollisionTypes, ActiveEvents, Ball, CoefficientCombineRule, Collider, ColliderDesc, Cuboid, EventQueue, JointData, QueryFilterFlags, Ray, RigidBody, RigidBodyType, ShapeColliderTOI, ShapeType, World } from '@dimforge/rapier3d-compat';
+import { ActiveCollisionTypes, ActiveEvents, Ball, CoefficientCombineRule, Collider, ColliderDesc, Cuboid, EventQueue, JointData, QueryFilterFlags, Ray, RigidBody, RigidBodyDesc, RigidBodyType, ShapeColliderTOI, ShapeType, World } from '@dimforge/rapier3d-compat';
 import { BufferAttribute, BufferGeometry, LineBasicMaterial, LineSegments, Matrix4, Mesh, Object3D, Quaternion, Vector3 } from 'three'
 import * as BufferGeometryUtils from 'three/examples/jsm/utils/BufferGeometryUtils.js'
@@ -295,9 +295,20 @@
     private rapierRay = new Ray({ x: 0, y: 0, z: 0 }, { x: 0, y: 0, z: 1 });
     private raycastVectorsBuffer = new CircularBuffer(() => new Vector3(), 10);
-    public raycast(origin?: Vec2 | Vec3, direction?: Vec3, maxDistance?: number, solid?: boolean)
+    public 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,
+        filterGroups?: number,
+        /** Return false to ignore this collider */
+        filterPredicate?: (c: ICollider) => boolean,
+    })
         : null | { point: Vector3, collider: ICollider } {
+        let maxDistance = options?.maxDistance;
+        let solid = options?.solid;
         if (maxDistance === undefined) maxDistance = Infinity;
         if (solid === undefined) solid = true;
@@ -306,9 +317,12 @@
         if (this.debugRenderRaycasts || showPhysicsRaycasts) Gizmos.DrawRay(ray.origin, ray.dir, 0x0000ff, 1);
-        const hit = this.world?.castRay(ray, maxDistance, solid, undefined, undefined, undefined, undefined, (c) => {
+        const hit = this.world?.castRay(ray, maxDistance, solid, options?.queryFilterFlags, options?.filterGroups, undefined, undefined, (c) => {
+            const component = c[$componentKey];
+            if (options?.filterPredicate) return options.filterPredicate(component);
             // ignore objects in the IgnoreRaycast=2 layer
-            return !c[$componentKey]?.gameObject.layers.isEnabled(2);
+            return !component?.gameObject.layers.isEnabled(2);
         });
         if (hit) {
             const point = ray.pointAt(hit.toi);
@@ -320,9 +334,20 @@
         return null;
     }
-    public raycastAndGetNormal(origin?: Vec2 | Vec3, direction?: Vec3, maxDistance?: number, solid?: boolean)
+    public 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,
+        filterGroups?: number,
+        /** Return false to ignore this collider */
+        filterPredicate?: (c: ICollider) => boolean,
+    })
         : null | { point: Vector3, normal: Vector3, collider: ICollider } {
+        let maxDistance = options?.maxDistance;
+        let solid = options?.solid;
         if (maxDistance === undefined) maxDistance = Infinity;
         if (solid === undefined) solid = true;
@@ -331,9 +356,11 @@
         if (this.debugRenderRaycasts || showPhysicsRaycasts) Gizmos.DrawRay(ray.origin, ray.dir, 0x0000ff, 1);
-        const hit = this.world?.castRayAndGetNormal(ray, maxDistance, solid, undefined, undefined, undefined, undefined, (c) => {
+        const hit = this.world?.castRayAndGetNormal(ray, maxDistance, solid, options?.queryFilterFlags, options?.filterGroups, undefined, undefined, (c) => {
+            const component = c[$componentKey];
+            if (options?.filterPredicate) return options.filterPredicate(component);
             // ignore objects in the IgnoreRaycast=2 layer
-            return !c[$componentKey]?.gameObject.layers.isEnabled(2);
+            return !component?.gameObject.layers.isEnabled(2);
         });
         if (hit) {
             const point = ray.pointAt(hit.toi);
@@ -802,30 +829,36 @@
         }
     }
-    /** Updates the collision groups */
+    /**
+     * Updates the collision groups of a collider.
+     *
+     * @param collider - The collider to update.
+     */
     private updateColliderCollisionGroups(collider: ICollider) {
-        const body = collider[$bodyKey];
+        const body = collider[$bodyKey] as Collider;
         const members = collider.membership;
         let memberMask = 0;
         if (members == undefined) {
-            memberMask = 0xffffffff;
+            memberMask = 0xffff;
         }
         else {
             for (let i = 0; i < members.length; i++) {
                 const member = members[i];
-                memberMask |= 1 << member;
+                if (member > 31) console.error(`Rapier only supports 32 layers, layer ${member} is not supported`);
+                else memberMask |= 1 << Math.floor(member);
             }
         }
         const mask = collider.filter;
         let filterMask = 0;
         if (mask == undefined) {
-            filterMask = 0xffffffff;
+            filterMask = 0xffff;
         }
         else {
             for (let i = 0; i < mask.length; i++) {
                 const member = mask[i];
-                filterMask |= 1 << member;
+                if (member > 31) console.error(`Rapier only supports 32 layers, layer ${member} is not supported`);
+                else filterMask |= 1 << Math.floor(member);
             }
         }
         body.setCollisionGroups((memberMask << 16) | filterMask);
@@ -843,10 +876,11 @@
                 const kinematic = rb.isKinematic && !debugColliderPlacement;
                 if (debugPhysics)
                     console.log("Create rigidbody", kinematic);
-                const rigidBodyDesc = kinematic ? RAPIER.RigidBodyDesc.kinematicPositionBased() : RAPIER.RigidBodyDesc.dynamic();
+                const rigidBodyDesc = (kinematic ? RAPIER.RigidBodyDesc.kinematicPositionBased() : RAPIER.RigidBodyDesc.dynamic()) as RigidBodyDesc;
                 const pos = getWorldPosition(collider.attachedRigidbody.gameObject);
                 rigidBodyDesc.setTranslation(pos.x, pos.y, pos.z);
                 rigidBodyDesc.setRotation(getWorldQuaternion(collider.attachedRigidbody.gameObject));
+                rigidBodyDesc.centerOfMass = new RAPIER.Vector3(rb.centerOfMass.x, rb.centerOfMass.y, rb.centerOfMass.z);
                 rigidBody = this.world.createRigidBody(rigidBodyDesc);
                 this.bodies.push(rigidBody);
                 this.objects.push(rb);

src/engine/engine_physics.ts CHANGED Viewed

@@ -125,14 +125,14 @@
 export class Physics {
-    /**@deprecated use this.context.physics.engine.raycast */
+    /**@deprecated use `this.context.physics.engine.raycast` {@link IPhysicsEngine.raycast} */
     public raycastPhysicsFast(origin: Vec2 | Vec3, direction: Vec3 | undefined = undefined, maxDistance: number = Infinity, solid: boolean = true) {
-        return this.context.physics.engine?.raycast(origin, direction, maxDistance, solid) ?? null;
+        return this.context.physics.engine?.raycast(origin, direction, { maxDistance, solid }) ?? null;
     }
-    /**@deprecated use this.context.physics.engine.raycastAndGetNormal */
+    /**@deprecated use `this.context.physics.engine.raycastAndGetNormal` {@link IPhysicsEngine.raycastAndGetNormal} */
     public raycastPhysicsFastAndGetNormal(origin: Vec2 | Vec3, direction: Vec3 | undefined = undefined, maxDistance: number = Infinity, solid: boolean = true) {
-        return this.context.physics.engine?.raycastAndGetNormal(origin, direction, maxDistance, solid) ?? null;
+        return this.context.physics.engine?.raycastAndGetNormal(origin, direction, { maxDistance, solid }) ?? null;
     }
     /**@deprecated use this.context.physics.engine.sphereOverlap */

src/engine/engine_types.ts CHANGED Viewed

@@ -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 @@
     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 @@
     drag: number;
     angularDrag: number;
     useGravity: boolean;
+    centerOfMass: Vec3;
     gravityScale: number;
     dominanceGroup: number;
@@ -436,12 +440,31 @@
     /** 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

src/engine/extensions/NEEDLE_lighting_settings.ts CHANGED Viewed

@@ -94,8 +94,6 @@
     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 @@
             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 @@
     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)

src/engine/webcomponents/needle menu/needle-menu.ts CHANGED Viewed

@@ -371,7 +371,20 @@
             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 */
         /*

src/engine/codegen/register_types.ts CHANGED Viewed

@@ -1,6 +1,6 @@
 /* eslint-disable */
 import { TypeStore } from "./../engine_typestore.js"
 // Import types
 import { __Ignore } from "../../engine-components/codegen/components.js";
 import { ActionBuilder } from "../../engine-components/export/usdz/extensions/behavior/BehavioursBuilder.js";
@@ -220,7 +220,7 @@
 import { XRFlag } from "../../engine-components/webxr/XRFlag.js";
 import { XRRig } from "../../engine-components/webxr/WebXRRig.js";
 import { XRState } from "../../engine-components/webxr/XRFlag.js";
 // Register types
 TypeStore.add("__Ignore", __Ignore);
 TypeStore.add("ActionBuilder", ActionBuilder);

src/engine-components/RigidBody.ts CHANGED Viewed

@@ -167,8 +167,11 @@
     @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.

src/engine-components/SyncedTransform.ts CHANGED Viewed

@@ -282,22 +282,14 @@
         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 @@
                 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;