@needle-tools/engine 2.55.1-pre → 2.55.2-pre

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@needle-tools/engine",
-    "version": "2.55.1-pre",
+    "version": "2.55.2-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/codegen/register_types.js

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

package/src/engine/engine_gizmos.ts

@@ -1,10 +1,11 @@
 import * as THREE from 'three';
-import { BufferAttribute, Line, BoxGeometry, EdgesGeometry, Color, LineSegments, LineBasicMaterial, Object3D, Mesh, SphereGeometry, ColorRepresentation, Vector3, Box3, Quaternion } from 'three';
+import { BufferAttribute, Line, BoxGeometry, EdgesGeometry, Color, LineSegments, LineBasicMaterial, Object3D, Mesh, SphereGeometry, ColorRepresentation, Vector3, Box3, Quaternion, CylinderGeometry } from 'three';
 import { Context } from './engine_setup';
 import { setWorldPosition, setWorldPositionXYZ } from './engine_three_utils';
 import { Vec3, Vec4 } from './engine_types';
 
 const _tmp = new Vector3();
+const _tmp2 = new Vector3();
 const _quat = new Quaternion();
 
 const defaultColor: ColorRepresentation = 0x888888;
@@ -76,7 +77,7 @@ export class Gizmos {
         obj.material["wireframe"] = true;
     }
 
