@needle-tools/engine 2.24.0-pre

package/src/engine-components/XRFlag.ts

@@ -0,0 +1,134 @@
+import { BufferAttribute } from "three";
+import { registerComponent } from "../engine/engine_components";
+import { Behaviour, GameObject } from "./Component";
+import * as utils from "../engine/engine_utils";
+const debug = utils.getParam("debugflags");
+
+export enum XRStateFlag {
+    Never = 0,
+    Browser = 1 << 0,
+    AR = 1 << 1,
+    VR = 1 << 2,
+    FirstPerson = 1 << 3,
+    ThirdPerson = 1 << 4,
+}
+
+// console.log(XRStateFlag);
+
+export class XRState {
+
+    public static Global: XRState = new XRState();
+
+    public Mask: XRStateFlag = XRStateFlag.Browser | XRStateFlag.ThirdPerson;
+
+    public Has(state: XRStateFlag) {
+
+        const res = (this.Mask & state);
+        if (debug) console.log("HAS", state, this.Mask, "Result=" + res);
+        return res !== 0;
+    }
+
+    public Set(state: number) {
+        this.Mask = state as number;
+        XRFlag.Apply();
+    }
+
+    public Enable(state: number) {
+        this.Mask |= state;
+        XRFlag.Apply();
+    }
+
+    public Disable(state: number) {
+        this.Mask &= ~state;
+        XRFlag.Apply();
+    }
+
+    public Toggle(state: number) {
+        this.Mask ^= state;
+        XRFlag.Apply();
+    }
+
+    public EnableAll() {
+        this.Mask = 0xffffffff | 0;
+        XRFlag.Apply();
+    }
+
+    public DisableAll() {
+        this.Mask = 0;
+        XRFlag.Apply();
+    }
+}
+
+export class XRFlag extends Behaviour {
+
+    private static registry: XRFlag[] = [];
+
+    public static Apply() {
+        for (const r of this.registry) r.UpdateVisible(XRState.Global);
+    }
+
+    private static firstApply: boolean;
+    private static buffer: XRState = new XRState();
+
+    awake(): void {
+        XRFlag.registry.push(this);
+    }
+
+    onEnable(): void {
+        if (!XRFlag.firstApply) {
+            XRFlag.firstApply = true;
+            XRFlag.Apply();
+        }
+    }
+
+    onDestroy(): void {
+        const i = XRFlag.registry.indexOf(this);
+        if (i >= 0)
+            XRFlag.registry.splice(i, 1);
+    }
+
+    public visibleIn!: number;
+
+    public get isOn(): boolean { return this.gameObject.visible; }
+
+    public UpdateVisible(state: XRState | XRStateFlag | null = null) {
+        if(!this.enabled) return;
+        let res: boolean | undefined = undefined;
+
+        const flag = state as number;
+        if (flag && typeof flag === "number") {
+            console.assert(typeof flag === "number", "XRFlag.UpdateVisible: state must be a number", flag);
+            if (debug)
+                console.log(flag);
+            XRFlag.buffer.Mask = flag;
+            state = XRFlag.buffer;
+        }
+
+        const st = state as XRState;
+        if (st) {
+            if (debug)
+                console.log("use passed in mask")
+            res = st.Has(this.visibleIn);
+        }
+        else {
+            if (debug)
+                console.log("use global mask")
+            XRState.Global.Has(this.visibleIn);
+        }
+        if (res === undefined) return;
+        if (res) {
+            if (debug)
+                console.trace("is visible", this.name, this.gameObject.uuid)
+            // this.gameObject.visible = true;
+            GameObject.setActive(this.gameObject, true);
+        } else {
+            if (debug)
+                console.trace("is not visible", this.name, this.gameObject.uuid);
+            const isVisible = this.gameObject.visible;
+            if(!isVisible) return;
+            this.gameObject.visible = false;
+            // console.trace("DISABLE", this.name);
+            // GameObject.setActive(this.gameObject, false);
+        }
+    }
+}

