ohzi-core 13.0.0 → 13.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ohzi-core",
-  "version": "13.0.0",
+  "version": "13.0.2",
   "description": "OHZI Interactive Core Library",
   "type": "module",
   "source": "src/index.ts",
@@ -21,7 +21,7 @@
     "build": "rollup -c",
     "create-tag": "node tasks/app/create_tag.mjs",
     "fix-syntax": "npx eslint src --fix || echo 'Done.'",
-    "generate-types": "npx -p typescript tsc src/* --declaration --allowJs --emitDeclarationOnly --outDir types",
+    "generate-types": "npx -p typescript tsc",
     "upload": "yarn build && npm publish && yarn create-tag",
     "create-view": "node ./tasks/create_view/create_view.mjs",
     "create-scene": "node ./tasks/create_scene/create_scene.mjs",
@@ -46,12 +46,12 @@
     "registry": "https://registry.npmjs.org/"
   },
   "dependencies": {
-    "three": "0.182.0"
+    "three": "0.183.0"
   },
   "devDependencies": {
     "@rollup/plugin-typescript": "^12.3.0",
     "@types/node": "^25.0.3",
-    "@types/three": "0.182.0",
+    "@types/three": "0.183.0",
     "@typescript-eslint/eslint-plugin": "^8.18.2",
     "@typescript-eslint/parser": "^8.18.2",
     "eslint": "^8.57.0",

package/src/CameraManager.ts

@@ -17,7 +17,6 @@ class CameraManager
     this._current = camera;
   }
 
-  /** @type {PerspectiveCamera} */
   get current()
   {
     return this._current;
@@ -28,7 +27,6 @@ class CameraManager
     this._spectator = camera;
   }
 
-  /** @type {PerspectiveCamera} */
   get spectator()
   {
     return this._spectator;

package/src/CustomBezierCurve.ts

@@ -5,9 +5,6 @@ class CustomBezierCurve
   original_points: Vector3[];
   tmp_points: Vector3[];
   
-  /**
-   * @param {Vector3[]} points
-   */
   constructor(points: Vector3[])
   {
     this.original_points = [];
@@ -19,10 +16,6 @@ class CustomBezierCurve
     }
   }
 
-  /**
-   * @param {number} point_amount
-   * @returns {Vector3[]}
-   */
   build(point_amount: number): Vector3[]
   {
     const curve = [];
@@ -33,10 +26,6 @@ class CustomBezierCurve
     return curve;
   }
 
