@needle-tools/engine 2.67.6-pre → 2.67.7-pre

package/src/engine/engine_time.ts

@@ -20,11 +20,13 @@ export class Time {
 
     get frameCount() { return this.frame; }
     get smoothedFps() { return this._smoothedFps; }
+    get smoothedDeltaTime() { return 1 / this._smoothedFps; }
 
 
     private clock = new Clock();
 
     private _smoothedFps: number = 0;
+    private _smoothedDeltaTime: number = 0;
     private _fpsSamples: number[] = [];
     private _fpsSampleIndex: number = 0;
 
@@ -47,6 +49,7 @@ export class Time {
         let sum = 0;
         for (let i = 0; i < this._fpsSamples.length; i++)
             sum += this._fpsSamples[i];
-        this._smoothedFps = 1 / (sum / this._fpsSamples.length);
+        this._smoothedDeltaTime = sum / this._fpsSamples.length;
+        this._smoothedFps = 1 / this._smoothedDeltaTime;
     }
 }

package/src/engine-components/AnimatorController.ts

@@ -432,9 +432,9 @@ export class AnimatorController {
             case AnimatorConditionMode.IfNot:
                 return param.value === false;
             case AnimatorConditionMode.Greater:
-                return param.value > cond.threshold;
+                return param.value as number > cond.threshold;
             case AnimatorConditionMode.Less:
-                return param.value < cond.threshold;
+                return param.value as number < cond.threshold;
             case AnimatorConditionMode.Equals:
                 return param.value === cond.threshold;
             case AnimatorConditionMode.NotEqual:

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

@@ -8,11 +8,13 @@ import { getComponentsInChildren } from "../../engine/engine_components";
 import { IComponent } from "../../engine/engine_types";
 import { GameObject } from "../Component";
 import { showBalloonMessage, showBalloonWarning } from "../../engine/debug";
+import { Object3D } from "three";
 
 export enum RenderMode {
     ScreenSpaceOverlay = 0,
     ScreenSpaceCamera = 1,
     WorldSpace = 2,
+    Undefined = -1,
 }
 
 export class Canvas extends UIRootComponent {
@@ -74,7 +76,7 @@ export class Canvas extends UIRootComponent {
         this._renderMode = val;
         this.onRenderSettingsChanged();
     }
-    private _renderMode: RenderMode = -1;
+    private _renderMode: RenderMode = RenderMode.Undefined;
 
     private _rootCanvas!: Canvas;
 
@@ -109,12 +111,28 @@ export class Canvas extends UIRootComponent {
     }
 
     private previousAspect: number = -1;
+    private previousParent: Object3D | null = null;
 
     onBeforeRender() {
         if (this.isScreenSpace && this.context.mainCameraComponent && this.context.mainCameraComponent.aspect !== this.previousAspect) {
             this.previousAspect = this.context.mainCameraComponent.aspect;
             this.updateRenderMode();
         }
+        else if(this.renderOnTop){
+            // This is just a test but in reality it should be combined with all world canvases with render on top in one render pass
+            this.previousParent = this.gameObject.parent;
+            this.gameObject.removeFromParent();
+        }
+    }
+
+    onAfterRender(): void {
+        if (this.renderOnTop && this.previousParent && this.context.mainCamera) {
+            this.previousParent.add(this.gameObject);
+            this.context.renderer.autoClear = false;
+            this.context.renderer.clearDepth();
+            this.context.renderer.render(this.gameObject, this.context.mainCamera);
+            this.context.renderer.autoClear = true;
+        }
     }
 
     applyRenderSettings(){

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

@@ -382,8 +382,7 @@ export class EventSystem extends Behaviour {
                 const actualGo = parent[$shadowDomOwner].gameObject;
                 if (actualGo) {
                     const res = UIRaycastUtils.isInteractable(actualGo, this.out);
-                    // console.log(actualGo, res);
-                    if (!res) return this.out.canvasGroup?.interactable ?? false;
+                    if (!res) return false;
                     canvasGroup = this.out.canvasGroup ?? null;
 
                     const handled = this.handleMeshUIIntersection(object, pressedOrClicked);

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

@@ -214,6 +214,9 @@ export class Text extends Graphic {
 
         this.getAlignment(opts, isTextIntermediate);
         const block = rt.createNewBlock(opts);
+        // The text block should never write depth to avoid z-fighting
+        const mat = block["backgroundMaterial"];
+        if(mat) mat.depthWrite = false;
         if (content) {
             if (Array.isArray(content)) {
                 block.add(...content);

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

@@ -34,11 +34,13 @@ export function updateRenderSettings(shadowComponent: THREE.Object3D, settings:
     //     console.log(shadowComponent)
     const mat = shadowComponent["material"];
     if (mat?.isMaterial === true) {
-        // console.log(shadowComponent, shadowComponent.name);
-        // console.log(mat, component.renderOnTop, component.doubleSided, component.depthWrite);
-        mat.depthTest = !settings.renderOnTop ?? true;
+        const parent = shadowComponent.parent;
+        if (parent && parent["isText"] === true) {
+            // console.log(shadowComponent, shadowComponent.name);
+        }
+        // mat.depthTest = !settings.renderOnTop ?? true;
+        // mat.depthWrite = settings.depthWrite ?? false;
         mat.side = (settings.doubleSided ?? true) ? DoubleSide : FrontSide;
-        mat.depthWrite = settings.depthWrite ?? false;
         mat.shadowSide = settings.doubleSided ? DoubleSide : FrontSide;
         shadowComponent.castShadow = settings.castShadows ? settings.castShadows : false;
         shadowComponent.receiveShadow = settings.receiveShadows ? settings.receiveShadows : false;