package/src/engine-components/avatar/AvatarBlink_Simple.ts

@@ -0,0 +1,68 @@
+import { Object3D } from "three";
+import { Behaviour, GameObject } from "../Component";
+import { XRFlag, XRState } from "../XRFlag";
+import { serializeable } from "../../engine/engine_serialization_decorator";
+
+
+export class AvatarBlink_Simple extends Behaviour {
+
+    @serializeable(Object3D)
+    private eyes: THREE.Object3D[] = [];
+    @serializeable()
+    private lastBlinkTime: number = 0;
+    @serializeable()
+    private blinkLength: number = 0;
+    @serializeable()
+    private eyesOpen: boolean = true;
+
+    private state : XRFlag | null = null;
+
+    awake(){
+        this.state = GameObject.getComponentInParent(this.gameObject, XRFlag);
+        // console.log(this.state, this.activeAndEnabled, this.gameObject);
+    }
+
+    public update() {
+        if (!this.gameObject || !this.gameObject.visible) return;
+        if(!this.eyes || !Array.isArray(this.eyes) || this.eyes.length === 0) return;
+
+        const needsUpdate = this.context.time.time - this.lastBlinkTime > this.blinkLength;
+
+        if (needsUpdate) {
+            this.lastBlinkTime = this.context.time.time;
+
+            // workaround until we propagate active state to all child components
+            if(this.state && !this.state.isOn) return;
+            if(!this.activeAndEnabled) return;
+
+            // console.log(this.state?.isOn, this.activeAndEnabled);
+
+            this.eyesOpen = !this.eyesOpen;
+            this.blinkLength = Math.random();
+            if (!this.eyesOpen) {
+                this.blinkLength *= Math.random() * .2;
+                this.blinkLength += .1;
+            }
+            else {
+                // eyes are open
+                this.blinkLength *= 3;
+                this.blinkLength += .5;
+                if (Math.random() < .1) this.blinkLength = .1 + Math.random() * .2;
+            }
+            if (Math.random() < .1) this.blinkLength *= 3;
+
+            // if(time.time - this.lastMouthChangeTime < .5 && Math.random() > .5){
+            //     this.blinkLength *= 1-(100/this.lastMouthChangeFrequency);
+            // }
+
+            this.blinkLength = Math.max(.2, this.blinkLength);
+            this.blinkLength = Math.min(3, this.blinkLength);
+            if (this.eyes) {
+                for (const eye of this.eyes) {
+                    if (eye)
+                        eye.visible = this.eyesOpen;
+                }
+            }
+        }
+    }
+}

package/src/engine-components/avatar/AvatarEyeLook_Rotation.ts