-  /**
-   * @param {number} t
-   * @returns {Vector3}
-   */
   get_point_at(t: number): Vector3
   {
     for (let i = 0; i < this.original_points.length; i++)

package/src/Debug.ts

@@ -22,7 +22,7 @@ class Debug
   camera: PerspectiveCamera;
   canvas_renderer: any;
   ctx: any;
-  display_texture_meshes: Mesh<PlaneGeometry, ScreenSpaceTextureMaterial>[];
+  display_texture_meshes: Mesh[];
   rt_debug: RenderTarget;
   scene: AbstractScene;
   
@@ -32,7 +32,6 @@ class Debug
     this.Vector3_zero = new Vector3(0, 0, 0);
     this.canvas_renderer = undefined;
 
-    /** @type { Mesh<PlaneGeometry, ScreenSpaceTextureMaterial>[] } */
     this.display_texture_meshes = [];
 
     this.ctx = undefined;

package/src/OS.ts

@@ -7,6 +7,7 @@ class OS
   is_mac: boolean;
   is_mobile: boolean;
   is_windows: boolean;
+
   operating_systems: {
     ANDROID: string;
     IOS: string;
@@ -14,6 +15,7 @@ class OS
     MAC: string;
     WINDOWS: string;
   };
+  
   init()
   {
     this.operating_systems = {

package/src/ResourceContainer.ts

@@ -1,8 +1,6 @@
-import type { Object3D, Texture } from 'three';
-
 class ResourceContainer
 {
-  resources: Record<string, Object3D | Texture>;
+  resources: Record<string, any>;
   resources_by_url: Record<string, any>;
 
   init()
@@ -12,7 +10,7 @@ class ResourceContainer
     this.resources_by_url = {};
   }
 
-  set_resource(name: string, url: string, resource: Object3D | Texture)
+  set_resource(name: string, url: string, resource: any)
   {
     const urls = Object.keys(this.resources_by_url);
 
@@ -27,12 +25,12 @@ class ResourceContainer
     }
   }
 
-  get_resource(name: string): Object3D | Texture
+  get_resource(name: string): any
   {
     return this.resources[name];
   }
 
-  get(name: string): Object3D | Texture
+  get(name: string): any
   {
     return this.resources[name];
   }

package/src/SceneManager.ts

@@ -16,7 +16,6 @@ class SceneManager
 
   }
 
-  /** @type {AbstractScene} */
   get current()
   {
     return this._current;

package/src/action_sequencer/ActionSequencer.ts

@@ -22,7 +22,6 @@ class ActionSequencer
     this.playback_speed = this.__get_playback_speed();
     this.playing = true;
 
-    /** @type {{action:ActionEvent, trigger_time:number }[]} */
     this.action_events = [];
     this.context = context;
 

package/src/components/Input.ts

@@ -45,19 +45,19 @@ export interface Input {
 
     pointer_is_over_element(elem: any): boolean;
 
-    get pointers(): any;
-    get pointer_pos(): any;
-    get pointer_pos_delta(): any;
+    get pointers(): Vector2[];
+    get pointer_pos(): Vector2;
+    get pointer_pos_delta(): Vector2;
     get NDC(): Vector2;
     get NDC_delta(): Vector2;
-    get pointer_center(): any;
-    get pointer_center_delta(): any;
-    get pointer_center_NDC(): any;
-    get pointer_center_NDC_delta(): any;
+    get pointer_center(): Vector2;
+    get pointer_center_delta(): Vector2;
+    get pointer_center_NDC(): Vector2;
+    get pointer_center_NDC_delta(): Vector2;
 
-    get_pointer_pos(index?: number): any;
-    get_pointer_pos_delta(index?: number): any;
-    get_pointer_NDC(index?: number): any;
-    get_pointer_NDC_delta(index?: number): any;
+    get_pointer_pos(index?: number): Vector2;
+    get_pointer_pos_delta(index?: number): Vector2;
+    get_pointer_NDC(index?: number): Vector2;
+    get_pointer_NDC_delta(index?: number): Vector2;
     dispose(): void;
 }

package/src/utilities/OMath.ts

@@ -155,13 +155,7 @@ class OMath
     return OMath.clamp(x, 0, 1);
   }
 
-  /**
-  * Generate a [UUID]{@link https://en.wikipedia.org/wiki/Universally_unique_identifier}
-  * (universally unique identifier).
-  *
-  * @return {string} The UUID.
-  */
-  static generate_uuid()
+  static generate_uuid(): string
   {
     // http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript/21963136#21963136
     const _lut = [

package/types/BaseApplication.d.ts

@@ -1,12 +1,7 @@
+import type { RenderLoop } from "./RenderLoop";
 export class BaseApplication {
     on_post_start(): void;
-    /**
-      * @param {RenderLoop} [loop]
-     */
     on_enter(loop?: RenderLoop): void;
-    /**
-      * @param {RenderLoop} [loop]
-     */
     on_exit(loop?: RenderLoop): void;
     before_update(): void;
     update(): void;
@@ -15,4 +10,3 @@ export class BaseApplication {
     on_pre_render(): void;
     on_frame_end(): void;
 }
-import { RenderLoop } from "./RenderLoop";

package/types/CameraManager.d.ts

@@ -1,14 +1,16 @@
-export { camera_manager as CameraManager };
-declare const camera_manager: CameraManager;
+import type { PerspectiveCamera } from "./PerspectiveCamera";
+
 declare class CameraManager {
     init(): void;
+    
     _current: PerspectiveCamera;
     _spectator: PerspectiveCamera;
     set current(arg: PerspectiveCamera);
-    /** @type {PerspectiveCamera} */
     get current(): PerspectiveCamera;
     set spectator(arg: PerspectiveCamera);
-    /** @type {PerspectiveCamera} */
     get spectator(): PerspectiveCamera;
 }
-import { PerspectiveCamera } from "./PerspectiveCamera";
+
+declare const camera_manager: CameraManager;
+export { camera_manager as CameraManager };
+

package/types/CustomBezierCurve.d.ts

@@ -2,19 +2,8 @@ import { Vector3 } from 'three';
 declare class CustomBezierCurve {
     original_points: Vector3[];
     tmp_points: Vector3[];
-    /**
-     * @param {Vector3[]} points
-     */
     constructor(points: Vector3[]);
-    /**
-     * @param {number} point_amount
-     * @returns {Vector3[]}
-     */
     build(point_amount: number): Vector3[];
-    /**
-     * @param {number} t
-     * @returns {Vector3}
-     */
     get_point_at(t: number): Vector3;
 }
 export { CustomBezierCurve };

package/types/Debug.d.ts

@@ -1,3 +1,11 @@
+import type { Box3, Box3Helper, Line, Mesh, RenderTarget, Scene, Texture, Vector2, Vector3 } from "three";
+import type { AxisHelper } from "./components/AxisHelper";
+import type { Graphics } from "./Graphics";
+import type { PerspectiveCamera } from "./PerspectiveCamera";
+import type { Arrow } from "./primitives/Arrow";
+import type { Cube } from "./primitives/Cube";
+import type { Sphere } from "./primitives/Sphere";
+
 export { debug as Debug };
 declare const debug: Debug;
 declare class Debug {
@@ -5,194 +13,30 @@ declare class Debug {
     Vector3_one: Vector3;
     Vector3_zero: Vector3;
     canvas_renderer: any;
-    /** @type { Mesh<PlaneGeometry, ScreenSpaceTextureMaterial>[] } */
-    display_texture_meshes: Mesh<PlaneGeometry, ScreenSpaceTextureMaterial>[];
+    display_texture_meshes: Mesh[];
     ctx: any;
     scene: Scene;
     camera: PerspectiveCamera;
-    /**
-     * @param {Vector3} origin
-     * @param {Vector3} dir
-     * @param {number | string} color
-     * @returns {Arrow}
-     */
     draw_arrow(origin: Vector3, dir: Vector3, color?: number | string): Arrow;
     draw_axis(): AxisHelper;
-    /**
-     * @param {RenderTarget} RT
-     */
     set_debug_RT(RT: RenderTarget): void;
     rt_debug: RenderTarget<Texture>;
-    /**
-     * @param {Vector2 | Vector3} position_2d
-     * @param {number} width
-     * @param {number} height
-     * @param {number | string} color
-     */
     draw_rectangle(position_2d: Vector2 | Vector3, width: number, height: number, color: number | string): void;
     clear(): void;
-    /**
-     * @param {Vector3 | Vector2} from
-     * @param {Vector3 | Vector2} to
-     * @param {number | string} color
-     */
     draw_line_2D(from: Vector3 | Vector2, to: Vector3 | Vector2, color: number | string): void;
-    /**
-     * @param {Vector3[]} points
-     * @param {number | string} color
-     * @returns {Line}
-     */
     draw_line(points: Vector3[], color?: number | string): Line;
-    /**
-     * @param {Vector3} pos
-     * @param {number} size
-     * @param {number | string} color
-     * @returns {Cube}
-     */
     draw_cube(pos: Vector3, size: number, color: number | string): Cube;
-    /**
-     * @param {Vector3} from
-     * @param {Vector3} to
-     * @param {number} height
-     * @param {number | string} color
-     * @param {number} depth
-     * @returns {Cube}
-     */
     draw_oriented_cube(from: Vector3, to: Vector3, height?: number, color?: number | string, depth?: number): Cube;
-    /**
-     *
-     * @param {number} [width]
-     * @param {number} [height]
-     * @param {number | string} [color]
-     * @returns
-     */
-    draw_plane(width?: number, height?: number, color?: number | string): Mesh<PlaneGeometry, ShaderMaterial, import("three").Object3DEventMap>;
-    /**
-     * @param {Vector3} pos
-     * @param {number} size
-     * @param {number | string} color
-     * @returns {Box3Helper}
-     */
+    draw_plane(width?: number, height?: number, color?: number | string): Mesh;
     draw_empty_cube(pos: Vector3, size: number, color: number | string): Box3Helper;
-    /**
-     * @param {Vector3} pos
-     * @param {number} size
-     * @param {number | string} color
-     * @returns {Sphere}
-     */
     draw_sphere(pos: Vector3, size: number, color: number | string): Sphere;
-    /**
-     *
-     * @param {Vector3[]} input_points
-     * @param {boolean} open
-     * @param {number | string} color
-     * @returns {Line}
-     */
     draw_point_array(input_points: Vector3[], open?: boolean, color?: number | string): Line;
-    /**
-     * @param {Sphere} sphere
-     * @param {number | string} color
-     * @returns {Mesh}
-     */
     draw_sphere_helper(sphere: Sphere, color: number | string): Mesh;
-    /**
-     * @param {Sphere} sphere
-     */
     draw_math_sphere(sphere: Sphere): void;
-    /**
-     * @param {Box3} bb
-     */
     draw_bounding_box(bb: Box3): void;
-    /**
-     * @param {Vector3[]} curve
-     * @param {object} options
-     * @param {number} options.offset
-     */
     draw_curve(curve: Vector3[], options: {
         offset: number;
     }): void;
-    /**
-     * @param {Texture} tex
-     * @param {number} w
-     * @param {number} h
-     * @returns {Mesh}
-     */
     draw_texture(tex: Texture, w: number, h: number): Mesh;
-    /**
-     * @param {Graphics} graphics
-     */
-    render(graphics: {
-        init({ canvas, core_attributes, context_attributes, threejs_attributes, dpr }: {
-            canvas: HTMLCanvasElement;
-            core_attributes: Record<string, any>;
-            context_attributes: Record<string, any>;
-            threejs_attributes: Record<string, any>;
-            dpr: number;
-        }): void;
-        _renderer: WebGLRenderer;
-        blitter: import("./render_utilities/Blitter").Blitter;
-        canvas: HTMLCanvasElement;
-        no_render: import("./render_mode/BaseRender").BaseRender;
-        current_render_mode: import("./render_mode/BaseRender").BaseRender;
-        generateDepthNormalTexture: boolean;
-        depth_and_normals_renderer: import("./render_utilities/DepthAndNormalsRenderer").DepthAndNormalsRenderer;
-        is_webgl2: boolean;
-        canvas_context: RenderingContext;
-        context_attributes: {
-            alpha: boolean;
-            antialias: boolean;
-            depth: boolean;
-            desynchronized: boolean;
-            failIfMajorPerformanceCaveat: boolean;
-            powerPreference: string;
-            premultipliedAlpha: boolean;
-            preserveDrawingBuffer: boolean;
-            stencil: boolean;
-        };
-        core_attributes: {
-            force_webgl2: boolean;
-            xr_enabled: boolean;
-        };
-        threejs_attributes: Record<string, any>;
-        readonly dom_element: HTMLCanvasElement;
-        readonly depth_normals_RT: import("three").WebGLRenderTarget<Texture>;
-        set_state(new_state: import("./render_mode/BaseRender").BaseRender): void;
-        update(): void;
-        __update_current_camera(): void;
-        render(scene?: Scene, camera?: PerspectiveCamera | import("./OrthographicCamera").OrthographicCamera, RT?: import("three").WebGLRenderTarget<Texture>, override_mat?: import("three").Material): void;
-        compile(scene: Scene, camera: PerspectiveCamera, RT: import("three").WebGLRenderTarget<Texture>, override_mat: import("three").Material): void;
-        compile_async(scene: Scene, camera: PerspectiveCamera, RT: import("three").WebGLRenderTarget<Texture>, override_mat: import("three").Material, target_scene: Scene): Promise<import("three").Object3D<import("three").Object3DEventMap>>;
-        render_scene(scene: Scene | import("./BaseApplication").BaseApplication | {
-            render: () => void;
-        }): void;
-        __apply_override_material(scene: Scene, mat: import("three").Material): void;
-        readback_RT(RT: import("three").WebGLRenderTarget<Texture>, buffer: import("three").TypedArray): void;
-        clear(RT: import("three").WebGLRenderTarget<Texture>, camera: PerspectiveCamera, clear_depth: boolean, clear_stencil: boolean): void;
-        on_resize(entries: ResizeObserverEntry[], dpr: number): void;
-        material_pass(mat: import("three").Material, dst: import("three").WebGLRenderTarget<Texture>): void;
-        blit(src_RT: import("three").WebGLRenderTarget<Texture>, dst_RT: import("three").WebGLRenderTarget<Texture>, mat: import("three").Material): void;
-        blit_clear_with_material(dst_RT: import("three").WebGLRenderTarget<Texture>, mat: import("three").Material): void;
-        take_screenshot(blob_callback: BlobCallback, width?: number, height?: number): void;
-        download_screenshot(blob: Blob): void;
-        dispose(): void;
-        is_floating_point_texture_available(): boolean;
-    }): void;
+    render(graphics: typeof Graphics): void;
 }
-import { Vector3 } from "three/src/math/Vector3";
-import { Mesh } from "three/src/objects/Mesh";
-import { PlaneGeometry } from "three/src/geometries/PlaneGeometry";
-import { ScreenSpaceTextureMaterial } from "./materials/ScreenSpaceTextureMaterial";
-import { Scene } from "three/src/scenes/Scene";
-import { PerspectiveCamera } from "./PerspectiveCamera";
-import { Arrow } from "./primitives/Arrow";
-import { AxisHelper } from "./components/AxisHelper";
-import { RenderTarget } from "three/src/core/RenderTarget";
-import { Texture } from "three/src/textures/Texture";
-import { Vector2 } from "three/src/math/Vector2";
-import { Line } from "three/src/objects/Line";
-import { Cube } from "./primitives/Cube";
-import { ShaderMaterial } from "three/src/materials/ShaderMaterial";
-import { Box3Helper } from "three/src/helpers/Box3Helper";
-import { Sphere } from "./primitives/Sphere";
-import { Box3 } from "three/src/math/Box3";
-import { WebGLRenderer } from "three/src/renderers/WebGLRenderer";

package/types/Graphics.d.ts

@@ -1,18 +1,21 @@
+import type { Material, Object3D, RenderTarget, Scene, Texture, TypedArray } from "three";
+import type { Renderer } from "three/webgpu";
+import type { BaseApplication } from "./BaseApplication";
+import type { OrthographicCamera } from "./OrthographicCamera";
+import type { PerspectiveCamera } from "./PerspectiveCamera";
+import type { BaseRender } from "./render_mode/BaseRender";
+import type { Blitter } from "./render_utilities/Blitter";
+import type { DepthAndNormalsRenderer } from "./render_utilities/DepthAndNormalsRenderer";
+
 export { graphics as Graphics };
 declare const graphics: Graphics;
 declare class Graphics {
-    /**
-     * @param {Object} options
-     * @param {Record<string, any>} options.core_attributes
-     * @param {Record<string, any>} options.renderer_attributes
-     * @param {number} options.dpr
-     */
     init({ core_attributes, renderer_attributes, dpr }: {
         core_attributes: Record<string, any>;
         renderer_attributes: Record<string, any>;
         dpr: number;
     }): void;
-    _renderer: WebGLRenderer;
+    _renderer: Renderer;
     blitter: Blitter;
     no_render: BaseRender;
     current_render_mode: BaseRender;
@@ -34,104 +37,27 @@ declare class Graphics {
         force_webgl2: boolean;
         xr_enabled: boolean;
     };
-    /** @type {Record<string, any>} */
     get dom_element(): HTMLCanvasElement;
-    get depth_normals_RT(): WebGLRenderTarget<import("three").Texture>;
-    /**
-     * @param {BaseRender} new_state
-     */
+    get depth_normals_RT(): RenderTarget<Texture>;
+
     set_state(new_state: BaseRender): void;
     update(): void;
     __update_current_camera(): void;
-    /**
-     * @param {Scene} [scene]
-     * @param {PerspectiveCamera | OrthographicCamera} [camera]
-     * @param {WebGLRenderTarget} [RT]
-     * @param {Material} [override_mat]
-     */
-    render(scene?: Scene, camera?: PerspectiveCamera | OrthographicCamera, RT?: WebGLRenderTarget, override_mat?: Material): void;
-    /**
-     * @param {Scene} scene
-     * @param {PerspectiveCamera} camera
-     * @param {WebGLRenderTarget} RT
-     * @param {Material} override_mat
-     */
-    compile(scene: Scene, camera: PerspectiveCamera, RT: WebGLRenderTarget, override_mat: Material): void;
-    /**
-     * @param {Scene} scene
-     * @param {PerspectiveCamera} camera
-     * @param {WebGLRenderTarget} RT
-     * @param {Material} override_mat
-     * @param {Scene} target_scene
-     * @returns {Promise<Object3D>}
-     */
-    compile_async(scene: Scene, camera: PerspectiveCamera, RT: WebGLRenderTarget, override_mat: Material, target_scene: Scene): Promise<Object3D>;
-    /**
-     * @param {BaseApplication | Scene | {render:()=>void}} scene
-     */
+    render(scene?: Scene, camera?: PerspectiveCamera | OrthographicCamera, RT?: RenderTarget, override_mat?: Material): void;
+    compile(scene: Scene, camera: PerspectiveCamera, RT: RenderTarget, override_mat: Material): void;
+    compile_async(scene: Scene, camera: PerspectiveCamera, RT: RenderTarget, override_mat: Material, target_scene: Scene): Promise<Object3D>;
     render_scene(scene: BaseApplication | Scene | {
         render: () => void;
     }): void;
-    /**
-     * @param {Scene} scene
-     * @param {Material} mat
-     */
     __apply_override_material(scene: Scene, mat: Material): void;
-    /**
-     * @param {WebGLRenderTarget} RT
-     * @param {import('three').TypedArray} buffer
-     */
-    readback_RT(RT: WebGLRenderTarget, buffer: import('three').TypedArray): void;
-    /**
-     * @param {WebGLRenderTarget} RT
-     * @param {PerspectiveCamera} camera
-     * @param {boolean} clear_depth
-     * @param {boolean} clear_stencil
-     */
-    clear(RT: WebGLRenderTarget, camera: PerspectiveCamera, clear_depth: boolean, clear_stencil: boolean): void;
-    /**
-     * @param {ResizeObserverEntry[]} entries
-     * @param {number} dpr
-     */
+    readback_RT(RT: RenderTarget, buffer: TypedArray): void;
+    clear(RT: RenderTarget, camera: PerspectiveCamera, clear_depth: boolean, clear_stencil: boolean): void;
     on_resize(entries: ResizeObserverEntry[], dpr: number): void;
-    /**
-     * @param {Material} mat
-     * @param {WebGLRenderTarget} dst
-     */
-    material_pass(mat: Material, dst: WebGLRenderTarget): void;
-    /**
-     * @param {WebGLRenderTarget} src_RT
-     * @param {WebGLRenderTarget} dst_RT
-     * @param {Material} mat
-     */
-    blit(src_RT: WebGLRenderTarget, dst_RT: WebGLRenderTarget, mat: Material): void;
-    /**
-     * @param {WebGLRenderTarget} dst_RT
-     * @param {Material} mat
-     */
-    blit_clear_with_material(dst_RT: WebGLRenderTarget, mat: Material): void;
-    /**
-     * @param {BlobCallback} blob_callback
-     * @param {number} width
-     * @param {number} height
-     */
+    material_pass(mat: Material, dst: RenderTarget): void;
+    blit(src_RT: RenderTarget, dst_RT: RenderTarget, mat: Material): void;
+    blit_clear_with_material(dst_RT: RenderTarget, mat: Material): void;
     take_screenshot(blob_callback: BlobCallback, width?: number, height?: number): void;
-    /**
-     * @param {Blob} blob
-     */
     download_screenshot(blob: Blob): void;
     dispose(): void;
     is_floating_point_texture_available(): boolean;
 }
-import { Object3D } from "three/src/core/Object3D";
-import { Material } from "three/src/materials/Material";
-import { WebGLRenderer } from "three/src/renderers/WebGLRenderer";
-import { WebGLRenderTarget } from "three/src/renderers/WebGLRenderTarget";
-import { Scene } from "three/src/scenes/Scene";
-import { BaseApplication } from "./BaseApplication";
-import { OrthographicCamera } from "./OrthographicCamera";
-import { PerspectiveCamera } from "./PerspectiveCamera";
-import { BaseRender } from "./render_mode/BaseRender";
-import { Blitter } from "./render_utilities/Blitter";
-import { DepthAndNormalsRenderer } from "./render_utilities/DepthAndNormalsRenderer";
-

package/types/Initializer.d.ts

@@ -1,10 +1,8 @@
+import type { RenderLoop } from "./index";
+
 export { initializer as Initializer };
 declare const initializer: Initializer;
 declare class Initializer {
     init(input: any): void;
-    /**
-     * @param {RenderLoop} render_loop
-     */
     dispose(render_loop: RenderLoop): void;
 }
-import { RenderLoop } from "./index";