Needle Engine 3.10.7-beta

Files changed (9) hide show

src/engine/codegen/register_types.js +2 -2
src/engine-components/Camera.ts +5 -1
src/engine/engine_assetdatabase.ts +50 -56
src/engine/engine_patcher.ts +53 -24
src/engine/engine_serialization_builtin_serializer.ts +13 -1
src/engine/engine_texture.ts +2 -2
src/engine/extensions/extensions.ts +2 -2
src/engine-components/ParticleSystem.ts +7 -1
src/engine-components/Renderer.ts +2 -2

src/engine/codegen/register_types.js CHANGED Viewed

@@ -1,5 +1,5 @@
 import { TypeStore } from "./../engine_typestore"
 // Import types
 import { __Ignore } from "../../engine-components/codegen/components";
 import { ActionBuilder } from "../../engine-components/export/usdz/extensions/behavior/BehavioursBuilder";
@@ -217,7 +217,7 @@
 import { XRGrabRendering } from "../../engine-components/webxr/WebXRGrabRendering";
 import { XRRig } from "../../engine-components/webxr/WebXRRig";
 import { XRState } from "../../engine-components/XRFlag";
 // Register types
 TypeStore.add("__Ignore", __Ignore);
 TypeStore.add("ActionBuilder", ActionBuilder);

src/engine-components/Camera.ts CHANGED Viewed

@@ -239,7 +239,11 @@
                 const useNormalRenderer = true;// this.context.isInXR || !composer;
                 const renderer = useNormalRenderer ? this.context.renderer : composer;
                 if (renderer) {
-                    this._targetTexture.render(this.context.scene, this._cam, renderer)
+                    // TODO: we should do this in onBeforeRender for the main camera only
+                    const mainCam = this.context.mainCameraComponent;
+                    this.applyClearFlags();
+                    this._targetTexture.render(this.context.scene, this._cam, renderer);
+                    mainCam?.applyClearFlags();
                 }
             }
         }

src/engine/engine_assetdatabase.ts CHANGED Viewed

@@ -1,5 +1,5 @@
 import { InternalUsageTrackerPlugin } from "./extensions/usage_tracker";
-import { Bone, BufferAttribute, BufferGeometry, InterleavedBuffer, InterleavedBufferAttribute, Material, Mesh, Object3D, Scene, Skeleton, SkinnedMesh, Source, Texture, Uniform, WebGLRenderer } from "three";
+import { Bone, BufferAttribute, BufferGeometry, InterleavedBuffer, InterleavedBufferAttribute, Material, Mesh, NeverCompare, Object3D, Scene, Skeleton, SkinnedMesh, Source, Texture, Uniform, WebGLRenderer } from "three";
 import { addPatch } from "./engine_patcher";
 import { getParam } from "./engine_utils";
@@ -20,19 +20,22 @@
     }
 }
-const trackUsageParam = getParam("trackusage");
+const trackUsageParam = getParam("trackresources");
 function autoDispose() {
     return trackUsageParam === "dispose";
 }