@@ -0,0 +1,69 @@
+import { Behaviour, GameObject } from "../Component";
+import * as utils from "../../engine/engine_three_utils"
+import * as THREE from "three";
+import { Avatar_Brain_LookAt } from "./Avatar_Brain_LookAt";
+import { serializeable } from "../../engine/engine_serialization_decorator";
+import { Object3D } from "three";
+
+export class AvatarEyeLook_Rotation extends Behaviour {
+
+    @serializeable(Object3D)
+    public head: GameObject | null = null;
+    @serializeable(Object3D)
+    public eyes: GameObject[] | null = null;
+    @serializeable(Object3D)
+    public target: THREE.Object3D | null = null;
+
+    private brain: Avatar_Brain_LookAt | null = null;
+
+    awake(): void {
+        // console.log(this);
+        if (!this.brain) {
+            this.brain = GameObject.getComponentInParent(this.gameObject, Avatar_Brain_LookAt);
+        }
+        if (!this.brain) {
+            console.log("No look at brain found, adding it now")
+            this.brain = GameObject.addNewComponent(this.gameObject, Avatar_Brain_LookAt);
+        }
+        if (this.brain && this.target) {
+            this.brain.controlledTarget = this.target;
+        }
+        // console.log(this);
+        // if(this.head){
+        //     this.head.add(new THREE.AxesHelper(1));
+        // }
+    }
+
+
+    private vec: THREE.Vector3 = new THREE.Vector3();
+    private static forward: THREE.Vector3 = new THREE.Vector3(0, 0, 1);
+    private currentTargetPoint: THREE.Vector3 = new THREE.Vector3();
+
+    update(): void {
+        // if(!this.activeAndEnabled) return;
+        const target = this.target;
+        // console.log(target);
+        if (target && this.head) {
+            const eyes = this.eyes;
+            if (eyes) {
+                const worldTarget = utils.getWorldPosition(target);
+                this.currentTargetPoint.lerp(worldTarget, this.context.time.deltaTime / .1);
+
+                const headPosition = utils.getWorldPosition(this.head);
+                const direction = this.vec.copy(this.currentTargetPoint).sub(headPosition).normalize();
+                if (direction.length() < .1) return;
+                const forward = AvatarEyeLook_Rotation.forward;
+                forward.set(0, 0, 1);
+                forward.applyQuaternion(utils.getWorldQuaternion(this.head));
+                const dot = forward.dot(direction);
+                if (dot > .45) {
+                    // console.log(dot);
+                    for (let i = 0; i < eyes.length; i++) {
+                        const eye = eyes[i];
+                        eye.lookAt(this.currentTargetPoint);
+                    }
+                }
+            }
+        }
+    }
+}

package/src/engine-components/avatar/Avatar_Brain_LookAt.ts