-    static DrawBox3(box:Box3, color: ColorRepresentation = defaultColor, duration: number = 0, depthTest: boolean = true) {
+    static DrawBox3(box: Box3, color: ColorRepresentation = defaultColor, duration: number = 0, depthTest: boolean = true) {
         const obj = Internal.getBox(duration);
         obj.position.copy(box.getCenter(_tmp));
         obj.scale.copy(box.getSize(_tmp));
@@ -84,6 +85,20 @@ export class Gizmos {
         obj.material["depthTest"] = depthTest;
         obj.material["wireframe"] = true;
     }
+
+    private static _up = new Vector3(0, 1, 0);
+    static DrawArrow(pt0: Vec3, pt1: Vec3, color: ColorRepresentation = defaultColor, duration: number = 0, depthTest: boolean = true, wireframe: boolean = false) {
+        const obj = Internal.getArrowHead(duration);
+        obj.position.set(pt1.x, pt1.y, pt1.z);
+        obj.quaternion.setFromUnitVectors(this._up.set(0, 1, 0), _tmp.set(pt1.x, pt1.y, pt1.z).sub(_tmp2.set(pt0.x, pt0.y, pt0.z)).normalize());
+        const dist = _tmp.set(pt1.x, pt1.y, pt1.z).sub(_tmp2.set(pt0.x, pt0.y, pt0.z)).length();
+        const scale = dist * 0.1;
+        obj.scale.set(scale, scale, scale);
+        obj.material["color"].set(color);
+        obj.material["depthTest"] = depthTest;
+        obj.material["wireframe"] = wireframe;
+        this.DrawLine(pt0, pt1, color, duration, depthTest);
+    }
 }
 
 const box: BoxGeometry = new BoxGeometry(1, 1, 1);
@@ -141,9 +156,19 @@ class Internal {
         return sphere;
     }
 
+    static getArrowHead(duration: number): Mesh {
+        let arrowHead = this.arrowHeadsCache.pop();
+        if (!arrowHead) {
+            arrowHead = new Mesh(new CylinderGeometry(0, .5, 1, 8));
+        }
+        this.registerTimedObject(Context.Current, arrowHead, duration, this.arrowHeadsCache);
+        return arrowHead;
+    }
+
     private static linesCache: Array<Line> = [];
     private static spheresCache: Mesh[] = [];
     private static boxesCache: Mesh[] = [];
+    private static arrowHeadsCache: Mesh[] = [];
 
     private static registerTimedObject(context: Context, object: Object3D, duration: number, cache: Array<Object3D>) {
         if (!this.contextPostRenderCallbacks.get(context)) {

package/src/engine/engine_physics.ts

@@ -386,10 +386,11 @@ export class Physics {
                 this._meshCache.set(key, scaledPositions);
             }
         }
-
         const desc = convex ? ColliderDesc.convexMesh(positions) : ColliderDesc.trimesh(positions, indices);
         if (desc) {
-            this.createCollider(collider, desc);
+            const col = this.createCollider(collider, desc);
+            col.setMassProperties(1, { x: 0, y: 0, z: 0 }, { x: 0, y: 0, z: 0 }, { x: 0, y: 0, z: 0, w: 1 });
+            // rb?.setTranslation({ x: 0, y: 2, z: 0 });
             // col.setTranslationWrtParent(new Vector3(0,2,0));
 
         }
@@ -593,7 +594,7 @@ export class Physics {
         rigidbody.enableCcd(rb.collisionDetectionMode !== CollisionDetectionMode.Discrete);
         rigidbody.setLinearDamping(rb.drag);
         rigidbody.setAngularDamping(rb.angularDrag);
-        rigidbody.setGravityScale(rb.useGravity ? 1 : 0, true);
+        rigidbody.setGravityScale(rb.useGravity ? rb.gravityScale : 0, true);
 
         // https://rapier.rs/docs/user_guides/javascript/rigid_bodies#mass-properties
         // rigidbody.setAdditionalMass(rb.mass, true);
@@ -807,7 +808,7 @@ export class Physics {
     }
 
 
-
+    /** The joint prevents any relative movement between two rigid-bodies, except for relative rotations along one axis. This is typically used to simulate wheels, fans, etc. They are characterized by one local anchor as well as one local axis on each rigid-body. */
     addHingeJoint(body1: IRigidbody, body2: IRigidbody, anchor: { x: number, y: number, z: number }, axis: { x: number, y: number, z: number }) {
         if (!this.world) {
             console.error("Physics world not initialized");

package/src/engine/engine_setup.ts

@@ -26,6 +26,7 @@ import { PlayerViewManager } from './engine_playerview';
 
 import { ICamera, IComponent, ILight } from "./engine_types"
 import { destroy, foreachComponent } from './engine_gameobject';
+import { createCameraWithOrbitControl } from '../engine-components/CameraUtils';
 
 
 const debug = utils.getParam("debugSetup");
@@ -147,12 +148,12 @@ export class Context {
 
 	get domWidth(): number {
 		// for mozilla XR
-		if(this.isInAR) return window.innerWidth;
+		if (this.isInAR) return window.innerWidth;
 		return this.domElement.clientWidth;
 	}
 	get domHeight(): number {
 		// for mozilla XR
-		if(this.isInAR) return window.innerHeight;
+		if (this.isInAR) return window.innerHeight;
 		return this.domElement.clientHeight;
 	}
 	get domX(): number {
@@ -543,6 +544,8 @@ export class Context {
 			foreachComponent(this.scene, comp => {
 				const cam = comp as ICamera;
 				if (cam?.isCamera) {
+					looputils.updateActiveInHierarchyWithoutEventCall(cam.gameObject);
+					if (!cam.activeAndEnabled) return undefined;
 					if (cam.tag === "MainCamera") {
 						camera = cam;
 						return true;
@@ -554,8 +557,10 @@ export class Context {
 			if (camera) {
 				this.setCurrentCamera(camera);
 			}
-			else
+			else {
 				console.error("MISSING camera", this);
+				createCameraWithOrbitControl(this.scene, "unknown");
+			}
 		}
 
 		Context._current = this;
@@ -738,7 +743,7 @@ export class Context {
 	private onHandlePaused(): boolean {
 		const paused = this.evaluatePaused();
 		if (this._wasPaused !== paused) {
-			if(debugActive) console.log("Paused?", paused, "context:" + this.alias);
+			if (debugActive) console.log("Paused?", paused, "context:" + this.alias);
 			for (let i = 0; i < this.scripts_pausedChanged.length; i++) {
 				const script = this.scripts_pausedChanged[i];
 				if (!script.activeAndEnabled) continue;

package/src/engine/engine_time.ts

@@ -1,9 +1,9 @@
 import { Clock } from 'three'
 import { getParam } from './engine_utils';
 
-const debug = getParam("debugtime");
+const timescaleUrl = getParam("timescale");
 let timeScale = 1;
-if(typeof debug === "number") timeScale = debug;
+if(typeof timescaleUrl === "number") timeScale = timescaleUrl;
 
 export class Time {
 

package/src/engine/engine_types.ts

@@ -150,6 +150,7 @@ export declare interface IRigidbody extends IComponent {
     drag: number;
     angularDrag: number;
     useGravity: boolean;
+    gravityScale : number;
     collisionDetectionMode: CollisionDetectionMode;
 
     lockPositionX: boolean;

package/src/engine-components/Camera.ts

@@ -230,10 +230,12 @@ export class Camera extends Behaviour implements ICamera {
         else if (!this.orthographic) {
             cam = new PerspectiveCamera(this.fieldOfView, window.innerWidth / window.innerHeight, this._nearClipPlane, this._farClipPlane);
             cam.fov = this.fieldOfView;
+            this.gameObject.add(cam);
         }
         else {
             const factor = this.orthographicSize * 100;
             cam = new OrthographicCamera(window.innerWidth / -factor, window.innerWidth / factor, window.innerHeight / factor, window.innerHeight / -factor, this._nearClipPlane, this._farClipPlane);
+            this.gameObject.add(cam);
         }
         this._cam = cam;
 

package/src/engine-components/CameraUtils.ts

@@ -1,15 +1,25 @@
 import { OrbitControls } from "./OrbitControls";
 import { Camera } from "./Camera";
 import { addNewComponent } from "../engine/engine_components";
-import { Object3D, Scene } from "three";
+import { Color, Object3D, Scene, Vector3 } from "three";
+import { ICamera, SourceIdentifier } from "../engine/engine_types";
+import { lookAtInverse } from "../engine/engine_three_utils";
+import { RGBAColor } from "./js-extensions/RGBAColor";
 
-export function createCameraWithOrbitControl(scene: Scene): Camera {
-    const srcId = "created/implictly";
+export function createCameraWithOrbitControl(scene: Scene, source: SourceIdentifier): ICamera {
+    const srcId = source;
     const go = new Object3D();
     scene.add(go);
-    const cam = addNewComponent(go, new Camera(), false);
+    const camInstance = new Camera();
+    const cam = addNewComponent(go, camInstance, true) as ICamera
     cam.sourceId = srcId;
-    const orbit = addNewComponent(go, new OrbitControls(), false);
+    cam.clearFlags = 2;
+    cam.backgroundColor = new RGBAColor(0.5, 0.5, 0.5, 1);
+    const orbit = addNewComponent(go, new OrbitControls(), false) as OrbitControls;
     orbit.sourceId = srcId;
+    go.position.x = -2;
+    go.position.y = 2;
+    go.position.z = 2;
+    lookAtInverse(go, new Vector3(0, 0, 0));
     return cam as Camera;
 }

package/src/engine-components/RigidBody.ts

@@ -38,11 +38,11 @@ class TransformWatch {
         }
     }
 
-    syncValues(){
-        for(const key of this._positionKeys){
+    syncValues() {
+        for (const key of this._positionKeys) {
             this.position![key] = this.obj.position[key];
         }
-        for(const key of this._quaternionKeys){
+        for (const key of this._quaternionKeys) {
             this.quaternion![key] = this.obj.quaternion[key];
         }
     }
@@ -213,6 +213,14 @@ export class Rigidbody extends Behaviour implements IRigidbody {
         else this.constraints &= ~RigidbodyConstraints.FreezeRotationZ;
     }
 
+    set gravityScale(val: number) {
+        this._gravityScale = val;
+    }
+    get gravityScale() {
+        return this._gravityScale;
+    }
+    private _gravityScale: number = 1;
+
     private static tempPosition: THREE.Vector3 = new THREE.Vector3();
     private _propertiesChanged: boolean = false;
     private _currentVelocity: THREE.Vector3 = new THREE.Vector3();
@@ -271,9 +279,9 @@ export class Rigidbody extends Behaviour implements IRigidbody {
         return this.context.physics.internal_getRigidbody(this);
     }
 
-    public teleport(pt: { x: number, y: number, z: number }, localspace:boolean = true) {
+    public teleport(pt: { x: number, y: number, z: number }, localspace: boolean = true) {
         this._watch?.reset(true);
-        if(localspace) this.gameObject.position.set(pt.x, pt.y, pt.z);
+        if (localspace) this.gameObject.position.set(pt.x, pt.y, pt.z);
         else this.setWorldPosition(pt.x, pt.y, pt.z);
         this.resetForcesAndTorques();
         this.resetVelocities();
@@ -343,6 +351,15 @@ export class Rigidbody extends Behaviour implements IRigidbody {
         this.body?.setAngvel({ x: x, y: y, z: z }, true);
     }
 
+    public getAngularVelocity(): Vector3 {
+        const vel = this.body?.angvel();
+        if (!vel) return this._currentVelocity.set(0, 0, 0);
+        this._currentVelocity.x = vel.x;
+        this._currentVelocity.y = vel.y;
+        this._currentVelocity.z = vel.z;
+        return this._currentVelocity;
+    }
+
     public setTorque(x: number | Vector3, y: number, z: number) {
         this.setAngularVelocity(x, y, z);
     }