@needle-tools/engine 2.66.1-pre → 2.67.0-pre

package/src/engine/engine_gameobject.ts

@@ -1,4 +1,4 @@
-import { Object3D } from "three";
+import { BufferGeometry, InstancedBufferGeometry, Material, Mesh, Object3D, Texture } from "three";
 import { processNewScripts } from "./engine_mainloop_utils";
 import { InstantiateIdProvider } from "./engine_networking_instantiate";
 import { Context, registerComponent } from "./engine_setup";
@@ -9,6 +9,9 @@ import { apply } from "../engine-components/js-extensions/Object3D";
 import { $isUsingInstancing, InstancingUtil } from "./engine_instancing";
 import { activeInHierarchyFieldName } from "./engine_constants";
 import { assign } from "./engine_serialization_core";
+import { disposeObjectResources, __internalNotifyObjectDestroyed as __internalRemoveReferences } from "./engine_assetdatabase";
+import { $originalGuid } from "./engine_constants";
+import { __internalDispatchComponentLifecycleEvent, ComponentEvents } from "./engine_components_internal";
 
 const debug = getParam("debuggetcomponent");
 const debugInstantiate = getParam("debuginstantiate");
@@ -119,15 +122,16 @@ function internalDestroy(instance: Object3D | Component, recursive: boolean = tr
 
 
     const obj = instance as GameObject;
-    if (dispose) disposeObject(obj);
     setDestroyed(obj, true);
-
+    if (dispose) disposeObjectResources(obj);
+    // This needs to be called after disposing because it removes the references to resources
+    __internalRemoveReferences(obj);
 
     if (debug) console.log(obj);
 
     if (recursive && obj.children) {
         for (const ch of obj.children) {
-            internalDestroy(ch, recursive, false, false);
+            internalDestroy(ch, recursive, dispose, false);
         }
     }
 
@@ -153,21 +157,6 @@ function internalDestroy(instance: Object3D | Component, recursive: boolean = tr
         obj.removeFromParent();
 }
 
-function disposeObject(obj: Object3D) {
-    if (!obj) return;
-    const mesh = obj as THREE.Mesh;
-    if (mesh.geometry) {
-        mesh.geometry.dispose();
-    }
-    if (mesh.material) {
-        if (Array.isArray(mesh.material)) {
-            mesh.material.forEach(m => m.dispose());
-        } else {
-            mesh.material.dispose();
-        }
-    }
-}
-
 declare type ForEachComponentCallback = (comp: Component) => any;
 
 export function foreachComponent(instance: THREE.Object3D, cb: ForEachComponentCallback, recursive: boolean = true): any {
@@ -304,12 +293,14 @@ function internalInstantiate(
     let clone: THREE.Object3D | GameObject;
     clone = instance.clone(false);
     apply(clone);
+    // if(instance[$originalGuid])
+    //     clone[$originalGuid] = instance[$originalGuid];
     instance.userData = userData;
     instance.children = children;
 
     // make reference from old id to new object
     newGameObjectsMap[instance.uuid] = { original: instance, clone: clone };
-    if(debugInstantiate) console.log("ADD", instance, clone)
+    if (debugInstantiate) console.log("ADD", instance, clone)
 
     if (instance.type === "SkinnedMesh") {
         skinnedMeshesMap[instance.uuid] = { original: instance, clone: clone };
@@ -379,12 +370,16 @@ function internalInstantiate(
         clone.userData.components = newComponents;
         for (let i = 0; i < components.length; i++) {
             const comp = components[i];
-            const copy = Object.create(comp);
+            const copy = new comp.constructor();
             assign(copy, comp);
+            // make sure the original guid stays intact
+            if (comp[$originalGuid] !== undefined)
+                copy[$originalGuid] = comp[$originalGuid];
             newComponents.push(copy);
             copy.gameObject = clone;
             // copy.transform = clone;
             componentsList.push(copy);
+            __internalDispatchComponentLifecycleEvent(ComponentEvents.Added, copy);
         }
     }
 

package/src/engine/engine_gltf_builtin_components.ts

@@ -1,15 +1,15 @@
 import "./codegen/register_types";
 import { TypeStore } from "./engine_typestore";
 import * as THREE from "three";
-import { Component, GameObject } from "../engine-components/Component";
+// import { GameObject } from "../engine-components/Component";
 import { InstantiateIdProvider } from "./engine_networking_instantiate"
 import { Context } from "./engine_setup";
 import { deserializeObject, serializeObject } from "./engine_serialization";
 import { assign, ImplementationInformation, ISerializable, SerializationContext } from "./engine_serialization_core";
 import { NEEDLE_components } from "./extensions/NEEDLE_components";
 import { debugExtension } from "./engine_default_parameters";
-import { builtinComponentKeyName } from "./engine_constants";
-import { GuidsMap, SourceIdentifier } from "./engine_types";
+import { $originalGuid, builtinComponentKeyName } from "./engine_constants";
+import { GuidsMap, IComponent, IGameObject, SourceIdentifier } from "./engine_types";
 import { UIDProvider } from "./engine_types";
 import { addNewComponent } from "./engine_components";
 import { getParam } from "./engine_utils";
@@ -21,7 +21,7 @@ const debug = debugExtension;
 const debugTypeStore = getParam("debugtypestore");
 if (debugTypeStore) console.log(TypeStore);
 
-export function writeBuiltinComponentData(comp: Component, context: SerializationContext): object | null {
+export function writeBuiltinComponentData(comp: IComponent, context: SerializationContext): object | null {
 
     // const fn = (comp as unknown as ISerializable)?.onBeforeSerialize;
     // if (fn) {
@@ -39,6 +39,7 @@ export function writeBuiltinComponentData(comp: Component, context: Serializatio
 }
 
 const typeImplementationInformation = new ImplementationInformation();
+const $context_deserialize_queue = Symbol("deserialize-queue");
 
 export async function createBuiltinComponents(context: Context, gltfId: SourceIdentifier, gltf, seed: number | null | UIDProvider = null, extension?: NEEDLE_components) {
     if (!gltf) return;
@@ -56,26 +57,34 @@ export async function createBuiltinComponents(context: Context, gltfId: SourceId
     serializationContext.nodeToObject = extension?.nodeToObjectMap;
     serializationContext.implementationInformation = typeImplementationInformation;
 
-    const deserialize: DeserializeData[] = [];
+    // If we're loading multiple gltf files in one scene we need to make sure we deserialize all of them in one go
+    // for that we collect them in one list per context
+    let deserializeQueue = context[$context_deserialize_queue];
+    if (!deserializeQueue) deserializeQueue = context[$context_deserialize_queue] = [];
 
     if (gltf.scenes) {
         for (const scene of gltf.scenes) {
-            await onCreateBuiltinComponents(serializationContext, scene, deserialize, lateResolve);
+            await onCreateBuiltinComponents(serializationContext, scene, deserializeQueue, lateResolve);
         }
     }
     if (gltf.children) {
         for (const ch of gltf.children) {
-            await onCreateBuiltinComponents(serializationContext, ch, deserialize, lateResolve);
+            await onCreateBuiltinComponents(serializationContext, ch, deserializeQueue, lateResolve);
         }
     }
 
-
     context.new_scripts_pre_setup_callbacks.push(() => {
-
-        for (const des of deserialize) {
-            handleDeserialization(des, serializationContext);
+        // First deserialize ALL components that were loaded before pre setup
+        // Down below they get new guids assigned so we have to do all of them first
+        // E.g. in cases where we load multiple glb files on startup from one scene
+        // and they might have cross-glb references
+        const queue = context[$context_deserialize_queue];
+        if (queue) {
+            for (const des of queue) {
+                handleDeserialization(des, serializationContext);
+            }
+            queue.length = 0;
         }
-
         // when dropping the same file multiple times we need to generate new guids
         // e.g. SyncTransform sends its own guid to the server to know about ownership
         // so it requires a unique guid for a new instance
@@ -95,7 +104,7 @@ export async function createBuiltinComponents(context: Context, gltfId: SourceId
     // console.log("finished creating builtin components", gltf.scene?.name, gltf);
 }
 
-function recursiveCreateGuids(obj: GameObject, idProvider: UIDProvider | null, guidsMap: GuidsMap) {
+function recursiveCreateGuids(obj: IGameObject, idProvider: UIDProvider | null, guidsMap: GuidsMap) {
     if (idProvider === null) return;
     if (!obj) return;
     const prev = obj.guid;
@@ -117,7 +126,7 @@ function recursiveCreateGuids(obj: GameObject, idProvider: UIDProvider | null, g
     }
     if (obj.children) {
         for (const child of obj.children) {
-            recursiveCreateGuids(child as GameObject, idProvider, guidsMap);
+            recursiveCreateGuids(child as IGameObject, idProvider, guidsMap);
         }
     }
 }
@@ -140,6 +149,7 @@ declare type LateResolveCallback = (gltf: THREE.Object3D) => void;
 
 const unknownComponentsBuffer: Array<string> = [];
 
+
 async function onCreateBuiltinComponents(context: SerializationContext, obj: THREE.Object3D,
     deserialize: DeserializeData[], lateResolve: LateResolveCallback[]) {
     if (!obj) return;
@@ -156,11 +166,16 @@ async function onCreateBuiltinComponents(context: SerializationContext, obj: THR
                     const type = TypeStore.get(compData.name);
                     // console.log(compData, compData.name, type, TypeStore);
                     if (type !== undefined && type !== null) {
-                        const instance: Component = new type() as Component;
+                        const instance: IComponent = new type() as IComponent;
                         instance.sourceId = context.gltfId;
 
                         // assign basic fields
                         assign(instance, compData, context.implementationInformation);
+                        
+                        // assign the guid of the original instance
+                        if("guid" in compData)
+                            instance[$originalGuid] = compData.guid;
+                        
                         // Object.assign(instance, compData);
                         // dont call awake here because some references might not be resolved yet and components that access those fields in awake will throw
                         // for example Duplicatable reference to object might still be { node: id }

package/src/engine/engine_networking_auto.ts

@@ -4,6 +4,7 @@ import { RoomEvents } from "./engine_networking";
 
 const debug = getParam("debugautosync");
 
+const $syncerId = Symbol("syncerId");
 class ComponentsSyncerManager {
     private _syncers: { [key: string]: ComponentPropertiesSyncer } = {};
 
@@ -11,9 +12,14 @@ class ComponentsSyncerManager {
         if (!comp.guid) return null;
         if (this._syncers[comp.guid]) return this._syncers[comp.guid];
         const syncer = new ComponentPropertiesSyncer(comp);
-        this._syncers[comp.guid] = syncer;
+        syncer[$syncerId] = comp.guid;
+        this._syncers[syncer[$syncerId]] = syncer;
         return syncer;
     }
+
+    removeSyncer(syncer: ComponentPropertiesSyncer) {
+        delete this._syncers[syncer[$syncerId]];
+    }
 }
 const syncerHandler = new ComponentsSyncerManager();
 
@@ -35,6 +41,7 @@ class ComponentPropertiesSyncer {
     private data = {};
 
     private _boundEvent?: Function;
+    private _handleReceivingMethod?: Function;
 
     get networkingKey(): string {
         const obj = this.comp as object;
@@ -46,6 +53,7 @@ class ComponentPropertiesSyncer {
     private _isReceiving: boolean = false;
     private _isInit = false;
 
+
     init(comp) {
         if (this._isInit) return;
         this._isInit = true;
@@ -53,10 +61,22 @@ class ComponentPropertiesSyncer {
         // console.log("INIT", this.comp.name, this.networkingKey);
         this._boundEvent = this.onHandleSending.bind(this);
         this.comp.context.post_render_callbacks.push(this._boundEvent);
-        this.comp.context.connection.beginListen(this.networkingKey, this.onHandleReceiving.bind(this));
+        this._handleReceivingMethod = this.onHandleReceiving.bind(this);
+        this.comp.context.connection.beginListen(this.networkingKey, this._handleReceivingMethod);
 
         const state = this.comp.context.connection.tryGetState(this.comp.guid);
-        if(state) this.onHandleReceiving(state);
+        if (state) this.onHandleReceiving(state);
+    }
+
+    destroy() {
+        if (!this._isInit) return;
+        if (this._boundEvent)
+            this.comp.context.post_render_callbacks.splice(this.comp.context.post_render_callbacks.indexOf(this._boundEvent), 1);
+        if (this._handleReceivingMethod)
+            this.comp.context.connection.stopListen(this.networkingKey, this._handleReceivingMethod);
+        //@ts-ignore
+        this.comp = null;
+        this._isInit = false;
     }
 
     notifyChanged(propertyName: string, value: any) {
@@ -156,16 +176,26 @@ function testValueChanged(newValue, previousValue): boolean {
     return valueChanged;
 }
 
+const $syncer = Symbol("AutoSyncHandler");
 function getSyncer(instance): ComponentPropertiesSyncer | null {
-    if (instance["__autoPropertySyncHandler"]) {
-        return instance["__autoPropertySyncHandler"];
+    if (instance[$syncer]) {
+        return instance[$syncer];
     }
     const syncer = syncerHandler.getOrCreateSyncer(instance);
     syncer?.init(instance);
-    instance["__autoPropertySyncHandler"] = syncer;
+    instance[$syncer] = syncer;
     return syncer;
 }
 
+function destroySyncer(instance) {
+    const syncer = instance[$syncer];
+    if (syncer) {
+        syncerHandler.removeSyncer(syncer);
+        syncer.destroy();
+        delete instance[$syncer];
+    }
+}
+
 export declare type SyncFieldOptions = {
     onPropertyChanged: Function,
 };
@@ -190,7 +220,7 @@ export const syncField = function (onFieldChanged?: string) {
         const internalAwake = t.__internalAwake;
         if (debug)
             console.log(propertyKey);
-        const backingFieldName = propertyKey + "k__BackingField";
+        const backingFieldName = Symbol(propertyKey);
 
         t.__internalAwake = function () {
             if (this[backingFieldName] !== undefined) {
@@ -221,7 +251,13 @@ export const syncField = function (onFieldChanged?: string) {
             }
 
             syncer?.init(this);
-            
+
+        }
+
+        const internalDestroy = t.__internalDestroy;
+        t.__internalDestroy = function () {
+            destroySyncer(this);
+            internalDestroy.call(this);
         }
 
     }
@@ -233,6 +269,7 @@ export declare type SyncOptions = {
     fieldName?: string,
 };
 
+/** experimental - use syncField instead */
 export const sync = function (_options?: SyncOptions) {
 
     return function <T>(target: any, _propertyKey: string, descriptor: PropertyDescriptor) {
@@ -253,14 +290,14 @@ export const sync = function (_options?: SyncOptions) {
         // inject getter and setter
         if (!descriptor.get) {
             const previousSetter = descriptor.set;
-            const backingFieldName = _propertyKey + "k__BackingField";
+            const $backingField = Symbol(_propertyKey);
             Object.defineProperty(target, _propertyKey, {
                 set: function (value) {
-                    this[backingFieldName] = value;
+                    this[$backingField] = value;
                     previousSetter?.call(this, value);
                 },
                 get: function () {
-                    return this[backingFieldName];
+                    return this[$backingField];
                 }
             });
             const newDescriptor = Object.getOwnPropertyDescriptor(target, _propertyKey);

package/src/engine/engine_patcher.ts

@@ -0,0 +1,113 @@
+
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/hasOwn
+
+const _wrappedMethods = new WeakSet();
+
+export declare type FieldPatch = (instance: object, oldValue: any, newValue: any) => any;
+export type MethodPatch<T> = (instance: T, result: any, ...args) => any;
+
+/**
+ * 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<TType extends object, TCallback extends (FieldPatch | MethodPatch<any>)>(prototype: TType, fieldName: string, cb: TCallback) {
+
+    // 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 = fieldName + "__needle";// Symbol(fieldName);// + " (patched)";
+
+    internalAddPatch(prototype, fieldName, cb);
+
+    const desc = Object.getOwnPropertyDescriptor(prototype, fieldName);
+
+    if (desc) {
+        // TODO: check if the property is writable
+        // the property might be a method in which case we want to wrap it
+        if (typeof desc.value === "function") {
+            const method = desc.value;
+            if (method) {
+                if (_wrappedMethods.has(method)) {
+                    return;
+                }
+                _wrappedMethods.add(method);
+                prototype[fieldName] = function (this: object, ...args: any[]) {
+                    // call the original method
+                    const result = method.apply(this, args);
+                    // call the patches
+                    const patches = getPatches(prototype, fieldName);
+                    if (patches) {
+                        for (const patch of patches) {
+                            patch(this, result, ...args);
+                        }
+                    }
+                    return result;
+                }
+            }
+            else {
+                // TODO: declare method?
+            }
+        }
+    }
+    else if (prototype.hasOwnProperty(backingField)) {
+    }
+    else {
+        Object.defineProperty(prototype, fieldName, {
+            set: function (this: object, value: any) {
+                const prev = this[backingField];
+                this[backingField] = value;
+                executePatches(prototype, fieldName, this, prev, value);
+            },
+            get: function (this: any) {
+                return this[backingField];
+            }
+        });
+    }
+}
+
+export function removePatch(prototype: object, fieldName: string, cb: Function) {
+    const patches = getPatches(prototype, fieldName);
+    if (patches) {
+        for (let i = patches.length - 1; i >= 0; i--) {
+            if (patches[i] === cb) {
+                patches.splice(i, 1);
+            }
+        }
+    }
+}
+
+
+
+
+const patches = new WeakMap<object, Map<string, Function[]>>();
+
+function getPatches(prototype, fieldName: string) {
+    let patchesMap = patches.get(prototype);
+    if (!patchesMap) {
+        return;
+    }
+    return patchesMap.get(fieldName);;
+}
+
+function internalAddPatch(prototype, fieldName: string, cb: Function) {
+    let patchesMap = patches.get(prototype);
+    if (!patchesMap) {
+        patchesMap = new Map();
+        patches.set(prototype, patchesMap);
+    }
+    let patchList = patchesMap.get(fieldName);
+    if (!patchList) {
+        patchList = [];
+        patchesMap.set(fieldName, patchList);
+    }
+    patchList.push(cb);
+}
+
+function executePatches(prototype, fieldName: string, instance: object, oldValue: any, newValue: any) {
+    if (!instance) return;
+    const patches = getPatches(prototype, fieldName);
+    if (patches) {
+        for (const patch of patches) {
+            patch(instance, oldValue, newValue);
+        }
+    }
+}

package/src/engine/engine_physics.ts

@@ -19,6 +19,7 @@ import RAPIER, { ActiveEvents, CoefficientCombineRule, Collider, ColliderDesc, E
 import { CollisionDetectionMode, PhysicsMaterialCombine } from '../engine/engine_physics.types';
 import { Gizmos } from './engine_gizmos';
 import { Mathf } from './engine_math';
+import { Layer } from './extensions/NEEDLE_animator_controller_model';
 export type Rapier = typeof RAPIER;
 
 
@@ -41,6 +42,8 @@ const $bodyKey = Symbol("physics body");
 const $colliderRigidbody = Symbol("rigidbody");
 // const $removed = Symbol("removed");
 
+const layerMaskHelper: Layers = new Layers();
+
 export class RaycastOptions {
     ray: Ray | undefined = undefined;
     cam: Camera | undefined | null = undefined;
@@ -52,6 +55,7 @@ export class RaycastOptions {
     minDistance: number | undefined = undefined;
     maxDistance: number | undefined = undefined;
     lineThreshold: number | undefined = undefined;
+    /** raw layer mask, use setLayer to set an individual layer active */
     layerMask: Layers | number | undefined = undefined;
     ignore: Object3D[] | undefined = undefined;
 
@@ -61,6 +65,13 @@ export class RaycastOptions {
         this.screenPoint.y = -(oy / window.innerHeight) * 2 + 1;
     }
 
+    /** sets one layer for raycasting (e.g. layer 4, only objects on layer 4 will then be hit) */
+    setLayer(layer: number) {
+        layerMaskHelper.set(layer);
+        this.layerMask = layerMaskHelper;
+    }
+
+    /** sets the layer.mask value directly, use setLayer if you want to set e.g. an individual layer only active. See https://threejs.org/docs/#api/en/core/Layers for more information about layers */
     setMask(mask: number) {
         if (!this.layerMask) this.layerMask = new Layers();
         const lm = this.layerMask as Layers;
@@ -69,7 +80,7 @@ export class RaycastOptions {
         else this.layerMask = mask;
     }
 
-    public static AllLayers = 0xFFFFFFFF;
+    public static readonly AllLayers = 0xFFFFFFFF;
 }
 
 export class SphereIntersection implements Intersection {
@@ -191,7 +202,8 @@ export class Physics {
         else {
             const cam = options.cam ?? this.context.mainCamera;
             if (!cam) {
-                console.error("Can not perform raycast - no main camera found");
+                if (debugPhysics)
+                    console.error("Can not perform raycast - no main camera found");
                 if (this.defaultRaycastOptions.results) this.defaultRaycastOptions.results.length = 0;
                 return this.defaultRaycastOptions.results ?? [];
             }
@@ -216,6 +228,7 @@ export class Physics {
                 rc.layers.mask = options.layerMask.mask;
             else
                 rc.layers.mask = options.layerMask;
+            console.log(rc.layers.mask, options.layerMask);
         }
         else {
             rc.layers.enableAll();

package/src/engine/engine_scenetools.ts

@@ -88,7 +88,6 @@ function invokeEvents(type: GltfLoadEventType, event: GltfLoadEvent) {
 async function handleLoadedGltf(context: Context, gltfId: string, gltf, seed: number | null | UIDProvider, componentsExtension) {
     if (printGltf)
         console.log(gltf);
-    await context.assets.registerGltf(gltf);
     await getLoader().createBuiltinComponents(context, gltfId, gltf, seed, componentsExtension);
 
     // load and assign animation

package/src/engine/engine_serialization_core.ts

@@ -614,7 +614,13 @@ export function assign(target: any, source: any, info?: ImplementationInformatio
 
     for (const key of Object.keys(source)) {
         const desc = getPropertyDescriptor(target, key);
+
         if (onlyDeclared && desc === undefined) continue;
+
+        if (typeof desc?.value == "function") {
+            // arrow functions are defined as properties on the object
+            continue;
+        }
         if (!desc || desc.writable === true) {
             target[key] = source[key];
         }

package/src/engine/engine_setup.ts

@@ -8,8 +8,7 @@ import { NetworkConnection } from './engine_networking';
 import * as looputils from './engine_mainloop_utils';
 import * as utils from "./engine_utils";
 
-import { EffectComposer } from 'three/examples/jsm/postprocessing/EffectComposer.js';
-import { RenderPass } from 'three/examples/jsm/postprocessing/RenderPass';
+import { EffectComposer, RenderPass } from "postprocessing";
 
 import { AssetDatabase } from './engine_assetdatabase';
 
@@ -323,7 +322,8 @@ export class Context implements IContext {
 			this.renderer.domElement.style.height = "100%";
 			if (this.composer) {
 				this.composer.setSize?.call(this.composer, width, height);
-				this.composer.setPixelRatio?.call(this.composer, window.devicePixelRatio);
+				if("setPixelRatio" in this.composer && typeof this.composer.setPixelRatio === "function")
+					this.composer.setPixelRatio?.call(this.composer, window.devicePixelRatio);
 			}
 		}
 	}
@@ -571,7 +571,7 @@ export class Context implements IContext {
 			}
 			else {
 				ContextRegistry.dispatchCallback(ContextEvent.MissingCamera, this);
-				if (!this.mainCamera)
+				if (!this.mainCamera && !this.isManagedExternally)
 					console.error("MISSING camera", this);
 			}
 		}
@@ -608,6 +608,7 @@ export class Context implements IContext {
 
 	private render(_, frame) {
 
+
 		this._currentFrameEvent = -1;
 
 		if (this.onHandlePaused()) return;
@@ -757,10 +758,15 @@ export class Context implements IContext {
 		}
 		this._isRendering = true;
 		this.renderRequiredTextures();
+		// if (camera === this.mainCameraComponent?.cam) {
+		// 	if (this.mainCameraComponent.activeTexture) {
+				
+		// 	}
+		// }
 		if (this.composer && !this.isInXR) {
 			this.composer.render();
 		}
-		else if (this.mainCamera) {
+		else if (camera) {
 			this.renderer.render(this.scene, camera);
 		}
 		this._isRendering = false;

package/src/engine/engine_texture.ts

@@ -1,6 +1,55 @@
-import { WebGLRenderTarget } from "three"
+import { Camera, Mesh, Object3D, Texture, WebGLRenderer, WebGLRenderTarget } from "three";
+import { EffectComposer } from "postprocessing";
+import { findUsers } from "./engine_assetdatabase";
+
+
+const _prevVisible = Symbol("previous-visibility");
+
+export class RenderTexture extends WebGLRenderTarget {
+
+
+    render(scene: Object3D, camera: Camera, renderer: WebGLRenderer | EffectComposer) {
+        if (renderer instanceof EffectComposer) {
+            if (!this["_unsupported_effectcomposer_warning"]) {
+                console.warn("RenderTexture.render() does not yet support EffectComposer");
+                this["_unsupported_effectcomposer_warning"] = true;
+            }
+        }
+        else {
+            this.onBeforeRender();
+            const prev = renderer.getRenderTarget();
+            renderer.setRenderTarget(this);
+            renderer.render(scene, camera);
+            renderer.setRenderTarget(prev);
+            this.onAfterRender();
+        }
+    }
+
+
+    private static _userSet: Set<object> = new Set();
+
+    private onBeforeRender() {
+        RenderTexture._userSet.clear();
+        const users = findUsers(this.texture, true, null, RenderTexture._userSet);
+        for (const user of users) {
+            if (user instanceof Mesh) {
+                user[_prevVisible] = user.visible;
+                user.visible = false;
+            }
+        }
+    }
+
+    private onAfterRender() {
+        for (const user of RenderTexture._userSet) {
+            if (user instanceof Mesh) {
+                user.visible = user[_prevVisible];
+            }
+        }
+        RenderTexture._userSet.clear();
+    }
+}
+
+
+
+
 
-export class RenderTexture extends WebGLRenderTarget
-{
-    
-}