@@ -0,0 +1,137 @@
+import * as THREE from "three";
+import { TypeStore } from "../../engine/engine_typestore";
+import { Behaviour, GameObject } from "../Component";
+import { AvatarMarker } from "../WebXRAvatar";
+import * as utils from "../../engine/engine_three_utils";
+import { IModel, OwnershipModel } from "../../engine/engine_networking";
+import { Int8BufferAttribute } from "three";
+import { Context } from "../../engine/engine_setup";
+
+export class Avatar_POI {
+
+    public static Pois: { obj: THREE.Object3D, avatar: AvatarMarker | null }[] = [];
+    public static LastChangeTime: number = 0;
+
+    public static Add(context: Context, obj: THREE.Object3D, ignoredBy: AvatarMarker | null = null) {
+        if (!obj) return;
+        for (const e of this.Pois) {
+            if (e.obj === obj) return;
+        }
+        this.Pois.push({ obj: obj, avatar: ignoredBy });
+        this.LastChangeTime = context.time.time;
+        // console.log("Added", obj?.name);
+    }
+
+    public static Remove(context: Context | null, obj: THREE.Object3D | null) {
+
+        if (!obj) return;
+        for (const e of this.Pois) {
+            if (e.obj === obj) {
+                this.Pois.splice(this.Pois.indexOf(e), 1);
+                this.LastChangeTime = context?.time.time ?? Context.Current?.time.time;
+                // console.log("Removed", obj?.name);
+                return;
+            }
+        }
+    }
+}
+
+enum NetworkEvents {
+    TargetChanged = "avatar-look-target-changed"
+}
+
+class TargetModel implements IModel {
+    public guid!: string;
+    public position: THREE.Vector3 = new THREE.Vector3();
+}
+
+export class Avatar_Brain_LookAt extends Behaviour {
+
+    public set controlledTarget(target: THREE.Object3D) {
+        this.target = target;
+        // HACK
+        const r = TypeStore.get("MoveRandom");
+        if (r && this.target) {
+            const rm = GameObject.getComponent(this.target, r) as Behaviour;
+            if (rm) {
+                rm.destroy();
+            }
+        }
+
+        // this.target.add(new THREE.AxesHelper(.1));
+    }
+
+    // that target to copy positions into
+    private target: THREE.Object3D | null = null;
+
+    private avatar: AvatarMarker | null = null;
+    private _model: OwnershipModel | null = null;
+    private _targetModel: TargetModel = new TargetModel();
+    private _currentTargetObject: THREE.Object3D | null = null;
+    private _lastUpdateTime: number = 0;
+    private _lookDuration: number = 0;
+    private _lastPoiChangedTime: number = 0;
+
+    awake(): void {
+        this.avatar = GameObject.getComponentInParent(this.gameObject, AvatarMarker);
+
+        if (this.avatar) {
+            const marker = GameObject.getComponentInParent(this.gameObject, AvatarMarker);
+            this._model = new OwnershipModel(this.context.connection, this.guid);
+            if (marker?.isLocalAvatar) {
+                this._model.requestOwnership();
+            }
+        }
+
+        this.context.connection.beginListen(NetworkEvents.TargetChanged, (cb: TargetModel) => {
+            if (this.target && cb && cb.guid === this.avatar?.guid) {
+                utils.setWorldPosition(this.target, cb.position);
+            }
+        });
+
+        // console.log(this);
+    }
+
+    update(): void {
+        const connected = this.context.connection.isConnected;
+        if (!connected || this._model?.hasOwnership) {
+
+            if (Avatar_POI.LastChangeTime !== this._lastPoiChangedTime) {
+                this._lastPoiChangedTime = Avatar_POI.LastChangeTime;
+                this._lookDuration = 0;
+            }
+
+            this.selectTarget();
+
+            // send target info
+            if (this._currentTargetObject && this.context.time.frameCount % 10 === 0 && this.target) {
+                const wp = utils.getWorldPosition(this._currentTargetObject);
+                utils.setWorldPosition(this.target, wp);
+
+                if (this.context.connection.isConnected && this.avatar) {
+                    this.context.connection.send(NetworkEvents.TargetChanged, this._targetModel);
+                    this._targetModel.guid = this.avatar.guid;
+                    this._targetModel.position.copy(wp);
+                }
+            }
+        }
+    }
+
+    private selectTarget() {
+        // select random target
+        const td = this.context.time.time - this._lastUpdateTime;
+        if (td > this._lookDuration) {
+            this._lastUpdateTime = this.context.time.time;
+            this._lookDuration = Math.random() * .5 + .2;
+            const pois = Avatar_POI.Pois;
+            if (pois.length > 0) {
+                const poi = pois[Math.floor(Math.random() * pois.length)];
+                if (poi && poi.obj) {
+                    if (poi.avatar && poi.avatar === this.avatar) return;
+                    this._currentTargetObject = poi.obj;
+                    // console.log(this._currentTargetObject);
+                }
+            }
+        }
+    }
+}

package/src/engine-components/avatar/Avatar_MouthShapes.ts

