@needle-tools/engine 2.63.3-pre → 2.64.0-pre

package/src/engine/engine_types.ts

@@ -21,9 +21,9 @@ export interface UIDProvider {
 
 
 export declare type CoroutineData = {
-	comp: IComponent,
-	main: Generator,
-	chained?: Array<Generator>
+    comp: IComponent,
+    main: Generator,
+    chained?: Array<Generator>
 }
 
 
@@ -37,25 +37,25 @@ export interface IContext {
     domElement: HTMLElement;
 
     scripts: IComponent[];
-	scripts_pausedChanged: IComponent[];
-	// scripts with update event
-	scripts_earlyUpdate: IComponent[];
-	scripts_update: IComponent[];
-	scripts_lateUpdate: IComponent[];
-	scripts_onBeforeRender: IComponent[];
-	scripts_onAfterRender: IComponent[];
-	scripts_WithCorroutines: IComponent[];
-	coroutines: { [FrameEvent: number]: Array<CoroutineData> };
-    
-	post_setup_callbacks: Function[];
-	pre_update_callbacks: Function[];
-	pre_render_callbacks: Function[];
-	post_render_callbacks: Function[];
-
-	new_scripts: IComponent[];
-	new_script_start: IComponent[];
-	new_scripts_pre_setup_callbacks: Function[];
-	new_scripts_post_setup_callbacks: Function[];
+    scripts_pausedChanged: IComponent[];
+    // scripts with update event
+    scripts_earlyUpdate: IComponent[];
+    scripts_update: IComponent[];
+    scripts_lateUpdate: IComponent[];
+    scripts_onBeforeRender: IComponent[];
+    scripts_onAfterRender: IComponent[];
+    scripts_WithCorroutines: IComponent[];
+    coroutines: { [FrameEvent: number]: Array<CoroutineData> };
+
+    post_setup_callbacks: Function[];
+    pre_update_callbacks: Function[];
+    pre_render_callbacks: Function[];
+    post_render_callbacks: Function[];
+
+    new_scripts: IComponent[];
+    new_script_start: IComponent[];
+    new_scripts_pre_setup_callbacks: Function[];
+    new_scripts_post_setup_callbacks: Function[];
 
     stopAllCoroutinesFrom(script: IComponent);
 }
@@ -71,6 +71,13 @@ export declare interface IGameObject extends Object3D {
     guid: string | undefined;
 
     activeSelf: boolean;
+
+    /** NOTE: this is just a wrapper for devs coming from Unity. Please use this.gameObject instead. In Needle Engine this.gameObject is the same as this.gameObject.transform. See the tutorial link below for more information
+     * @augments Object3D
+     * @tutorial https://fwd.needle.tools/needle-engine/docs/transform
+     * */
+    get transform(): Object3D;
+    
     addNewComponent<T>(type: Constructor<T>): T | null;
     removeComponent(comp: IComponent): IComponent;
     getOrAddComponent<T>(typeName: Constructor<T> | null): T;
@@ -100,12 +107,19 @@ export interface IComponent {
 
     get activeAndEnabled(): boolean;
 
+    /** @internal */
     __internalNewInstanceCreated();
+    /** @internal */
     __internalAwake();
+    /** @internal */
     __internalStart();
+    /** @internal */
     __internalEnable();
+    /** @internal */
     __internalDisable();
+    /** @internal */
     __internalDestroy();
+    /** @internal */
     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. */

package/src/engine-components/Animation.ts

@@ -125,11 +125,12 @@ export class Animation extends Behaviour {
     update() {
         if (!this.mixer) return;
         this.mixer.update(this.context.time.deltaTime);
-        for (const handle of this._handles) {
-            handle._update();
-        }
-        if (this._handles?.length > 0)
-            InstancingUtil.markDirty(this.gameObject);
+        // this is now handled via matrix auto update
+        // for (const handle of this._handles) {
+        //     handle._update();
+        // }
+        // if (this._handles?.length > 0)
+        //     InstancingUtil.markDirty(this.gameObject);
     }
 
     getAction(name: string): THREE.AnimationAction | undefined | null {

package/src/engine-components/AnimatorController.ts

@@ -146,6 +146,7 @@ export class AnimatorController {
         if (!this.animator) return;
         this.evaluateTransitions();
         this.updateActiveStates();
+        if(!this._activeState) return;
         const dt = this.animator.context.time.deltaTime;
         if (this.animator.applyRootMotion) {
             this.rootMotionHandler?.onBeforeUpdate();

package/src/engine-components/AudioListener.ts

@@ -16,6 +16,7 @@ export class AudioListener extends Behaviour {
 
     awake() {
         AudioSource.registerWaitForAllowAudio(() => {
+            if (this.destroyed) return;
             const listener = this.listener;
             if (listener == null) return;
             // if the listener is already parented to some object d0nt change it

package/src/engine-components/AudioSource.ts

@@ -75,7 +75,7 @@ export class AudioSource extends Behaviour {
             }
             this.callbacks.length = 0;
         };
-        let fn = callback.bind(this);
+        const fn = callback.bind(this);
         document.addEventListener('pointerdown', fn);
         document.addEventListener('click', fn);
         document.addEventListener('dragstart', fn);
@@ -133,7 +133,7 @@ export class AudioSource extends Behaviour {
     get volume(): number { return this._volume; }
     set volume(val: number) {
         this._volume = val;
-        if (this.sound) {
+        if (this.sound && !this.context.application.muted) {
             if (debug) console.log(this.name, "audio set volume", val);
             this.sound.setVolume(val);
         }
@@ -167,7 +167,9 @@ export class AudioSource extends Behaviour {
 
     public get ShouldPlay(): boolean { return this.shouldPlay; }
 
-    private _focusCallback?: any;
+
+    private _focusCallback: any;
+    private _muteChangedCallback: any;
 
     awake() {
         this.audioLoader = new THREE.AudioLoader();
@@ -189,13 +191,22 @@ export class AudioSource extends Behaviour {
             if (this.enabled && this.playOnAwake && !this.isPlaying && AudioSource._userInteractionRegistered) {
                 this.play();
             }
-        };
+        }
+
+        this._muteChangedCallback = () => {
+            if (this.context.application.muted)
+                this.sound?.setVolume(0);
+            else
+                this.sound?.setVolume(this.volume);
+        }
 
         this.context.application.addEventListener(ApplicationEvents.Visible, this._focusCallback);
+        this.context.application.addEventListener(ApplicationEvents.MuteChanged, this._muteChangedCallback);
     }
 
     onDestroy() {
         this.context.application.removeEventListener(ApplicationEvents.Visible, this._focusCallback);
+        this.context.application.removeEventListener(ApplicationEvents.MuteChanged, this._muteChangedCallback);
     }
 
 
@@ -233,7 +244,8 @@ export class AudioSource extends Behaviour {
 
             sound.setBuffer(buffer);
             sound.loop = this._loop;
-            sound.setVolume(this.volume);
+            if(this.context.application.muted) sound.setVolume(0);
+            else sound.setVolume(this.volume);
             sound.autoplay = this.shouldPlay;
             // sound.setDistanceModel('linear');
             // sound.setRolloffFactor(1);
@@ -313,7 +325,9 @@ export class AudioSource extends Behaviour {
         if (debug)
             console.log("play", this.sound?.getVolume(), this.sound);
         if (this.sound && !this.sound.isPlaying) {
-            this.sound.play();
+            const muted = this.context.application.muted;
+            if(muted) this.sound.setVolume(0);
+            this.sound.play(muted ? .1 : 0);
         }
     }
 

package/src/engine-components/Component.ts

@@ -23,6 +23,9 @@ 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);
     }

package/src/engine-components/GridHelper.ts

@@ -6,7 +6,7 @@ import { Color, GridHelper as _GridHelper } from "three";
 export class GridHelper extends Behaviour {
 
     @serializable()
-    public isGizmo:boolean = false;
+    public isGizmo: boolean = false;
     @serializable(Color)
     private color0!: THREE.Color;
     @serializable(Color)
@@ -23,10 +23,18 @@ export class GridHelper extends Behaviour {
         const size = this.size;
         const divisions = this.divisions;
         if (!this.gridHelper) {
-            this.gridHelper = new _GridHelper(size, divisions, this.color0 ?? new Color(.4, .4, .4), this.color1 ?? new Color(.6,.6,.6));
+            this.gridHelper = new _GridHelper(size, divisions, this.color0 ?? new Color(.4, .4, .4), this.color1 ?? new Color(.6, .6, .6));
             if (this.offset !== undefined)
                 this.gridHelper.position.y += this.offset;
+        }
+        if (this.gridHelper)
             this.gameObject.add(this.gridHelper);
+    }
+
+    onDisable(): void {
+        if (this.gridHelper) {
+            this.gameObject.remove(this.gridHelper);
+            this.gridHelper = null;
         }
     }
 }

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/WebARSessionRoot.ts

@@ -45,6 +45,7 @@ export class WebARSessionRoot extends Behaviour {
     private _placementPose: Matrix4 | null = null;
     private _isTouching: boolean = false;
     private _rigStartPose: Matrix4 | undefined | null = null;
+    private _gotFirstHitTestResult: boolean = false;
 
     onBegin(session: XRSession) {
         this._placementPose = null;
@@ -52,6 +53,7 @@ export class WebARSessionRoot extends Behaviour {
         this.gameObject.matrixAutoUpdate = false;
         this._startPose = this.gameObject.matrix.clone();
         this._rigStartPose = this.rig?.matrix.clone();
+        this._gotFirstHitTestResult = false;
         session.addEventListener('selectstart', this._selectStartFn);
         session.addEventListener('selectend', this._selectEndFn);
         // setTimeout(() => this.gameObject.visible = false, 1000); // TODO test on phone AR and Hololens if this was still needed
@@ -66,12 +68,24 @@ export class WebARSessionRoot extends Behaviour {
             this.rig.matrixAutoUpdate = true;
             this._initalMatrix.decompose(this.rig.position, this.rig.quaternion, this.rig.scale);
         }
+
+        // TODO this is duplicate to WebXR events AND engine events, would be better in one place
+        this.dispatchEvent(new CustomEvent('onBeginSession'));
     }
 
     onUpdate(rig: Object3D | null, _session: XRSession, pose: XRPose | null | undefined): boolean {
 
         if (pose && !this._placementPose) {
+
+            if (!this._gotFirstHitTestResult) {
+                this._gotFirstHitTestResult = true;
+                this.dispatchEvent(new CustomEvent('canPlaceSession', { detail: { pose: pose } }));
+            }
+
             if (this._isTouching) {
+                // callbacks
+                this.dispatchEvent(new CustomEvent('placedSession', { detail: { pose: pose } }));
+
                 if (this.webAR) this.webAR.setReticleActive(false);
                 this.placeAt(rig, new Matrix4().fromArray(pose.transform.matrix).invert());
                 return true;

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

@@ -12,12 +12,13 @@ export function apply(object: Object3D) {
     }
 }
 
-
-
-// do we still need this?
 Object3D.prototype["SetActive"] = function (active: boolean) {
     this.visible = active;
 }
+// e.g. when called via a UnityEvent
+Object3D.prototype["setActive"] = function (active: boolean) {
+    this.visible = active;
+}
 
 Object3D.prototype["addNewComponent"] = function <T extends Component>(type: ConstructorConcrete<T>) {
     return addNewComponent(this, new type());
@@ -67,6 +68,13 @@ if (!Object.getOwnPropertyDescriptor(Object3D.prototype, "activeSelf")) {
     });
 }
 
+if (!Object.getOwnPropertyDescriptor(Object3D.prototype, "transform")) {
+    Object.defineProperty(Object3D.prototype, "transform", {
+        get: function () {
+            return this;
+        }
+    });
+}