-// For testing only track when explictly enabled
-let allowUsageTracking = trackUsageParam !== undefined && trackUsageParam !== false && trackUsageParam !== 0;
+let allowUsageTracking = true;// trackUsageParam === true || trackUsageParam === 1;
+if (trackUsageParam === 0) allowUsageTracking = false;
-export function setUsageTrackingEnabled(enabled: boolean) {
+/**
+ * Disable usage tracking
+ */
+export function setResourceTrackingEnabled(enabled: boolean) {
     allowUsageTracking = enabled;
 }
-export function isUsageTrackingEnabled() {
+export function isResourceTrackingEnabled() {
     return allowUsageTracking;
 }
@@ -52,7 +55,7 @@
 export function disposeObjectResources(obj: object | null | undefined) {
     if (!obj) return;
     if (obj[$disposable] === false) {
-        if(debug) console.warn("Object is marked as not disposable", obj);
+        if (debug) console.warn("Object is marked as not disposable", obj);
         return;
     }
@@ -183,7 +186,7 @@
  * @param set Set to add users to, a new one will be created if none is provided
  * @returns a set of users
  */
-export function findUsers(object: object, recursive: boolean, predicate: UserFilter | null | undefined = null, set?: Set<object>): Set<object> {
+export function findResourceUsers(object: object, recursive: boolean, predicate: UserFilter | null | undefined = null, set?: Set<object>): Set<object> {
     if (!set) {
         set = usersBuffer;
         set.clear();
@@ -198,29 +201,29 @@
             if (predicate?.call(null, user) === false) continue;
             set.add(user);
             if (recursive)
-                findUsers(user, true, predicate, set);
+                findResourceUsers(user, true, predicate, set);
         }
     }
     return set;
 }
-export function getUserCount(object: object): number | undefined {
+export function getResourceUserCount(object: object): number | undefined {
     return object[$objectUsersCountKey];
 }
-const debug = getParam("debugusers") || getParam("debugmemory");
+const debug = getParam("debugresourceusers") || getParam("debugmemory");
 // Should we check if the type has the
-const $objectUsersKey = Symbol("needle-users");
-const $objectUsersCountKey = Symbol("needle-users-count");
+const $objectUsersKey = Symbol("needle-resource-users");
+const $objectUsersCountKey = Symbol("needle-resource-users-count");
 function trackValueChange(prototype, fieldName) {
-    addPatch(prototype, fieldName, (obj, oldValue, newValue) => {
+    addPatch(prototype, fieldName, function (this: object, oldValue, newValue) {
         if (allowUsageTracking) {
-            updateUsers($objectUsersKey, obj, oldValue, false);
-            updateUsers($objectUsersKey, obj, newValue, true);
+            updateUsers($objectUsersKey, this, oldValue, false);
+            updateUsers($objectUsersKey, this, newValue, true);
         }
     });
 }
@@ -234,29 +237,26 @@
 // }
-trackValueChange(Mesh.prototype, "material");
-trackValueChange(Mesh.prototype, "geometry");
-trackValueChange(Material.prototype, "map");
-trackValueChange(Material.prototype, "bumpMap");
-trackValueChange(Material.prototype, "alphaMap");
-trackValueChange(Material.prototype, "normalMap");
-trackValueChange(Material.prototype, "displacementMap");
-trackValueChange(Material.prototype, "roughnessMap");
-trackValueChange(Material.prototype, "metalnessMap");
-trackValueChange(Material.prototype, "emissiveMap");
-trackValueChange(Material.prototype, "specularMap");
-trackValueChange(Material.prototype, "envMap");
-trackValueChange(Material.prototype, "lightMap");
-trackValueChange(Material.prototype, "aoMap");
-trackValueChange(Material.prototype, "gradientMap");
-// trackValueChange(Object3D.prototype, "parent");
+if (allowUsageTracking) {
+    trackValueChange(Mesh.prototype, "material");
+    trackValueChange(Mesh.prototype, "geometry");
+    trackValueChange(Material.prototype, "map");
+    trackValueChange(Material.prototype, "bumpMap");
+    trackValueChange(Material.prototype, "alphaMap");
+    trackValueChange(Material.prototype, "normalMap");
+    trackValueChange(Material.prototype, "displacementMap");
+    trackValueChange(Material.prototype, "roughnessMap");
+    trackValueChange(Material.prototype, "metalnessMap");
+    trackValueChange(Material.prototype, "emissiveMap");
+    trackValueChange(Material.prototype, "specularMap");
+    trackValueChange(Material.prototype, "envMap");
+    trackValueChange(Material.prototype, "lightMap");
+    trackValueChange(Material.prototype, "aoMap");
+    trackValueChange(Material.prototype, "gradientMap");
+}
-// setTimeout(()=>{
-//     stopTracking(Mesh.prototype, "material");
-// },100);
 // TODO: patch dispose?
@@ -270,18 +270,17 @@
     }
 }
-function trackDispose(prototype, methodName: string) {
-    addPatch(prototype, methodName, (instance) => {
-        onDispose(instance);
-    });
+if (allowUsageTracking) {
+    addPatch(Material.prototype, "dispose", function (this: object) { onDispose(this) });
 }
-trackDispose(Material.prototype, "dispose");
+// This variable is crucial for performance:
+// it is incremented during rendering to prevent usage updates during the three.js render loop
+// where materials and properties are updated every frame (e.g. the DepthMaterial)
+// and we don't care about those
 let noUpdateScope = 0;
 // Main method called by wrapped fields/properties to update the users for an object
@@ -331,21 +330,16 @@
 }
 // We dont want to update users during rendering
 try {
-    // addPatch(WebGLRenderer.prototype, "render",
-    //     () => {
-    //         noUpdateScope++;
-    //     },
-    //     () => {
-    //         noUpdateScope--;
-    //     }
-    // );
+    addPatch(WebGLRenderer.prototype, "render",
+        function () {
+            noUpdateScope++;
+        },
+        function () {
+            noUpdateScope--;
+        }
+    );
 }
 catch (e) {
     console.warn("Could not wrap WebGLRenderer.render", e);

src/engine/engine_patcher.ts CHANGED Viewed

@@ -1,9 +1,11 @@
 // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/hasOwn
-const _wrappedMethods = new WeakSet();
+import { getParam } from "./engine_utils";
+// const _wrappedMethods = new WeakSet();
 // export function wrap<T>(prototype: object, methodName: string, before: (t: T) => void, after: (t: T) => void) {
 //     const $key = Symbol(methodName + "-patched");
@@ -40,34 +42,43 @@
 export type Prefix = (...args) => any;
 export type Postfix = (...args) => any;
+const debugPatch = getParam("debugpatch");
 /**
  * Use patcher for patching properties insteadof calling Object.defineProperty individually
  * since this will cause conflicts if multiple patches need to be applied to the same property
  */
-export function addPatch<T extends object>(prototype: T, fieldName: string, beforeCallback?: Prefix, afterCallback?: Postfix) {
+export function addPatch<T extends object>(prototype: T, fieldName: string, beforeCallback?: Prefix | null, afterCallback?: Postfix | null) {
+    const debug = debugPatch === fieldName;
-    // TODO
-    return;
+    // If no callbacks are provided, we don't need to do anything
+    if (!beforeCallback && !afterCallback) {
+        return;
+    }
     // TODO: we probably want to turn this into a symbol to prevent anyone from overriding it
     // But when we need to store the symbol per prototype to allow e.g. material disposing to iterate those and dispose all
     const backingField = Symbol(fieldName + "__needle");// Symbol(fieldName);// + " (patched)";
-    internalAddPatch(prototype, fieldName, afterCallback, beforeCallback);
+    internalAddPatch(prototype, fieldName, beforeCallback, afterCallback);
     const desc = Object.getOwnPropertyDescriptor(prototype, fieldName);
     const existing = prototype[fieldName];
-    console.log(prototype);
+    if (debug) console.log("Patch", prototype.constructor.name, fieldName, desc, existing);
     if (desc) {
+        if (debug) console.log("Apply patch with existing descriptor", prototype.constructor.name, fieldName, desc);
+        if (typeof desc.value === "function") {
+            prototype[fieldName] = ensureFunctionWrapped(desc.value, prototype, fieldName);
+        }
     }
     else {
+        if (debug) console.log("Create patch with new property", prototype.constructor.name, fieldName, desc);
         Object.defineProperty(prototype, fieldName, {
             set: function (this: object, value: any) {
-                console.log("setting", fieldName, value);
                 if (typeof value === "function") {
-                    this[backingField] = addWrapper(value, prototype, fieldName);
+                    // TODO: not sure if this is correct (if the value that is set is a function)
+                    this[backingField] = ensureFunctionWrapped(value, prototype, fieldName);
                 }
                 else {
                     const prev = this[backingField];
@@ -77,7 +88,6 @@
                 }
             },
             get: function (this: any) {
-                console.log("GET", fieldName);
                 const value = this[backingField];
                 if (typeof value === "function") {
                     if (value[backingField]) {
@@ -90,20 +100,21 @@
     }
 }
-function addWrapper(originalFunction: Function, prototype, fieldname) {
-    return function (this: object, ...args: any[]) {
-        executePrefixes(prototype, fieldname, this, ...args);
-        const result = originalFunction.apply(this, args);
-        executePostFixes(prototype, fieldname, this, result, ...args);
-        return result;
-    }
-}
-export function removePatch(prototype: object, fieldName: string, cb: Function) {
+/** Removes prefix or postfix */
+export function removePatch(prototype: object, fieldName: string, prefixOrPostfix: Prefix | Postfix) {
     const patches = getPatches(prototype, fieldName);
     if (patches) {
         for (let i = patches.length - 1; i >= 0; i--) {
-            if (patches[i] === cb) {
+            const patch = patches[i];
+            // Remove either the prefix or postfix
+            if (patch.prefix === prefixOrPostfix) {
+                patch.prefix = null;
+            }
+            if (patch.postfix === prefixOrPostfix) {
+                patch.postfix = null;
+            }
+            // If the patch is empty, remove it from the list
+            if (!patch.prefix && !patch.postfix) {
                 patches.splice(i, 1);
             }
         }
@@ -111,11 +122,29 @@
 }
+const $wrappedFunctionSymbol = Symbol("Needle:Patches:WrappedFunction");
+function ensureFunctionWrapped(originalFunction: Function, prototype, fieldname) {
+    if (originalFunction[$wrappedFunctionSymbol]) {
+        return originalFunction;
+    }
+    const wrappedFunction = function (this: object, ...args: any[]) {
+        executePrefixes(prototype, fieldname, this, ...args);
+        const result = originalFunction.apply(this, args);
+        executePostFixes(prototype, fieldname, this, result, ...args);
+        return result;
+    }
+    wrappedFunction[$wrappedFunctionSymbol] = true;
+    return wrappedFunction;
+}
 export const NeedlePatchesKey = "Needle:Patches";
 declare type PatchInfo = {
-    prefix?: Prefix;
-    postfix?: Postfix;
+    prefix?: Prefix | null;
+    postfix?: Postfix | null;
 }
 function patches(): WeakMap<object, Map<string, PatchInfo[]>> {
     if (!globalThis[NeedlePatchesKey]) {
@@ -132,7 +161,7 @@
     return patchesMap.get(fieldName);;
 }
-function internalAddPatch(prototype, fieldName: string, postfix?: Postfix, prefix?: Prefix) {
+function internalAddPatch(prototype, fieldName: string, prefix?: Prefix | null, postfix?: Postfix | null) {
     let patchesMap = patches().get(prototype);
     if (!patchesMap) {
         patchesMap = new Map();

src/engine/engine_serialization_builtin_serializer.ts CHANGED Viewed

@@ -4,7 +4,7 @@
 import { Behaviour, Component, GameObject } from "../engine-components/Component";
 import { debugExtension } from "./engine_default_parameters";
 import { CallInfo, EventList } from "../engine-components/EventList";
-import { Color, Object3D, Texture, WebGLRenderTarget } from "three";
+import { Color, CompressedTexture, Object3D, Texture, WebGLRenderTarget } from "three";
 import { RenderTexture } from "./engine_texture";
 import { isDevEnvironment, showBalloonMessage, showBalloonWarning } from "../engine/debug/debug";
 import { resolveUrl } from "./engine_utils";
@@ -350,6 +350,18 @@
             const tex = data as Texture;
             const rt = new RenderTexture(tex.image.width, tex.image.height);
             rt.texture = tex;
+            if (tex instanceof CompressedTexture) {
+                //@ts-ignore
+                tex["isCompressedTexture"] = false;
+                //@ts-ignore
+                tex.format = THREE.RGBAFormat;
+            }
+            rt.texture.flipY = true;
+            rt.texture.offset.y = 1;
+            rt.texture.repeat.y = -1;
             return rt;
         }
         return undefined;

src/engine/engine_texture.ts CHANGED Viewed

@@ -1,6 +1,6 @@
 import { Camera, Mesh, Object3D, Texture, WebGLRenderer, WebGLRenderTarget } from "three";
 import { EffectComposer } from "postprocessing";
-import { findUsers } from "./engine_assetdatabase";
+import { findResourceUsers } from "./engine_assetdatabase";
 const _prevVisible = Symbol("previous-visibility");
@@ -34,7 +34,7 @@
     private onBeforeRender() {
         RenderTexture._userSet.clear();
-        const users = findUsers(this.texture, true, null, RenderTexture._userSet);
+        const users = findResourceUsers(this.texture, true, null, RenderTexture._userSet);
         for (const user of users) {
             if (user instanceof Mesh) {
                 user[_prevVisible] = user.visible;

src/engine/extensions/extensions.ts CHANGED Viewed

@@ -14,7 +14,7 @@
 import { NEEDLE_render_objects } from "./NEEDLE_render_objects";
 import { NEEDLE_progressive } from "./NEEDLE_progressive";
 import { InternalUsageTrackerPlugin } from "./usage_tracker";
-import { isUsageTrackingEnabled } from "../engine_assetdatabase";
+import { isResourceTrackingEnabled } from "../engine_assetdatabase";
 import { GLTFLoaderPlugin } from "three/examples/jsm/loaders/GLTFLoader.js";
 import { getParam } from "../engine_utils";
 import { isDevEnvironment } from "../debug";
@@ -79,7 +79,7 @@
     loader.register(p => new NEEDLE_render_objects(p, sourceId));
     loader.register(p => new NEEDLE_progressive(p, sourceId, context));
     loader.register(p => new EXT_texture_exr(p));
-    if (isUsageTrackingEnabled()) loader.register(p => new InternalUsageTrackerPlugin(p))
+    if (isResourceTrackingEnabled()) loader.register(p => new InternalUsageTrackerPlugin(p))
     for (const ext of _addedCustomExtension)
         loader.register(p => new ext(p));

src/engine-components/ParticleSystem.ts CHANGED Viewed

@@ -1027,7 +1027,12 @@
         if (this._subEmitterSystems && this._particleSystem) {
             for (const sys of this._subEmitterSystems) {
                 // Make sure the particle system is created
-                if (sys.particleSystem) sys.particleSystem.__internalAwake();
+                if (sys.particleSystem) {
+                    if (sys.particleSystem.__internalAwake)
+                        sys.particleSystem.__internalAwake();
+                    else if (isDevEnvironment())
+                        console.warn("SubParticleSystem serialization issue(?)", sys.particleSystem, sys);
+                }
                 const system = sys.particleSystem?._particleSystem;
                 if (system) {
                     sys.particleSystem!._isUsedAsSubsystem = true;
@@ -1037,6 +1042,7 @@
                     sub.emitterProbability = sys.emitProbability;
                     this._particleSystem.addBehavior(sub);
                 }
+                else if (debug) console.warn("Could not add SubParticleSystem", sys, this);
             }
         }
     }

src/engine-components/Renderer.ts CHANGED Viewed

@@ -365,8 +365,8 @@
                     // ignore nested groups or objects that have their own renderer (aka their own render order settings)
                     if (!this.isMeshOrSkinnedMesh(ch) || GameObject.getComponent(ch, Renderer)) continue;
                     if (this.renderOrder.length <= index) {
-                        console.error("Incorrect element count", this);
-                        break;
+                        console.warn("Incorrect renderOrder element count", this, this.renderOrder.length + " but expected " + this.gameObject.children.length, "Index: " + index, "ChildElement:", ch);
+                        continue;
                     }
                     // if(debugRenderer) console.log("Setting render order", ch, this.renderOrder[index])
                     ch.renderOrder = this.renderOrder[index];