@@ -0,0 +1,81 @@
+import { Behaviour, GameObject } from "../Component";
+import { Voip } from "../Voip";
+import { AvatarMarker } from "../WebXRAvatar";
+import * as utils from "../../engine/engine_utils";
+import { Object3D } from "three";
+import { serializeable } from "../../engine/engine_serialization_decorator";
+
+const debug = utils.getParam("debugmouth");
+
+export class Avatar_MouthShapes extends Behaviour {
+    @serializeable(Object3D)
+    public idle: THREE.Object3D[] = [];
+    @serializeable(Object3D)
+    public talking: THREE.Object3D[] = [];
+
+    private marker: AvatarMarker | null = null;
+    private voip: Voip | null = null;
+    private lastMouthChangeTime = 0;
+    private mouthChangeLength = 0;
+
+    awake(): void {
+        this.voip = GameObject.findObjectOfType(Voip, this.context);
+        console.log(this);
+    }
+
+    update(): void {
+        if (!this.voip) return;
+        if (this.context.time.frameCount % 10 !== 0) return;
+        let id = this.marker?.connectionId ?? null;
+        if (!id) {
+            if (debug) id = null;
+        }
+        const freq = this.voip.getFrequency(id);
+        if (freq == null) return;
+        this.updateLips(freq);
+    }
+
+    private updateLips(frequency: number) {
+        if (this.context.time.time - this.lastMouthChangeTime > this.mouthChangeLength) {
+            this.mouthChangeLength = .05 + Math.random() * .1;
+            if (this.talking && this.talking.length > 0 && frequency > 50) {
+                this.lastMouthChangeTime = this.context.time.time;
+                const index = Math.floor(Math.random() * this.talking.length);
+                this.setMouthShapeActive(this.talking, index);
+            }
+            else if (this.idle.length > 0 && this.context.time.time - this.lastMouthChangeTime > .5) {
+                this.lastMouthChangeTime = this.context.time.time;
+                const index = Math.floor(Math.random() * this.idle.length);
+                this.setMouthShapeActive(this.idle, index);
+            }
+        }
+    }
+
+    private setMouthShapeActive(arr: THREE.Object3D[], index: number) {
+        if (!arr) return;
+
+        // hide other
+        if(arr != this.idle) this.idle.map(i => i.visible = false);
+        else this.talking.map(i => i.visible = false);
+
+        for (let i = 0; i < arr.length; i++) {
+            const shape = arr[i];
+            if (shape) {
+                shape.visible = i === index;
+                shape.scale.set(1,1,1);
+            }
+        }
+    }
+
+    // private tryFindMouthShapes() {
+    //     if (this.mouthShapes) return;
+    //     this.mouthShapes = [];
+    //     this.head?.traverse(o => {
+    //         if (o && o.type === "Mesh") {
+    //             if (o.name.lastIndexOf("mouth") > 0) {
+    //                 this.mouthShapes.push(o as THREE.Mesh);
+    //             }
+    //         }
+    //     });
+    // }
+}

package/src/engine-components/avatar/Avatar_MustacheShake.ts

@@ -0,0 +1,29 @@
+import { Behaviour, GameObject } from "../Component";
+import { Voip } from "../Voip";
+import { AvatarMarker } from "../WebXRAvatar";
+
+export class Avatar_MustacheShake extends Behaviour {
+    private voip: Voip | null = null;
+    private marker: AvatarMarker | null = null;
+
+    private _startPosition : THREE.Vector3 | null = null;
+
+    awake() {
+        this.voip = GameObject.findObjectOfType(Voip, this.context);
+        this.marker = GameObject.getComponentInParent(this.gameObject, AvatarMarker);
+        // console.log(this);
+    }
+
+    update() {
+        if (!this.voip || !this.marker) return;
+        if(this.context.time.frameCount % 10 !== 0) return;
+        const id = this.marker.connectionId;
+        const freq = this.voip.getFrequency(id);
+        if(freq == null) return;
+        if(!this._startPosition) {
+            this._startPosition = this.gameObject.position.clone();
+        }
+        let t = freq / 100;
+        this.gameObject.position.y = this._startPosition.y + t * 0.07;
+    }
+}

package/src/engine-components/codegen/exports.ts

