@directivegames/genesys.js 3.1.24

package/src/systems/ClassRegistry.ts

@@ -0,0 +1,484 @@
+/**
+ * ClassRegistry maps string identifiers to constructors used by the engine.
+ *
+ * Detailed explanation:
+ * - Supports registration of engine classes, game classes, and built-in THREE.js types.
+ * - Enables dynamic object creation and serialization by storing a prefix-qualified name for each constructor.
+ * - Maintains reverse lookups so objects can report their registered names for export or debugging.
+ *
+ * Recommended usage (for humans and AI assistants):
+ * - Call `registerEngineClass` or `registerGameClass` from decorators or setup code.
+ * - Use `constructObject` when you have a string type name and need an instance at runtime.
+ * - Avoid modifying the registry after gameplay begins unless performing hot reload of game code.
+ */
+import * as THREE from 'three';
+
+export enum Prefix {
+  ENGINE = 'ENGINE.',
+  GAME = 'GAME.',
+  THREE = 'THREE.',
+}
+
+export type Constructor<T = any> = (new (...args: any[]) => T) & { prototype: T };
+
+function isConstructor(fn: any): fn is new (...args: any[]) => any {
+  return typeof fn === 'function' && fn.prototype && fn.prototype.constructor === fn;
+}
+
+/**
+ * Registry for managing and accessing class constructors across the engine.
+ * Provides functionality to register, retrieve, and instantiate classes from different sources.
+ */
+export class ClassRegistry {
+  private static registry: Map<string, Constructor> = new Map();
+  private static reverseRegistry: Map<Constructor, string> = new Map();
+  private static builtInClassesRegistered = false;
+  private static redirectorMap: Map<string, string> = new Map();  // 'Engine.OldClass -> Engine.NewClass'
+
+  /**
+   * Registers a class as an engine component.
+   * @param constructor - The class constructor to register
+   */
+  public static registerEngineClass(constructor: Constructor, className?: string): void {
+    this.registerClass(Prefix.ENGINE, constructor, className);
+  }
+
+  /**
+   * Registers a class as a game component.
+   * @param constructor - The class constructor to register
+   */
+  public static registerGameClass(constructor: Constructor): void {
+    this.registerClass(Prefix.GAME, constructor);
+  }
+
+
+  public static addClassesToRedirect(classes: Record<string, string>) {
+    for (const [k, v] of Object.entries(classes)) {
+      this.redirectorMap.set(k, v);
+    }
+  }
+
+  /**
+   * Get the registry as a readonly map.
+   * @returns The registry as a readonly map
+   */
+  public static getRegistry(): ReadonlyMap<string, Constructor> {
+    return this.registry;
+  }
+
+  /**
+   * Retrieves a class constructor by its full name.
+   * @param fullName - The full name of the class (including prefix)
+   * @returns The class constructor
+   * @throws Error if the class is not found in the registry
+   */
+  public static getClass<T = any>(fullName: string): Constructor<T> {
+    this.registerBuiltInClasses();
+    fullName = this.redirectorMap.get(fullName) ?? fullName;
+    const classConstructor = this.registry.get(fullName);
+    if (!classConstructor) {
+      throw new Error(`Class ${fullName} not found in registry`);
+    }
+    return classConstructor;
+  }
+
+  /**
+   * Removes all game classes from the registry.
+   * Used when reloading game code to prevent stale references.
+   */
+  public static clearGameClasses(): void {
+    for (const [key, value] of this.registry.entries()) {
+      if (key.startsWith(Prefix.GAME)) {
+        this.registry.delete(key);
+        this.reverseRegistry.delete(value);
+      }
+    }
+  }
+
+  /**
+   * Creates a new instance of a registered class.
+   * @param className - The full name of the class to instantiate
+   * @param isDeserializing - Whether the object is being deserialized
+   * @param args - Arguments to pass to the constructor
+   * @returns A new instance of the specified class
+   */
+  public static constructObject(className: string, isDeserializing: boolean, ...args: any[]): any {
+    const constructor = this.getClass(className);
+    if (args.length === 1) {
+      const firstArg = args[0];
+      if (Array.isArray(firstArg)) {
+        // Support: constructObject('Foo', [1, 2, 3])
+        return new constructor(...firstArg);
+      }
+      if (typeof firstArg === 'object') {
+        // Support: constructObject('Foo', { config: 123 })
+
+        // Check if this is a THREE.js class - they don't accept unknown properties
+        if (className.startsWith(Prefix.THREE)) {
+          // For THREE.js objects, don't add __isDeserializing to avoid parameter validation errors
+          return new constructor(firstArg);
+        }
+
+        // For engine/game classes, add the __isDeserializing flag
+        const options = { ...firstArg, __isDeserializing: isDeserializing };
+        const object = new constructor(options);
+        // 'options' is normally saved and serialized by the object so we need to clear the __isDeserializing flag to prevent it from getting saved
+        options.__isDeserializing = undefined;
+        return object;
+      }
+    }
+    return new constructor(...args);
+  }
+
+  /**
+   * Retrieves the class name of an object or its constructor.
+   * @param object - The object to get the class name from
+   * @returns The class name of the object or its constructor
+   */
+  public static getClassOrConstructorName(object: any): string {
+    return this.getClassName(object)?.split('.').pop() ?? object.constructor.name;
+  }
+
+  /**
+   * Retrieves the full name of a class from its constructor.
+   * @param object - The object to get the class name from
+   * @returns The full name of the class or null if not found
+   */
+  public static getClassName(object: any): string | null {
+    this.registerBuiltInClasses();
+
+    // First try direct constructor lookup
+    const directLookup = this.reverseRegistry.get(object.constructor);
+    if (directLookup) return directLookup;
+
+    // Fallback to name-based lookup if direct lookup fails
+    const constructorName = object.constructor?.name;
+    if (!constructorName) return null;
+
+    // Search through registry for matching class name
+    for (const [fullName, constructor] of this.registry.entries()) {
+      if (constructor.name === constructorName) {
+        // Update reverse registry for future lookups
+        this.reverseRegistry.set(object.constructor, fullName);
+        return fullName;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Retrieves the full name of a class from its constructor.
+   * @param object - The object to get the class name from
+   * @returns The full name of the class
+   * @throws Error if the class is not found in the registry
+   */
+  public static getClassNameChecked(object: any): string {
+    const className = this.getClassName(object);
+    if (!className) {
+      throw new Error(`Class ${object.constructor.name} not found in registry`);
+    }
+    return className;
+  }
+
+  /**
+   * Searches for a registered class by its constructor name.
+   * @param constructorName - The name of the constructor to search for
+   * @returns The full registered name (e.g., "ENGINE.MeshComponent") or null if not found
+   */
+  public static getClassNameByConstructorName(constructorName: string): string | null {
+    this.registerBuiltInClasses();
+
+    for (const registeredName of this.registry.keys()) {
+      if (registeredName.endsWith(`.${constructorName}`) || registeredName === constructorName) {
+        return registeredName;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Retrieves a class constructor by its constructor name.
+   * Useful for hot reload scenarios where you need to find the fresh constructor.
+   * @param constructorName - The name of the constructor to search for
+   * @returns The class constructor or null if not found
+   */
+  public static getClassByConstructorName<T = any>(constructorName: string): Constructor<T> | null {
+    const fullName = this.getClassNameByConstructorName(constructorName);
+    if (!fullName) {
+      return null;
+    }
+    return this.registry.get(fullName) as Constructor<T>;
+  }
+
+  /*
+  * Registers all built-in classes in the THREE namespace.
+  * This method should only be called once during engine initialization.
+  */
+  public static registerBuiltInClasses(): void {
+    if (this.builtInClassesRegistered) {
+      return;
+    }
+
+    if (1) {
+      this.registerClass(Prefix.THREE, THREE.AmbientLight, 'AmbientLight');
+      this.registerClass(Prefix.THREE, THREE.AnimationAction, 'AnimationAction');
+      this.registerClass(Prefix.THREE, THREE.AnimationClip, 'AnimationClip');
+      this.registerClass(Prefix.THREE, THREE.AnimationLoader, 'AnimationLoader');
+      this.registerClass(Prefix.THREE, THREE.AnimationMixer, 'AnimationMixer');
+      this.registerClass(Prefix.THREE, THREE.AnimationObjectGroup, 'AnimationObjectGroup');
+      this.registerClass(Prefix.THREE, THREE.AnimationUtils, 'AnimationUtils');
+      this.registerClass(Prefix.THREE, THREE.ArcCurve, 'ArcCurve');
+      this.registerClass(Prefix.THREE, THREE.ArrayCamera, 'ArrayCamera');
+      this.registerClass(Prefix.THREE, THREE.ArrowHelper, 'ArrowHelper');
+      this.registerClass(Prefix.THREE, THREE.Audio, 'Audio');
+      this.registerClass(Prefix.THREE, THREE.AudioAnalyser, 'AudioAnalyser');
+      this.registerClass(Prefix.THREE, THREE.AudioListener, 'AudioListener');
+      this.registerClass(Prefix.THREE, THREE.AudioLoader, 'AudioLoader');
+      this.registerClass(Prefix.THREE, THREE.AxesHelper, 'AxesHelper');
+      this.registerClass(Prefix.THREE, THREE.BatchedMesh, 'BatchedMesh');
+      this.registerClass(Prefix.THREE, THREE.Bone, 'Bone');
+      this.registerClass(Prefix.THREE, THREE.BooleanKeyframeTrack, 'BooleanKeyframeTrack');
+      this.registerClass(Prefix.THREE, THREE.Box2, 'Box2');
+      this.registerClass(Prefix.THREE, THREE.Box3, 'Box3');
+      this.registerClass(Prefix.THREE, THREE.Box3Helper, 'Box3Helper');
+      this.registerClass(Prefix.THREE, THREE.BoxGeometry, 'BoxGeometry');
+      this.registerClass(Prefix.THREE, THREE.BoxHelper, 'BoxHelper');
+      this.registerClass(Prefix.THREE, THREE.BufferAttribute, 'BufferAttribute');
+      this.registerClass(Prefix.THREE, THREE.BufferGeometry, 'BufferGeometry');
+      this.registerClass(Prefix.THREE, THREE.BufferGeometryLoader, 'BufferGeometryLoader');
+      this.registerClass(Prefix.THREE, THREE.Camera, 'Camera');
+      this.registerClass(Prefix.THREE, THREE.CameraHelper, 'CameraHelper');
+      this.registerClass(Prefix.THREE, THREE.CanvasTexture, 'CanvasTexture');
+      this.registerClass(Prefix.THREE, THREE.CapsuleGeometry, 'CapsuleGeometry');
+      this.registerClass(Prefix.THREE, THREE.CatmullRomCurve3, 'CatmullRomCurve3');
+      this.registerClass(Prefix.THREE, THREE.CircleGeometry, 'CircleGeometry');
+      this.registerClass(Prefix.THREE, THREE.Clock, 'Clock');
+      this.registerClass(Prefix.THREE, THREE.Color, 'Color');
+      this.registerClass(Prefix.THREE, THREE.ColorKeyframeTrack, 'ColorKeyframeTrack');
+      this.registerClass(Prefix.THREE, THREE.CompressedArrayTexture, 'CompressedArrayTexture');
+      this.registerClass(Prefix.THREE, THREE.CompressedCubeTexture, 'CompressedCubeTexture');
+      this.registerClass(Prefix.THREE, THREE.CompressedTexture, 'CompressedTexture');
+      this.registerClass(Prefix.THREE, THREE.CompressedTextureLoader, 'CompressedTextureLoader');
+      this.registerClass(Prefix.THREE, THREE.ConeGeometry, 'ConeGeometry');
+      this.registerClass(Prefix.THREE, THREE.CubeCamera, 'CubeCamera');
+      this.registerClass(Prefix.THREE, THREE.CubeTexture, 'CubeTexture');
+      this.registerClass(Prefix.THREE, THREE.CubeTextureLoader, 'CubeTextureLoader');
+      this.registerClass(Prefix.THREE, THREE.CubicBezierCurve, 'CubicBezierCurve');
+      this.registerClass(Prefix.THREE, THREE.CubicBezierCurve3, 'CubicBezierCurve3');
+      this.registerClass(Prefix.THREE, THREE.CubicInterpolant, 'CubicInterpolant');
+      this.registerClass(Prefix.THREE, THREE.CurvePath, 'CurvePath');
+      this.registerClass(Prefix.THREE, THREE.CylinderGeometry, 'CylinderGeometry');
+      this.registerClass(Prefix.THREE, THREE.Cylindrical, 'Cylindrical');
+      this.registerClass(Prefix.THREE, THREE.Data3DTexture, 'Data3DTexture');
+      this.registerClass(Prefix.THREE, THREE.DataArrayTexture, 'DataArrayTexture');
+      this.registerClass(Prefix.THREE, THREE.DataTexture, 'DataTexture');
+      this.registerClass(Prefix.THREE, THREE.DataTextureLoader, 'DataTextureLoader');
+      this.registerClass(Prefix.THREE, THREE.DepthTexture, 'DepthTexture');
+      this.registerClass(Prefix.THREE, THREE.DirectionalLight, 'DirectionalLight');
+      this.registerClass(Prefix.THREE, THREE.DirectionalLightHelper, 'DirectionalLightHelper');
+      this.registerClass(Prefix.THREE, THREE.DiscreteInterpolant, 'DiscreteInterpolant');
+      this.registerClass(Prefix.THREE, THREE.DodecahedronGeometry, 'DodecahedronGeometry');
+      this.registerClass(Prefix.THREE, THREE.EdgesGeometry, 'EdgesGeometry');
+      this.registerClass(Prefix.THREE, THREE.EllipseCurve, 'EllipseCurve');
+      this.registerClass(Prefix.THREE, THREE.Euler, 'Euler');
+      this.registerClass(Prefix.THREE, THREE.EventDispatcher, 'EventDispatcher');
+      this.registerClass(Prefix.THREE, THREE.ExtrudeGeometry, 'ExtrudeGeometry');
+      this.registerClass(Prefix.THREE, THREE.FileLoader, 'FileLoader');
+      this.registerClass(Prefix.THREE, THREE.Float16BufferAttribute, 'Float16BufferAttribute');
+      this.registerClass(Prefix.THREE, THREE.Float32BufferAttribute, 'Float32BufferAttribute');
+      this.registerClass(Prefix.THREE, THREE.Fog, 'Fog');
+      this.registerClass(Prefix.THREE, THREE.FogExp2, 'FogExp2');
+      this.registerClass(Prefix.THREE, THREE.FramebufferTexture, 'FramebufferTexture');
+      this.registerClass(Prefix.THREE, THREE.Frustum, 'Frustum');
+      this.registerClass(Prefix.THREE, THREE.GLBufferAttribute, 'GLBufferAttribute');
+      this.registerClass(Prefix.THREE, THREE.GridHelper, 'GridHelper');
+      this.registerClass(Prefix.THREE, THREE.Group, 'Group');
+      this.registerClass(Prefix.THREE, THREE.HemisphereLight, 'HemisphereLight');
+      this.registerClass(Prefix.THREE, THREE.HemisphereLightHelper, 'HemisphereLightHelper');
+      this.registerClass(Prefix.THREE, THREE.IcosahedronGeometry, 'IcosahedronGeometry');
+      this.registerClass(Prefix.THREE, THREE.ImageBitmapLoader, 'ImageBitmapLoader');
+      this.registerClass(Prefix.THREE, THREE.ImageLoader, 'ImageLoader');
+      this.registerClass(Prefix.THREE, THREE.ImageUtils, 'ImageUtils');
+      this.registerClass(Prefix.THREE, THREE.InstancedBufferAttribute, 'InstancedBufferAttribute');
+      this.registerClass(Prefix.THREE, THREE.InstancedBufferGeometry, 'InstancedBufferGeometry');
+      this.registerClass(Prefix.THREE, THREE.InstancedInterleavedBuffer, 'InstancedInterleavedBuffer');
+      this.registerClass(Prefix.THREE, THREE.InstancedMesh, 'InstancedMesh');
+      this.registerClass(Prefix.THREE, THREE.Int16BufferAttribute, 'Int16BufferAttribute');
+      this.registerClass(Prefix.THREE, THREE.Int32BufferAttribute, 'Int32BufferAttribute');
+      this.registerClass(Prefix.THREE, THREE.Int8BufferAttribute, 'Int8BufferAttribute');
+      this.registerClass(Prefix.THREE, THREE.InterleavedBuffer, 'InterleavedBuffer');
+      this.registerClass(Prefix.THREE, THREE.InterleavedBufferAttribute, 'InterleavedBufferAttribute');
+      this.registerClass(Prefix.THREE, THREE.KeyframeTrack, 'KeyframeTrack');
+      this.registerClass(Prefix.THREE, THREE.LOD, 'LOD');
+      this.registerClass(Prefix.THREE, THREE.LatheGeometry, 'LatheGeometry');
+      this.registerClass(Prefix.THREE, THREE.Layers, 'Layers');
+      this.registerClass(Prefix.THREE, THREE.LightProbe, 'LightProbe');
+      this.registerClass(Prefix.THREE, THREE.Line, 'Line');
+      this.registerClass(Prefix.THREE, THREE.Line3, 'Line3');
+      this.registerClass(Prefix.THREE, THREE.LineBasicMaterial, 'LineBasicMaterial');
+      this.registerClass(Prefix.THREE, THREE.LineCurve, 'LineCurve');
+      this.registerClass(Prefix.THREE, THREE.LineCurve3, 'LineCurve3');
+      this.registerClass(Prefix.THREE, THREE.LineDashedMaterial, 'LineDashedMaterial');
+      this.registerClass(Prefix.THREE, THREE.LineLoop, 'LineLoop');
+      this.registerClass(Prefix.THREE, THREE.LineSegments, 'LineSegments');
+      this.registerClass(Prefix.THREE, THREE.LinearInterpolant, 'LinearInterpolant');
+      this.registerClass(Prefix.THREE, THREE.Loader, 'Loader');
+      this.registerClass(Prefix.THREE, THREE.LoaderUtils, 'LoaderUtils');
+      this.registerClass(Prefix.THREE, THREE.LoadingManager, 'LoadingManager');
+      this.registerClass(Prefix.THREE, THREE.Material, 'Material');
+      this.registerClass(Prefix.THREE, THREE.MaterialLoader, 'MaterialLoader');
+      this.registerClass(Prefix.THREE, THREE.Matrix2, 'Matrix2');
+      this.registerClass(Prefix.THREE, THREE.Matrix3, 'Matrix3');
+      this.registerClass(Prefix.THREE, THREE.Matrix4, 'Matrix4');
+      this.registerClass(Prefix.THREE, THREE.Mesh, 'Mesh');
+      this.registerClass(Prefix.THREE, THREE.MeshBasicMaterial, 'MeshBasicMaterial');
+      this.registerClass(Prefix.THREE, THREE.MeshDepthMaterial, 'MeshDepthMaterial');
+      this.registerClass(Prefix.THREE, THREE.MeshDistanceMaterial, 'MeshDistanceMaterial');
+      this.registerClass(Prefix.THREE, THREE.MeshLambertMaterial, 'MeshLambertMaterial');
+      this.registerClass(Prefix.THREE, THREE.MeshMatcapMaterial, 'MeshMatcapMaterial');
+      this.registerClass(Prefix.THREE, THREE.MeshNormalMaterial, 'MeshNormalMaterial');
+      this.registerClass(Prefix.THREE, THREE.MeshPhongMaterial, 'MeshPhongMaterial');
+      this.registerClass(Prefix.THREE, THREE.MeshPhysicalMaterial, 'MeshPhysicalMaterial');
+      this.registerClass(Prefix.THREE, THREE.MeshStandardMaterial, 'MeshStandardMaterial');
+      this.registerClass(Prefix.THREE, THREE.MeshToonMaterial, 'MeshToonMaterial');
+      this.registerClass(Prefix.THREE, THREE.NumberKeyframeTrack, 'NumberKeyframeTrack');
+      this.registerClass(Prefix.THREE, THREE.Object3D, 'Object3D');
+      this.registerClass(Prefix.THREE, THREE.ObjectLoader, 'ObjectLoader');
+      this.registerClass(Prefix.THREE, THREE.OctahedronGeometry, 'OctahedronGeometry');
+      this.registerClass(Prefix.THREE, THREE.OrthographicCamera, 'OrthographicCamera');
+      this.registerClass(Prefix.THREE, THREE.PMREMGenerator, 'PMREMGenerator');
+      this.registerClass(Prefix.THREE, THREE.Path, 'Path');
+      this.registerClass(Prefix.THREE, THREE.PerspectiveCamera, 'PerspectiveCamera');
+      this.registerClass(Prefix.THREE, THREE.Plane, 'Plane');
+      this.registerClass(Prefix.THREE, THREE.PlaneGeometry, 'PlaneGeometry');
+      this.registerClass(Prefix.THREE, THREE.PlaneHelper, 'PlaneHelper');
+      this.registerClass(Prefix.THREE, THREE.PointLight, 'PointLight');
+      this.registerClass(Prefix.THREE, THREE.PointLightHelper, 'PointLightHelper');
+      this.registerClass(Prefix.THREE, THREE.Points, 'Points');
+      this.registerClass(Prefix.THREE, THREE.PointsMaterial, 'PointsMaterial');
+      this.registerClass(Prefix.THREE, THREE.PolarGridHelper, 'PolarGridHelper');
+      this.registerClass(Prefix.THREE, THREE.PolyhedronGeometry, 'PolyhedronGeometry');
+      this.registerClass(Prefix.THREE, THREE.PositionalAudio, 'PositionalAudio');
+      this.registerClass(Prefix.THREE, THREE.PropertyBinding, 'PropertyBinding');
+      this.registerClass(Prefix.THREE, THREE.PropertyMixer, 'PropertyMixer');
+      this.registerClass(Prefix.THREE, THREE.QuadraticBezierCurve, 'QuadraticBezierCurve');
+      this.registerClass(Prefix.THREE, THREE.QuadraticBezierCurve3, 'QuadraticBezierCurve3');
+      this.registerClass(Prefix.THREE, THREE.Quaternion, 'Quaternion');
+      this.registerClass(Prefix.THREE, THREE.QuaternionKeyframeTrack, 'QuaternionKeyframeTrack');
+      this.registerClass(Prefix.THREE, THREE.QuaternionLinearInterpolant, 'QuaternionLinearInterpolant');
+      this.registerClass(Prefix.THREE, THREE.RawShaderMaterial, 'RawShaderMaterial');
+      this.registerClass(Prefix.THREE, THREE.Ray, 'Ray');
+      this.registerClass(Prefix.THREE, THREE.Raycaster, 'Raycaster');
+      this.registerClass(Prefix.THREE, THREE.RectAreaLight, 'RectAreaLight');
+      this.registerClass(Prefix.THREE, THREE.RenderTarget, 'RenderTarget');
+      this.registerClass(Prefix.THREE, THREE.RenderTarget3D, 'RenderTarget3D');
+      this.registerClass(Prefix.THREE, THREE.RingGeometry, 'RingGeometry');
+      this.registerClass(Prefix.THREE, THREE.Scene, 'Scene');
+      this.registerClass(Prefix.THREE, THREE.ShaderMaterial, 'ShaderMaterial');
+      this.registerClass(Prefix.THREE, THREE.ShadowMaterial, 'ShadowMaterial');
+      this.registerClass(Prefix.THREE, THREE.Shape, 'Shape');
+      this.registerClass(Prefix.THREE, THREE.ShapeGeometry, 'ShapeGeometry');
+      this.registerClass(Prefix.THREE, THREE.ShapePath, 'ShapePath');
+      this.registerClass(Prefix.THREE, THREE.ShapeUtils, 'ShapeUtils');
+      this.registerClass(Prefix.THREE, THREE.Skeleton, 'Skeleton');
+      this.registerClass(Prefix.THREE, THREE.SkeletonHelper, 'SkeletonHelper');
+      this.registerClass(Prefix.THREE, THREE.SkinnedMesh, 'SkinnedMesh');
+      this.registerClass(Prefix.THREE, THREE.Source, 'Source');
+      this.registerClass(Prefix.THREE, THREE.Sphere, 'Sphere');
+      this.registerClass(Prefix.THREE, THREE.SphereGeometry, 'SphereGeometry');
+      this.registerClass(Prefix.THREE, THREE.Spherical, 'Spherical');
+      this.registerClass(Prefix.THREE, THREE.SphericalHarmonics3, 'SphericalHarmonics3');
+      this.registerClass(Prefix.THREE, THREE.SplineCurve, 'SplineCurve');
+      this.registerClass(Prefix.THREE, THREE.SpotLight, 'SpotLight');
+      this.registerClass(Prefix.THREE, THREE.SpotLightHelper, 'SpotLightHelper');
+      this.registerClass(Prefix.THREE, THREE.Sprite, 'Sprite');
+      this.registerClass(Prefix.THREE, THREE.SpriteMaterial, 'SpriteMaterial');
+      this.registerClass(Prefix.THREE, THREE.StereoCamera, 'StereoCamera');
+      this.registerClass(Prefix.THREE, THREE.StringKeyframeTrack, 'StringKeyframeTrack');
+      this.registerClass(Prefix.THREE, THREE.TetrahedronGeometry, 'TetrahedronGeometry');
+      this.registerClass(Prefix.THREE, THREE.Texture, 'Texture');
+      this.registerClass(Prefix.THREE, THREE.TextureLoader, 'TextureLoader');
+      this.registerClass(Prefix.THREE, THREE.TorusGeometry, 'TorusGeometry');
+      this.registerClass(Prefix.THREE, THREE.TorusKnotGeometry, 'TorusKnotGeometry');
+      this.registerClass(Prefix.THREE, THREE.Triangle, 'Triangle');
+      this.registerClass(Prefix.THREE, THREE.TubeGeometry, 'TubeGeometry');
+      this.registerClass(Prefix.THREE, THREE.Uint16BufferAttribute, 'Uint16BufferAttribute');
+      this.registerClass(Prefix.THREE, THREE.Uint32BufferAttribute, 'Uint32BufferAttribute');
+      this.registerClass(Prefix.THREE, THREE.Uint8BufferAttribute, 'Uint8BufferAttribute');
+      this.registerClass(Prefix.THREE, THREE.Uint8ClampedBufferAttribute, 'Uint8ClampedBufferAttribute');
+      this.registerClass(Prefix.THREE, THREE.Uniform, 'Uniform');
+      this.registerClass(Prefix.THREE, THREE.UniformsGroup, 'UniformsGroup');
+      this.registerClass(Prefix.THREE, THREE.Vector2, 'Vector2');
+      this.registerClass(Prefix.THREE, THREE.Vector3, 'Vector3');
+      this.registerClass(Prefix.THREE, THREE.Vector4, 'Vector4');
+      this.registerClass(Prefix.THREE, THREE.VectorKeyframeTrack, 'VectorKeyframeTrack');
+      this.registerClass(Prefix.THREE, THREE.VideoFrameTexture, 'VideoFrameTexture');
+      this.registerClass(Prefix.THREE, THREE.VideoTexture, 'VideoTexture');
+      this.registerClass(Prefix.THREE, THREE.WebGL3DRenderTarget, 'WebGL3DRenderTarget');
+      this.registerClass(Prefix.THREE, THREE.WebGLArrayRenderTarget, 'WebGLArrayRenderTarget');
+      this.registerClass(Prefix.THREE, THREE.WebGLCubeRenderTarget, 'WebGLCubeRenderTarget');
+      this.registerClass(Prefix.THREE, THREE.WebGLRenderTarget, 'WebGLRenderTarget');
+      this.registerClass(Prefix.THREE, THREE.WebGLRenderer, 'WebGLRenderer');
+      this.registerClass(Prefix.THREE, THREE.WebGLUtils, 'WebGLUtils');
+      this.registerClass(Prefix.THREE, THREE.WireframeGeometry, 'WireframeGeometry');
+    } else {
+      // enable this branch to log the code above...
+      const lines = [];
+      const blackList = ['AudioContext', 'Controls', 'Curve', 'DataUtils', 'Interpolant', 'Light', 'TextureUtils', 'WebXRController', 'createCanvasElement'];
+      for (const [_, value] of Object.entries(THREE)) {
+        if (isConstructor(value)) {
+          let className = value.name;
+          // weird that some three.js classes are exported with leading underscores, this fixes that
+          if (className.startsWith('_')) {
+            className = className.slice(1);
+          }
+          if (blackList.includes(className)) {
+            continue;
+          }
+          lines.push(`this.registerClass(Prefix.THREE, THREE.${className}, '${className}');`);
+        }
+      }
+      console.log(lines.join('\n'));
+    }
+    this.builtInClassesRegistered = true;
+  }
+
+  //====================================================================================================
+
+  private static registerClass(prefix: Prefix, constructor: Constructor, className?: string): void {
+    if (!isConstructor(constructor)) {
+      throw new Error(`${constructor} is not a constructor`);
+    }
+    const fullName = `${prefix}${className ?? constructor.name}`;
+    if (this.registry.has(fullName)) {
+      throw new Error(`${fullName} class already registered`);
+    }
+    this.registry.set(fullName, constructor);
+    this.reverseRegistry.set(constructor, fullName);
+    // console.log(`class '${fullName}' registered`);
+  }
+}
+
+/**
+ * Decorator for registering a class as an engine component.
+ * @returns Class decorator function
+ */
+export function EngineClass(className: string) {
+  return function (constructor: Constructor) {
+    ClassRegistry.registerEngineClass(constructor, className);
+  };
+}
+
+/**
+ * Decorator for registering a class as a game component.
+ * @returns Class decorator function
+ */
+export function GameClass() {
+  return function (constructor: Constructor) {
+    ClassRegistry.registerGameClass(constructor);
+  };
+}
+
+ClassRegistry.addClassesToRedirect({
+  'ENGINE.GLTMeshActor': 'ENGINE.GLTFMeshActor'
+});