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

package/src/engine/engine_element_loading.ts

@@ -4,6 +4,7 @@ import { LoadingProgressArgs } from "./engine_setup";
 import { getParam } from "./engine_utils";
 
 const debug = getParam("debugloadingbar");
+const debugRendering = getParam("debugloadingbarrendering");
 
 export class LoadingElementOptions {
     className?: string;
@@ -43,12 +44,14 @@ export function calculateProgress01(progress: LoadingProgressArgs) {
 
 export class EngineLoadingView implements ILoadingViewHandler {
 
+    static LoadingContainerClassName = "loading";
+
     // the raw progress
     loadingProgress: number = 0;
 
     private container: HTMLElement;
     private _progress: number = 0;
-    private _allowCustomLoadingElement: boolean = false;
+    private _allowCustomLoadingElement: boolean = true;
     private _loadingElement?: HTMLElement;
     private _loadingTextContainer: HTMLElement | null = null;
     private _loadingBar: HTMLElement | null = null;
@@ -61,20 +64,21 @@ export class EngineLoadingView implements ILoadingViewHandler {
     }
 
     onLoadingBegin(message?: string) {
+        if(debug) console.log("Begin Loading")
         if (!this._loadingElement) {
             for (let i = 0; i < this.container.children.length; i++) {
                 const el = this.container.children[i] as HTMLElement;
-                if (el.classList.contains("loading")) {
+                if (el.classList.contains(EngineLoadingView.LoadingContainerClassName)) {
                     if (!this._allowCustomLoadingElement) {
-                        console.warn("Custom loading container is not allowed")
+                        if(debug) console.warn("Remove custom loading container")
                         this.container.removeChild(el);
                         continue;
                     }
                     this._loadingElement = this.createLoadingElement(el);
-                    return;
                 }
             }
-            this._loadingElement = this.createLoadingElement();
+            if (!this._loadingElement)
+                this._loadingElement = this.createLoadingElement();
         }
         this._progress = 0;
         this.loadingProgress = 0;
@@ -121,9 +125,11 @@ export class EngineLoadingView implements ILoadingViewHandler {
         if (this._progressLoop) return;
         let dt = 1 / 12;
         const max = 1 - .05;
+        if(debugRendering) dt = 1 / 500;
         this._progressLoop = setInterval(() => {
             if (this.loadingProgress >= 1 && this._progress >= max) {
                 if (this._loadingElement) {
+                    if(debug) console.log("Hiding loading element");
                     this._loadingElement.style.display = "none";
                     this._loadingElement.remove();
                 }
@@ -148,6 +154,7 @@ export class EngineLoadingView implements ILoadingViewHandler {
     }
 
     private createLoadingElement(existing?: HTMLElement): HTMLElement {
+    if(debug && !existing) console.log("Creating loading element");
         this._loadingElement = existing || document.createElement("div");
         if (!existing) {
             this._loadingElement.style.position = "fixed";
@@ -165,7 +172,7 @@ export class EngineLoadingView implements ILoadingViewHandler {
             this._loadingElement.style.color = "white";
         }
 
-        const className = this._loadingElementOptions?.className ?? "loading";
+        const className = this._loadingElementOptions?.className ?? EngineLoadingView.LoadingContainerClassName;
         this._loadingElement.classList.add(className);
         if (this._loadingElementOptions?.additionalClasses) {
             for (const c of this._loadingElementOptions.additionalClasses) {

package/src/engine/engine_element_overlay.ts

@@ -1,6 +1,7 @@
 import { Context } from "./engine_setup";
-import { isMozillaXR } from "./engine_utils";
+import { getParam, isMozillaXR } from "./engine_utils";
 
+const debug = getParam("debugaroverlay");
 export const arContainerClassName = "ar";
 export const quitARClassName = "quit-ar";
 
@@ -110,7 +111,8 @@ export class AROverlayHandler {
         if (arElements && arElements.length > 0)
             return arElements[0] as HTMLElement;
 
-        console.log("No overlay container found in document - generating new ony");
+        if (debug)
+            console.log("No overlay container found in document - generating new ony");
         const el = document.createElement("div");
         el.classList.add(arContainerClassName);
         el.style.position = "absolute";

package/src/engine/engine_input.ts

@@ -384,6 +384,8 @@ export class Input extends EventTarget {
         for (let i = 0; i < evt.changedTouches.length; i++) {
             const touch = evt.changedTouches[i];
             const id = this.getPointerIndex(touch.identifier)
+            if (debug)
+                showBalloonMessage(`touch start #${id}, identifier:${touch.identifier}`);
             const args: PointerEventArgs = { button: id, clientX: touch.clientX, clientY: touch.clientY, pointerType: PointerType.Touch, source: evt };
             this.onDown(args);
         }
@@ -404,6 +406,8 @@ export class Input extends EventTarget {
         for (let i = 0; i < evt.changedTouches.length; i++) {
             const touch = evt.changedTouches[i];
             const id = this.getPointerIndex(touch.identifier)
+            if (debug)
+                showBalloonMessage(`touch up #${id}, identifier:${touch.identifier}`);
             const args: PointerEventArgs = { button: id, clientX: touch.clientX, clientY: touch.clientY, pointerType: PointerType.Touch, source: evt };
             this.onUp(args);
         }

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_networking_websocket.ts

@@ -1 +1,3 @@
-// TODO: move websocket specific networking code here!
+// TODO: move websocket specific networking code here!
+
+export {}

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_serialization_builtin_serializer.ts

@@ -6,6 +6,7 @@ import { debugExtension } from "./engine_default_parameters";
 import { CallInfo, EventList } from "../engine-components/EventList";
 import { Color, Object3D, Texture, WebGLRenderTarget } from "three";
 import { RenderTexture } from "./engine_texture";
+import { isDevEnvironment } from "../engine/debug/debug";
 
 // export class SourcePath {
 //     src?:string
@@ -98,7 +99,8 @@ class ObjectSerializer extends TypeSerializer {
                     res = GameObject.findByGuid(data.guid, context.context.scene);
                 }
                 if (!res) {
-                    console.warn("Could not resolve object reference", context.path, data, context.target, context.context.scene);
+                    if (isDevEnvironment() || debugExtension)
+                        console.warn("Could not resolve object reference", context.path, data, context.target, context.context.scene);
                     data["could_not_resolve"] = true;
                 }
                 else if (debugExtension)
@@ -141,9 +143,10 @@ class ComponentSerializer extends TypeSerializer {
                 // if not found within the gltf use the provided context scene
                 // to find references outside
                 res = this.findObjectForGuid(data.guid, context.context?.scene);
-                if(res) return res;
+                if (res) return res;
             }
-            console.warn("Could not resolve component reference", context.path, data, context.target);
+            if (isDevEnvironment() || debugExtension)
+                console.warn("Could not resolve component reference", context.path, data, context.target);
             data["could_not_resolve"] = true;
             return undefined;
         }
@@ -227,7 +230,7 @@ class EventListSerializer extends TypeSerializer {
                                 call.method = call.method.substring(4);
                                 if (target[call.method] !== undefined) foundMethod = true;
                             }
-                            if (!foundMethod)
+                            if (!foundMethod && (isDevEnvironment() || debugExtension))
                                 printWarningMethodNotFound();
                         }
                     }
@@ -302,7 +305,7 @@ export class RenderTextureSerializer extends TypeSerializer {
     }
 
     onDeserialize(data: any, context: SerializationContext) {
-        if(data instanceof Texture && context.type === RenderTexture){
+        if (data instanceof Texture && context.type === RenderTexture) {
             const tex = data as Texture;
             const rt = new RenderTexture(tex.image.width, tex.image.height);
             rt.texture = tex;

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

@@ -52,7 +52,7 @@ export function getUrlParams() {
     return new URLSearchParams(window.location.search);
 }
 
-export function getParam(paramName: string): string | boolean {
+export function getParam(paramName: string): string | boolean | number {
 
     if (saveParams && !requestedParams.includes(paramName))
         requestedParams.push(paramName);
@@ -60,6 +60,8 @@ export function getParam(paramName: string): string | boolean {
     if (urlParams.has(paramName)) {
         const val = urlParams.get(paramName);
         if (val) {
+            const num = Number(val);
+            if (!isNaN(num)) return num; 
             return val;
         }
         else return true;
@@ -383,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");
 }