@@ -0,0 +1,141 @@
+// Export types
+export { AlignmentConstraint } from "../AlignmentConstraint";
+export { Animation } from "../Animation";
+export { AnimationCurve } from "../AnimationCurve";
+export { Animator } from "../Animator";
+export { AnimatorController } from "../AnimatorController";
+export { AudioListener } from "../AudioListener";
+export { AudioSource } from "../AudioSource";
+export { AvatarModel } from "../AvatarLoader";
+export { AvatarLoader } from "../AvatarLoader";
+export { AxesHelper } from "../AxesHelper";
+export { BasicIKConstraint } from "../BasicIKConstraint";
+export { BoxHelperComponent } from "../BoxHelperComponent";
+export { Camera } from "../Camera";
+export { Collider } from "../Collider";
+export { SphereCollider } from "../Collider";
+export { BoxCollider } from "../Collider";
+export { InstantiateOptions } from "../Component";
+export { UnityObject } from "../ComponentExtensions";
+export { DeleteBox } from "../DeleteBox";
+export { Deletable } from "../DeleteBox";
+export { DeviceFlag } from "../DeviceFlag";
+export { DragControls } from "../DragControls";
+export { DropListener } from "../DropListener";
+export { Duplicatable } from "../Duplicatable";
+export { CallInfo } from "../EventList";
+export { EventListEvent } from "../EventList";
+export { EventList } from "../EventList";
+export { EventTrigger } from "../EventTrigger";
+export { FlyControls } from "../FlyControls";
+export { BoxGizmo } from "../Gizmos";
+export { GltfExportBox } from "../GltfExport";
+export { GltfExport } from "../GltfExport";
+export { GridHelper } from "../GridHelper";
+export { GroundProjectedEnv } from "../GroundProjection";
+export { Interactable } from "../Interactable";
+export { UsageMarker } from "../Interactable";
+export { Light } from "../Light";
+export { LODModel } from "../LODGroup";
+export { LODGroup } from "../LODGroup";
+export { LookAtConstraint } from "../LookAtConstraint";
+export { MeshCollider } from "../MeshCollider";
+export { NavMesh } from "../NavMesh";
+export { NavMeshAgent } from "../NavMesh";
+export { NestedGltf } from "../NestedGltf";
+export { Networking } from "../Networking";
+export { OffsetConstraint } from "../OffsetConstraint";
+export { OrbitControls } from "../OrbitControls";
+export { ParticleSystemRenderer } from "../ParticleSystem";
+export { ParticleSystem } from "../ParticleSystem";
+export { MainModule } from "../ParticleSystemModules";
+export { EmissionModule } from "../ParticleSystemModules";
+export { ShapeModule } from "../ParticleSystemModules";
+export { PlayerColor } from "../PlayerColor";
+export { FieldWithDefault } from "../Renderer";
+export { Renderer } from "../Renderer";
+export { MeshRenderer } from "../Renderer";
+export { SkinnedMeshRenderer } from "../Renderer";
+export { InstancingUtil } from "../Renderer";
+export { RendererLightmap } from "../RendererLightmap";
+export { Rigidbody } from "../RigidBody";
+export { ScreenCapture } from "../ScreenCapture";
+export { ShadowCatcher } from "../ShadowCatcher";
+export { RemoteSkybox } from "../Skybox";
+export { SmoothFollow } from "../SmoothFollow";
+export { SpatialTriggerReceiver } from "../SpatialTrigger";
+export { SpatialTrigger } from "../SpatialTrigger";
+export { SpectatorCamera } from "../SpectatorCamera";
+export { SpringJoint } from "../SpringJoint";
+export { Sprite } from "../SpriteRenderer";
+export { SpriteRenderer } from "../SpriteRenderer";
+export { SyncedCamera } from "../SyncedCamera";
+export { SyncedRoom } from "../SyncedRoom";
+export { SyncedTransform } from "../SyncedTransform";
+export { TestRunner } from "../TestRunner";
+export { TestSimulateUserData } from "../TestRunner";
+export { TransformGizmo } from "../TransformGizmo";
+export { VideoPlayer } from "../VideoPlayer";
+export { Voip } from "../Voip";
+export { VolumeParameter } from "../Volume";
+export { VolumeComponent } from "../Volume";
+export { ToneMapping } from "../Volume";
+export { ColorAdjustments } from "../Volume";
+export { VolumeProfile } from "../Volume";
+export { Volume } from "../Volume";
+export { WebARSessionRoot } from "../WebARSessionRoot";
+export { WebXR } from "../WebXR";
+export { WebAR } from "../WebXR";
+export { AvatarMarker } from "../WebXRAvatar";
+export { WebXRAvatar } from "../WebXRAvatar";
+export { TeleportTarget } from "../WebXRController";
+export { WebXRController } from "../WebXRController";
+export { AttachedObject } from "../WebXRController";
+export { XRGrabModel } from "../WebXRGrabRendering";
+export { XRGrabRendering } from "../WebXRGrabRendering";
+export { XRRig } from "../WebXRRig";
+export { VRUserState } from "../WebXRSync";
+export { WebXRSync } from "../WebXRSync";
+export { XRState } from "../XRFlag";
+export { XRFlag } from "../XRFlag";
+export { AvatarBlink_Simple } from "../avatar/AvatarBlink_Simple";
+export { AvatarEyeLook_Rotation } from "../avatar/AvatarEyeLook_Rotation";
+export { Avatar_POI } from "../avatar/Avatar_Brain_LookAt";
+export { Avatar_Brain_LookAt } from "../avatar/Avatar_Brain_LookAt";
+export { Avatar_MouthShapes } from "../avatar/Avatar_MouthShapes";
+export { Avatar_MustacheShake } from "../avatar/Avatar_MustacheShake";
+export { LogStats } from "../debug/LogStats";
+export { RGBAColor } from "../js-extensions/RGBAColor";
+export { PlayableDirector } from "../timeline/PlayableDirector";
+export { SignalAsset } from "../timeline/SignalAsset";
+export { SignalReceiverEvent } from "../timeline/SignalAsset";
+export { SignalReceiver } from "../timeline/SignalAsset";
+export { AnimationTrackHandler } from "../timeline/TimelineTracks";
+export { AudioTrackHandler } from "../timeline/TimelineTracks";
+export { SignalTrackHandler } from "../timeline/TimelineTracks";
+export { ControlTrackHandler } from "../timeline/TimelineTracks";
+export { BaseUIComponent } from "../ui/BaseUIComponent";
+export { UIRootComponent } from "../ui/BaseUIComponent";
+export { Button } from "../ui/Button";
+export { Canvas } from "../ui/Canvas";
+export { CanvasGroup } from "../ui/CanvasGroup";
+export { EventSystem } from "../ui/EventSystem";
+export { Graphic } from "../ui/Graphic";
+export { MaskableGraphic } from "../ui/Graphic";
+export { Image } from "../ui/Image";
+export { RawImage } from "../ui/Image";
+export { InputField } from "../ui/InputField";
+export { Keyboard } from "../ui/Keyboard";
+export { LayoutGroup } from "../ui/Layout";
+export { VerticalLayoutGroup } from "../ui/Layout";
+export { HorizontalLayoutGroup } from "../ui/Layout";
+export { GridLayoutGroup } from "../ui/Layout";
+export { PointerEventData } from "../ui/PointerEvents";
+export { Raycaster } from "../ui/Raycaster";
+export { ObjectRaycaster } from "../ui/Raycaster";
+export { GraphicRaycaster } from "../ui/Raycaster";
+export { Size } from "../ui/RectTransform";
+export { Rect } from "../ui/RectTransform";
+export { RectTransform } from "../ui/RectTransform";
+export { SpatialHtml } from "../ui/SpatialHtml";
+export { Text } from "../ui/Text";

package/src/engine-components/debug/LogStats.ts

@@ -0,0 +1,22 @@
+import { Behaviour } from "../../engine-components/Component";
+import { FrameEvent } from "../../engine/engine_setup";
+import { getParam } from "../../engine/engine_utils";
+
+const debug = getParam("logstats");
+
+export class LogStats extends Behaviour {
+
+    onEnable(): void {
+        console.log(this);
+        if (debug)
+            this.startCoroutine(this.run(), FrameEvent.OnAfterRender);
+    }
+
+    *run() {
+        while(this.enabled){
+            const info = this.context.renderer.info;
+            console.log(info.memory, info.render, info.programs);
+            yield;
+        }
+    }
+}