@needle-tools/engine 2.63.3-pre.1 → 2.65.0-pre

package/src/engine-components/Camera.ts

@@ -2,7 +2,7 @@ import { Behaviour, GameObject } from "./Component";
 import { getParam } from "../engine/engine_utils";
 import { serializable } from "../engine/engine_serialization_decorator";
 import { RGBAColor } from "./js-extensions/RGBAColor";
-import { XRSessionMode } from "../engine/engine_setup";
+import { Context, XRSessionMode } from "../engine/engine_setup";
 import { ICamera } from "../engine/engine_types"
 import { showBalloonMessage } from "../engine/debug/debug";
 import { getWorldPosition } from "../engine/engine_three_utils";
@@ -267,7 +267,7 @@ export class Camera extends Behaviour implements ICamera {
         if (this._cam && this.context.mainCameraComponent === this) {
             switch (this._clearFlags) {
                 case ClearFlags.Skybox:
-                    if (this.environmentIsTransparent()) {
+                    if (Camera.backgroundShouldBeTransparent(this.context)) {
                         if (!this.ARBackgroundAlpha || this.ARBackgroundAlpha < 0.001) {
                             this.context.scene.background = null;
                             this.context.renderer.setClearColor(0x000000, 0);
@@ -287,7 +287,7 @@ export class Camera extends Behaviour implements ICamera {
                     if (this._backgroundColor) {
                         let alpha = this._backgroundColor.alpha;
                         // when in WebXR use ar background alpha override or set to 0
-                        if (this.environmentIsTransparent()) {
+                        if (Camera.backgroundShouldBeTransparent(this.context)) {
                             alpha = this.ARBackgroundAlpha ?? 0;
                         }
                         this.context.scene.background = null;
@@ -302,15 +302,22 @@ export class Camera extends Behaviour implements ICamera {
         }
     }
 
-    private environmentIsTransparent(): boolean {
-        const session = this.context.renderer.xr?.getSession();
+    private enableSkybox() {
+        if (!this._skybox)
+            this._skybox = new CameraSkybox(this);
+        this._skybox.enable();
+    }
+
+    /** Returns true when in XR on a pass through device where the background shouldbe invisible */
+    static backgroundShouldBeTransparent(context:Context) {
+        const session = context.renderer.xr?.getSession();
         if (!session) return false;
         const environmentBlendMode = session.environmentBlendMode;
         if (debug)
             showBalloonMessage("Environment blend mode: " + environmentBlendMode + " on " + navigator.userAgent);
         const transparent = environmentBlendMode === 'additive' || environmentBlendMode === 'alpha-blend';
 
-        if (this.context.xrSessionMode === XRSessionMode.ImmersiveAR) {
+        if (context.xrSessionMode === XRSessionMode.ImmersiveAR) {
             if (environmentBlendMode === "opaque") {
                 // workaround for Quest 2 returning opaque when it should be alpha-blend
                 // check user agent if this is the Quest browser and return true if so
@@ -323,14 +330,9 @@ export class Camera extends Behaviour implements ICamera {
                 }
             }
         }
+        
         return transparent;
     }
-
-    private enableSkybox() {
-        if (!this._skybox)
-            this._skybox = new CameraSkybox(this);
-        this._skybox.enable();
-    }
 }
 
 

package/src/engine-components/Component.ts

@@ -23,13 +23,16 @@ abstract class GameObject extends THREE.Object3D implements THREE.Object3D, IGam
 
     guid: string | undefined;
 
+    // The actual implementation / prototype of threejs is modified in js-extensions/Object3D
+    abstract get transform(): THREE.Object3D;
+
     public static isDestroyed(go: THREE.Object3D): boolean {
         return isDestroyed(go);
     }
 
-    public static setActive(go: THREE.Object3D, active: boolean, processStart: boolean = true, setVisible: boolean = true) {
+    public static setActive(go: THREE.Object3D, active: boolean, processStart: boolean = true) {
         if (!go) return;
-        setActive(go, active, setVisible);
+        setActive(go, active);
         main.updateIsActive(go);
         if (active && processStart)
             main.processStart(Context.Current, go);

package/src/engine-components/Light.ts

@@ -246,9 +246,9 @@ export class Light extends Behaviour implements ILight {
         return vec;
     }
 
-    public updateIntensity() {
-        this.intensity = this._intensity;
-    }
+    // public updateIntensity() {
+    //     this.intensity = this._intensity;
+    // }
 
     awake() {
         this.color = new THREE.Color(this.color ?? 0xffffff);
@@ -256,10 +256,12 @@ export class Light extends Behaviour implements ILight {
     }
 
     onEnable(): void {
+        if(debug) console.log("ENABLE LIGHT", this.name);
         this.createLight();
         if (this.isBaked) return;
         else if (this.light) {
             this.light.visible = true;
+            this.light.intensity = this._intensity;
             if (this.selfIsLight) {
                 // nothing to do
             }
@@ -273,8 +275,12 @@ export class Light extends Behaviour implements ILight {
     }
 
     onDisable() {
+        if(debug) console.log("DISABLE LIGHT", this.name);
         if (this.light) {
-            this.light.visible = false;
+            if (this.selfIsLight)
+                this.light.intensity = 0;
+            else
+                this.light.visible = false;
         }
         WebXR.removeEventListener(WebXREvent.XRStarted, this._webXRStartedListener);
         WebXR.removeEventListener(WebXREvent.XRStopped, this._webXREndedListener);
@@ -286,19 +292,19 @@ export class Light extends Behaviour implements ILight {
 
     private onWebXRStarted() {
         this._webARRoot = GameObject.getComponentInParent(this.gameObject, WebARSessionRoot) ?? undefined;
-        this.startCoroutine(this._updateLightIntensityInARRoutine());
+        // this.startCoroutine(this._updateLightIntensityInARRoutine());
     }
 
-    private *_updateLightIntensityInARRoutine() {
-        while (this.context.isInAR) {
-            yield;
-            this.updateIntensity();
-            for (let i = 0; i < 30; i++) yield;
-        }
-    }
+    // private *_updateLightIntensityInARRoutine() {
+    //     while (this.context.isInAR) {
+    //         yield;
+    //         // this.updateIntensity();
+    //         for (let i = 0; i < 30; i++) yield;
+    //     }
+    // }
 
     private onWebXREnded() {
-        this.updateIntensity();
+        // this.updateIntensity();
     }
 
     createLight() {
@@ -306,6 +312,7 @@ export class Light extends Behaviour implements ILight {
 
         if (lightAlreadyCreated && !this.light) {
             this.light = this.gameObject as unknown as THREE.Light;
+            this.light.name = this.name;
             this._intensity = this.light.intensity;
 
             switch (this.type) {

package/src/engine-components/ParticleSystem.ts

@@ -70,7 +70,7 @@ export class ParticleSystemRenderer extends Behaviour {
 
     getMaterial(trailEnabled: boolean = false) {
         const material = (trailEnabled === true && this.trailMaterial) ? this.trailMaterial : this.particleMaterial;
-        
+
         // progressive load on start
         // TODO: figure out how to do this before particle system rendering so we only load textures for visible materials
         if (material && !suppressProgressiveLoading && material["_didRequestTextureLOD"] === undefined) {
@@ -836,7 +836,20 @@ export class ParticleSystem extends Behaviour implements IParticleSystem {
     onBeforeRender() {
         this.onUpdate();
         const dt = this.deltaTime;
-        this._batchSystem?.update(dt);
+
+        if (this._batchSystem) {
+            // Updating layers on batches
+            // TODO: figure out a better way to do this
+            // Issue: https://github.com/Alchemist0823/three.quarks/issues/49
+            if (this.context.time.frameCount % 60 === 0) {
+                for (let i = 0; i < this._batchSystem.batches.length; i++) {
+                    const batch = this._batchSystem.batches[i];
+                    batch.layers.disableAll();
+                    batch.layers.set(2);
+                }
+            }
+            this._batchSystem.update(dt);
+        }
         this._time += dt;
         if (this._time > this.duration) this._time = 0;
     }

package/src/engine-components/Renderer.ts

@@ -5,7 +5,7 @@ import { RendererLightmap } from "./RendererLightmap";
 import { Context, FrameEvent } from "../engine/engine_setup";
 import { getParam } from "../engine/engine_utils";
 import { serializable } from "../engine/engine_serialization_decorator";
-import { AxesHelper, Material, Mesh, Object3D, SkinnedMesh, Texture, Vector4 } from "three";
+import { AxesHelper, Material, Matrix4, Mesh, Object3D, SkinnedMesh, Texture, Vector4 } from "three";
 import { NEEDLE_render_objects } from "../engine/extensions/NEEDLE_render_objects";
 import { NEEDLE_progressive } from "../engine/extensions/NEEDLE_progressive";
 import { NEED_UPDATE_INSTANCE_KEY } from "../engine/engine_instancing";
@@ -18,6 +18,7 @@ import { showBalloonWarning } from "../engine/debug/debug";
 // for staying compatible with old code
 export { InstancingUtil } from "../engine/engine_instancing";
 
+const debugRenderer = getParam("debugrenderer");
 const suppressInstancing = getParam("noInstancing");
 const debugLightmap = getParam("debuglightmaps") ? true : false;
 const debugInstancing = getParam("debuginstancing");
@@ -294,6 +295,7 @@ export class Renderer extends Behaviour implements IRenderer {
     }
 
     awake() {
+        if (debugRenderer) console.log("Renderer ", this.name, this);
         this.clearInstancingState();
 
         if (this.probeAnchor && debug) this.probeAnchor.add(new AxesHelper(.2));
@@ -332,6 +334,9 @@ export class Renderer extends Behaviour implements IRenderer {
             if (this.renderOrder !== undefined && this.renderOrder.length > 0)
                 this.gameObject.renderOrder = this.renderOrder[0];
         }
+        else {
+            this.context.addBeforeRenderListener(this.gameObject, this.onBeforeRenderThree.bind(this));
+        }
 
         if (this.lightmapIndex >= 0) {
             // use the override lightmap if its not undefined
@@ -394,20 +399,14 @@ export class Renderer extends Behaviour implements IRenderer {
         this.handles = undefined;
         this.prevLayers = undefined;
     }
+
     setInstancingEnabled(enabled: boolean): boolean {
         if (this._isInstancingEnabled === enabled) return enabled && (this.handles === undefined || this.handles != null && this.handles.length > 0);
         this._isInstancingEnabled = enabled;
         if (enabled) {
-            // if handles is undefined we
             if (this.handles === undefined) {
-                this.handles = instancing.setup(this.gameObject, this.context, null, { rend: this, foundMeshes: 0 });
+                this.handles = instancing.setup(this, this.gameObject, this.context, null, { rend: this, foundMeshes: 0, useMatrixWorldAutoUpdate: this.useInstanceMatrixWorldAutoUpdate() });
                 if (this.handles) {
-                    // const disableSelf = this.gameObject.type === "Mesh" || this.gameObject.children?.length === this.handles.length;
-                    // this.gameObject.visible = !disableSelf;
-                    // this.gameObject.type = "Object3D";
-                    // this.gameObject.material = null;
-                    // console.log("Using instancing", this.gameObject.visible);
-                    // this.gameObject.onBeforeRender = () => console.log("SHOULD NOT BE CALLED");
                     GameObject.markAsInstancedRendered(this.gameObject, true);
                     return true;
                 }
@@ -417,8 +416,6 @@ export class Renderer extends Behaviour implements IRenderer {
                     handler.updateInstanceMatrix(true);
                     handler.add();
                 }
-                // this.gameObject.type = "Object3D";
-                // this.gameObject.visible = false;
                 GameObject.markAsInstancedRendered(this.gameObject, true);
                 return true;
             }
@@ -429,13 +426,19 @@ export class Renderer extends Behaviour implements IRenderer {
                     handler.remove();
                 }
             }
-            // this.gameObject.visible = true;
             return true;
         }
 
         return false;
     }
 
+    /** Return true to wrap matrix update events for instanced rendering to update instance matrices automatically when matrixWorld changes
+     * This is a separate method to be overrideable from user code
+     */
+    useInstanceMatrixWorldAutoUpdate() {
+        return true;
+    }
+
     start() {
         if (this.enableInstancing && !suppressInstancing) {
             this.setInstancingEnabled(true);
@@ -461,6 +464,7 @@ export class Renderer extends Behaviour implements IRenderer {
         }
 
         this.updateReflectionProbe();
+
     }
 
     onDisable() {
@@ -479,17 +483,12 @@ export class Renderer extends Behaviour implements IRenderer {
         NEEDLE_render_objects.applyStencil(this);
     }
 
-    static envmap: THREE.Texture | null = null;
 
     onBeforeRender() {
         if (!this.gameObject) {
             return;
         }
 
-        Renderer.envmap = this.scene.environment;
-
-        const needsUpdate: boolean = this.gameObject[NEED_UPDATE_INSTANCE_KEY] === true || this.gameObject.matrixWorldNeedsUpdate;
-
         if (this.isMultiMaterialObject(this.gameObject) && this.gameObject.children?.length > 0) {
             for (const ch of this.gameObject.children) {
                 this.applySettings(ch);
@@ -499,9 +498,14 @@ export class Renderer extends Behaviour implements IRenderer {
             this.applySettings(this.gameObject);
         }
 
-        if (needsUpdate) {
-            delete this.gameObject[NEED_UPDATE_INSTANCE_KEY];
-            if (this.handles) {
+        if (this.handles?.length) {
+            // if (this.name === "Darbouka")
+            //     console.log(this.name, this.gameObject.matrixWorldNeedsUpdate);
+            const needsUpdate: boolean = this.gameObject[NEED_UPDATE_INSTANCE_KEY] === true;// || this.gameObject.matrixWorldNeedsUpdate;
+            if (needsUpdate) {
+                if(debugInstancing)
+                    console.log("UPDATE INSTANCED MATRICES", this.context.time.frame);
+                this.gameObject[NEED_UPDATE_INSTANCE_KEY] = false;
                 const remove = false;// Math.random() < .01;
                 for (let i = this.handles.length - 1; i >= 0; i--) {
                     const h = this.handles[i];
@@ -539,14 +543,7 @@ export class Renderer extends Behaviour implements IRenderer {
 
     onBeforeRenderThree(_renderer, _scene, _camera, _geometry, material, _group) {
 
-        // progressive load before rendering so we only load textures for visible materials
-        if (!suppressProgressiveLoading && material._didRequestTextureLOD === undefined && this.allowProgressiveLoading) {
-            material._didRequestTextureLOD = 0;
-            if (debugProgressiveLoading) {
-                console.log("Load material LOD", material.name);
-            }
-            NEEDLE_progressive.assignTextureLOD(this.context, this.sourceId, material);
-        }
+        this.loadProgressiveTextures(material);
 
         if (material.envMapIntensity !== undefined) {
             const factor = this.hasLightmap ? Math.PI : 1;
@@ -607,6 +604,22 @@ export class Renderer extends Behaviour implements IRenderer {
         }
     }
 
+    loadProgressiveTextures(material: THREE.Material) {
+        // progressive load before rendering so we only load textures for visible materials
+        if (!suppressProgressiveLoading && material) {
+            if (debugProgressiveLoading && material["_didRequestTextureLOD"] === undefined)
+                console.warn("Progressive?", this)
+
+            if (material["_didRequestTextureLOD"] === undefined && this.allowProgressiveLoading) {
+                material["_didRequestTextureLOD"] = 0;
+                if (debugProgressiveLoading) {
+                    console.log("Load material LOD", material.name);
+                }
+                NEEDLE_progressive.assignTextureLOD(this.context, this.sourceId, material);
+            }
+        }
+    }
+
     private applySettings(go: THREE.Object3D) {
         go.receiveShadow = this.receiveShadows;
         if (this.shadowCastingMode == ShadowCastingMode.On) {
@@ -689,17 +702,22 @@ export enum ShadowCastingMode {
 
 
 
-declare class InstancingSetupArgs { rend: Renderer; foundMeshes: number };
+declare class InstancingSetupArgs {
+    rend: Renderer;
+    foundMeshes: number;
+    useMatrixWorldAutoUpdate: boolean;
+};
 
 class InstancingHandler {
 
     public objs: InstancedMeshRenderer[] = [];
 
-    public setup(obj: THREE.Object3D, context: Context, handlesArray: InstanceHandle[] | null, args: InstancingSetupArgs, level: number = 0)
+    public setup(renderer:Renderer, obj: THREE.Object3D, context: Context, handlesArray: InstanceHandle[] | null, args: InstancingSetupArgs, level: number = 0)
         : InstanceHandle[] | null {
 
         const res = this.tryCreateOrAddInstance(obj, context, args);
         if (res) {
+            renderer.loadProgressiveTextures(res.instancer.material);
             if (handlesArray === null) handlesArray = [];
             handlesArray.push(res);
             return handlesArray;
@@ -708,7 +726,7 @@ class InstancingHandler {
         if (level <= 0 && obj.type !== "Mesh") {
             const nextLevel = level + 1;
             for (const ch of obj.children) {
-                handlesArray = this.setup(ch, context, handlesArray, args, nextLevel);
+                handlesArray = this.setup(renderer, ch, context, handlesArray, args, nextLevel);
             }
         }
         return handlesArray;
@@ -736,16 +754,52 @@ class InstancingHandler {
             for (const i of this.objs) {
                 if (i.isFull()) continue;
                 if (i.geo === geo && i.material === mat) {
-                    return i.addInstance(mesh);
+                    const handle = i.addInstance(mesh);
+                    if (args.useMatrixWorldAutoUpdate && handle)
+                        this.autoUpdateInstanceMatrix(mesh, i, handle);
+                    return handle;
                 }
             }
             // console.log("Add new instance mesh renderer", obj);
             const i = new InstancedMeshRenderer(obj.name, geo, mat, 200, context);
             this.objs.push(i);
-            return i.addInstance(mesh);
+            const handle = i.addInstance(mesh);
+            if (args.useMatrixWorldAutoUpdate && handle)
+                this.autoUpdateInstanceMatrix(mesh, i, handle);
+            return handle;
         }
         return null;
     }
+
+    private autoUpdateInstanceMatrix(obj: Object3D, _renderer: InstancedMeshRenderer, _handle: InstanceHandle) {
+        const original = obj.matrixWorld["multiplyMatrices"].bind(obj.matrixWorld);
+        let previousMatrix: THREE.Matrix4 = obj.matrixWorld.clone();
+
+        const matrixChangeWrapper = (a: Matrix4, b: Matrix4) => {
+            const newMatrixWorld = original(a, b);
+            // console.warn("MULT", obj.matrixWorldNeedsUpdate);
+            if (obj[NEED_UPDATE_INSTANCE_KEY] || previousMatrix.equals(newMatrixWorld) === false) {
+                previousMatrix.copy(newMatrixWorld)
+                // handle.setMatrix(newMatrixWorld);
+                obj[NEED_UPDATE_INSTANCE_KEY] = true;
+            }
+            return newMatrixWorld;
+        };
+        obj.matrixWorld["multiplyMatrices"] = matrixChangeWrapper;
+
+        // wrap matrixWorldNeedsUpdate
+        // let originalMatrixWorldNeedsUpdate = obj.matrixWorldNeedsUpdate;
+        // Object.defineProperty(obj, "matrixWorldNeedsUpdate", {
+        //     get: () => {
+        //         return originalMatrixWorldNeedsUpdate;
+        //     },
+        //     set: (value: boolean) => {
+        //         if(value) console.warn("SET MATRIX WORLD NEEDS UPDATE");
+        //         originalMatrixWorldNeedsUpdate = value;
+        //     }
+        // });
+
+    }
 }
 const instancing: InstancingHandler = new InstancingHandler();
 
@@ -773,6 +827,11 @@ class InstanceHandle {
         this.instancer.updateInstance(this.object.matrixWorld, this.instanceIndex);
     }
 
+    setMatrix(matrix: THREE.Matrix4) {
+        if (this.instanceIndex < 0) return;
+        this.instancer.updateInstance(matrix, this.instanceIndex);
+    }
+
     add() {
         if (this.instanceIndex >= 0) return;
         this.instancer.add(this);

package/src/engine-components/Skybox.ts

@@ -4,7 +4,7 @@ import { RGBELoader } from 'three/examples/jsm/loaders/RGBELoader.js';
 import { EXRLoader } from "three/examples/jsm/loaders/EXRLoader";
 import { EquirectangularRefractionMapping, sRGBEncoding, Texture, TextureLoader } from "three"
 import { syncField } from "../engine/engine_networking_auto";
-
+import { Camera } from "./Camera";
 
 export class RemoteSkybox extends Behaviour {
 
@@ -22,6 +22,7 @@ export class RemoteSkybox extends Behaviour {
     environment: boolean = true;
 
     private _loader?: RGBELoader | EXRLoader | TextureLoader;
+    private _prevUrl?: string;
     private _prevLoadedEnvironment?: Texture;
     private _prevEnvironment: Texture | null = null;
     private _prevBackground: any = null;
@@ -33,10 +34,9 @@ export class RemoteSkybox extends Behaviour {
 
     onDisable() {
         if (this.context.scene.environment === this._prevLoadedEnvironment) {
-            if (!this.context.isInXR) {
-                this.context.scene.environment = this._prevEnvironment;
+            this.context.scene.environment = this._prevEnvironment;
+            if (!Camera.backgroundShouldBeTransparent(this.context))
                 this.context.scene.background = this._prevBackground;
-            }
             this._prevLoadedEnvironment = undefined;
         }
         this.unregisterDropEvents();
@@ -48,39 +48,66 @@ export class RemoteSkybox extends Behaviour {
             console.warn("Potentially invalid skybox url", this.url, "on", this.name);
         }
 
-        // if (!this._loader) 
-        {
-            const isEXR = url.endsWith(".exr");
-            const isHdr = url.endsWith(".hdr");
-            if (isEXR) {
+        if (this._prevUrl === url && this._prevLoadedEnvironment) {
+            this.applySkybox();
+            return;
+        }
+        else {
+            this._prevLoadedEnvironment?.dispose();
+            this._prevLoadedEnvironment = undefined;
+        }
+        this._prevUrl = url;
+
+
+        const isEXR = url.endsWith(".exr");
+        const isHdr = url.endsWith(".hdr");
+        if (isEXR) {
+            if (!(this._loader instanceof EXRLoader))
                 this._loader = new EXRLoader();
-            }
-            else if (isHdr) {
+        }
+        else if (isHdr) {
+            if (!(this._loader instanceof RGBELoader))
                 this._loader = new RGBELoader();
-            }
-            else {
+        }
+        else {
+            if (!(this._loader instanceof TextureLoader))
                 this._loader = new TextureLoader();
-            }
         }
+
         console.log("Loading skybox: " + url);
         const envMap = await this._loader.loadAsync(url);
         if (!envMap) return;
+        // Check if we're still enabled
         if (!this.enabled) return;
+        // Update the current url
         this.url = url;
-        envMap.mapping = EquirectangularRefractionMapping;
+        const nameIndex = url.lastIndexOf("/");
+        envMap.name = url.substring(nameIndex >= 0 ? nameIndex + 1 : 0);
         if (this._loader instanceof TextureLoader) {
             envMap.encoding = sRGBEncoding;
         }
-        this._prevBackground = this.context.scene.background;
-        this._prevEnvironment = this.context.scene.environment;
-        console.log("Set skybox", this.url);
+        this._prevLoadedEnvironment = envMap;
+        this.applySkybox();
+    }
+
+    private applySkybox() {
+        const envMap = this._prevLoadedEnvironment;
+        if (!envMap) return;
+
+        envMap.mapping = EquirectangularRefractionMapping;
+        envMap.needsUpdate = true;
+
+        // capture state
+        if (this.context.scene.background !== envMap)
+            this._prevBackground = this.context.scene.background;
+        if (this.context.scene.environment !== envMap)
+            this._prevEnvironment = this.context.scene.environment;
+
+        console.log("Set remote skybox", this.url);
         if (this.environment)
             this.context.scene.environment = envMap;
-        if (this.background)
+        if (this.background && !Camera.backgroundShouldBeTransparent(this.context))
             this.context.scene.background = envMap;
-        this._prevLoadedEnvironment = envMap;
-        const nameIndex = url.lastIndexOf("/");
-        envMap.name = url.substring(nameIndex >= 0 ? nameIndex + 1 : 0);
         if (this.context.mainCameraComponent?.backgroundBlurriness !== undefined)
             this.context.scene.backgroundBlurriness = this.context.mainCameraComponent.backgroundBlurriness;
     }

package/src/engine-components/Volume.ts

@@ -88,6 +88,7 @@ export class VolumeProfile {
                 }
             }
             else if (component instanceof ColorAdjustments) {
+                if (!component.active) continue;
                 const colorAdjustments = component as ColorAdjustments;
                 // unity range goes from -15..15
                 // three.js range goes from 0..inf

package/src/engine-components/js-extensions/Object3D.ts

@@ -12,7 +12,6 @@ export function apply(object: Object3D) {
     }
 }
 
-
 Object3D.prototype["SetActive"] = function (active: boolean) {
     this.visible = active;
 }
@@ -64,11 +63,18 @@ if (!Object.getOwnPropertyDescriptor(Object3D.prototype, "activeSelf")) {
             return isActiveSelf(this)
         },
         set: function (val: boolean | number) {
-            setActive(this, val, true);
+            setActive(this, val);
         }
     });
 }
 
+if (!Object.getOwnPropertyDescriptor(Object3D.prototype, "transform")) {
+    Object.defineProperty(Object3D.prototype, "transform", {
+        get: function () {
+            return this;
+        }
+    });
+}