vanta-engine 1.0.2 → 1.0.4

package/dist/index.d.ts

@@ -1,27 +1,755 @@
-export * from "./graphics/assets/asset_loaders/obj.ts";
-export * from "./graphics/assets/vaos.ts";
-export * from "./graphics/assets/material.ts";
-export * from "./graphics/assets/mesh.ts";
-export * from "./graphics/assets/model.ts";
-export * from "./graphics/assets/texture.ts";
-export * from "./graphics/framebuffer.ts";
-export * from "./graphics/shader_program.ts";
-export * from "./graphics/graphics_manager.ts";
-export * from "./node.ts";
-export * from "./node/camera3d.ts";
-export * from "./node/lights/light.ts";
-export * from "./node/lights/point_light.ts";
-export * from "./node/lights/directional_light.ts";
-export * from "./node/lights/spot_light.ts";
-export * from "./node/object3d.ts";
-export * from "./node/skybox.ts";
-export * from "./node/sprite2d.ts";
-export * from "./graphics/utility.ts";
-export * from "./input/input_manager.ts";
-export * from "./utility.ts";
-export * from "./engine.ts";
-export * from "./scene.ts";
-export * from "./hook_manager.ts";
-import Engine from './engine.ts';
-export default Engine;
-//# sourceMappingURL=index.d.ts.map
+import { Mat4, Vec3, Quat, Vec2, Vec4, Mat2, Mat3 } from '@vicimpa/glm';
+import { LuaFactory, LuaEngine } from 'wasmoon';
+
+declare enum MouseButton {
+    Left = 0,
+    Middle = 1,
+    Right = 2
+}
+declare class InputManager {
+    private target;
+    engine: Engine;
+    private keysDown;
+    private keysPressed;
+    private keysReleased;
+    private mouseDown;
+    private mousePressed;
+    private mouseReleased;
+    mouseX: number;
+    mouseY: number;
+    mouse_delta_x: number;
+    mouse_delta_y: number;
+    wheelDelta: number;
+    constructor(engine: Engine, target?: HTMLElement);
+    destroy(): void;
+    update(): void;
+    is_key_down(code: string): boolean;
+    was_key_pressed(code: string): boolean;
+    was_key_released(code: string): boolean;
+    is_mouse_down(button: MouseButton): boolean;
+    was_mouse_pressed(button: MouseButton): boolean;
+    was_mouse_released(button: MouseButton): boolean;
+    lock_mouse(): void;
+    unlock_mouse(): void;
+    private attach;
+    private detach;
+    private onKeyDown;
+    private onKeyUp;
+    private onMouseDown;
+    private onMouseUp;
+    private onMouseMove;
+    private onWheel;
+}
+
+declare class Utility {
+    static load_text_file(url: string): Promise<string>;
+    static load_image(image_asset_path: string, options?: ImageBitmapOptions): Promise<ImageBitmap>;
+}
+
+type Constructor<T> = new (...args: any[]) => T;
+declare class Node {
+    engine: Engine;
+    name: string;
+    parent: Node | null;
+    children: Array<Node>;
+    on_ready_callback: (node: Node, engine: Engine) => void;
+    on_removed_callback: (node: Node, engine: Engine, parent: Node) => void;
+    on_update_callback: (node: Node, engine: Engine, time: number, delta_time: number) => void;
+    on_render_callback: (node: Node, engine: Engine, time: number, delta_time: number) => void;
+    private lua_url;
+    constructor(engine: Engine, name: string);
+    set_lua_file(url: string): Promise<void>;
+    protected on_ready(node: this, engine: Engine): void;
+    protected on_removed(node: this, engine: Engine, parent: Node): void;
+    protected on_update(node: this, engine: Engine, time: number, delta_time: number): void;
+    protected on_render(node: this, engine: Engine, time: number, delta_time: number): void;
+    protected on_parented(): void;
+    has_child(node: Node | string): boolean;
+    has_parent(node: Node | string): boolean;
+    get_parent(node_name: string): Node | null;
+    get_parent_of_type<T>(node_type: Constructor<T>): T | null;
+    get_child(name: string): Node | null;
+    get_children_of_type<T>(node_type: Constructor<T>): T[];
+    push_child(node: Node): void;
+    remove_child(node: Node | string): void;
+    update(time: number, delta_time: number): void;
+    render(view_matrix: Mat4, projection_matrix_3d: Mat4, projection_matrix_2d: Mat4, time: number, delta_time: number): void;
+    protected render_children(view_matrix: Mat4, projection_matrix_3d: Mat4, projection_matrix_2d: Mat4, time: number, delta_time: number): void;
+    protected render_class(view_matrix: Mat4, projection_matrix_3d: Mat4, projection_matrix_2d: Mat4, time: number, delta_time: number): void;
+}
+declare class Node2D extends Node {
+    private stored_position;
+    private stored_rotation;
+    private stored_scale;
+    constructor(engine: Engine, name: string);
+    get position(): Vec2;
+    set position(value: Vec2);
+    get rotation(): number;
+    set rotation(value: number);
+    get scale(): Vec2;
+    set scale(value: Vec2);
+    private proxy_on_change_position;
+    private proxy_on_change_scale;
+    protected on_change_position(new_value: Vec2): void;
+    protected on_change_rotation(new_value: number): void;
+    protected on_change_scale(new_value: Vec2): void;
+    get_model_matrix(): Mat4;
+    get_world_matrix(): Mat4;
+}
+declare class Node3D extends Node {
+    private stored_position;
+    private stored_rotation;
+    private stored_scale;
+    constructor(engine: Engine, name: string);
+    get position(): Vec3;
+    set position(value: Vec3);
+    get rotation(): Quat;
+    set rotation(value: Quat);
+    get scale(): Vec3;
+    set scale(value: Vec3);
+    private proxy_on_change_position;
+    private proxy_on_change_rotation;
+    private proxy_on_change_scale;
+    protected on_change_position(new_value: Vec3): void;
+    protected on_change_rotation(new_value: Quat): void;
+    protected on_change_scale(new_value: Vec3): void;
+    get_world_position(): Vec3;
+    get_parent_world_matrix(): Mat4;
+    get_model_matrix(): Mat4;
+    get_world_matrix(): Mat4;
+}
+
+declare class HookManager {
+    engine: Engine;
+    lua_factory: LuaFactory;
+    lua_engine_promise: Promise<LuaEngine>;
+    lua: LuaEngine | null;
+    on_ready_callbacks: {
+        [key: string]: (node: Node, engine: Engine) => void;
+    };
+    on_removed_callbacks: {
+        [key: string]: (node: Node, engine: Engine, parent: Node) => void;
+    };
+    on_update_callbacks: {
+        [key: string]: (node: Node, engine: Engine, time: number, delta_time: number) => void;
+    };
+    on_render_callbacks: {
+        [key: string]: (node: Node, engine: Engine, time: number, delta_time: number) => void;
+    };
+    constructor(engine: Engine);
+    call_on_ready_callback(url: string, node: Node, engine: Engine): void;
+    call_on_removed_callback(url: string, node: Node, engine: Engine, parent: Node): void;
+    call_on_update_callback(url: string, node: Node, engine: Engine, time: number, delta_time: number): void;
+    call_on_render_callback(url: string, node: Node, engine: Engine, time: number, delta_time: number): void;
+    private do_lua_file_url;
+    add_on_ready_callback(url: string): Promise<void>;
+    add_on_removed_callback(url: string): Promise<void>;
+    add_on_update_callback(url: string): Promise<void>;
+    add_on_render_callback(url: string): Promise<void>;
+    set_globals(): Promise<void>;
+}
+
+declare class Camera3D extends Node3D {
+    fov: number;
+    near_plane: number;
+    far_plane: number;
+    get_projection_matrix(canvas: HTMLCanvasElement): Mat4;
+    get_view_matrix(): Mat4;
+}
+
+declare class Scene {
+    name: string;
+    engine: Engine;
+    on_scene_start_callback: (engine: Engine, scene: Scene) => Promise<void>;
+    on_scene_update_callback: (engine: Engine, scene: Scene, time: number, delta_time: number) => void;
+    root_node: Node | null;
+    main_camera_3d: Camera3D | null;
+    rendering_depth_map: boolean;
+    constructor(engine: Engine, name: string, root_node?: Node | null, main_camera?: Camera3D | null);
+    get_node(name: string): Node | null;
+    private get_node_search;
+    update(time: number, delta_time: number): void;
+    render(view_matrix: Mat4, projection_matrix_3d: Mat4, projection_matrix_2d: Mat4, time: number, delta_time: number): void;
+}
+
+declare class Engine {
+    canvas: HTMLCanvasElement;
+    graphics_manager: GraphicsManager;
+    input_manager: InputManager;
+    hook_manager: HookManager;
+    main_scene: Scene;
+    on_global_start_callback: (engine: Engine) => Promise<void>;
+    on_global_update_callback: (engine: Engine, time: number, delta_time: number) => void;
+    UTIL: typeof Utility;
+    constructor(canvas: HTMLCanvasElement, main_scene?: Scene | null, on_global_start_callback?: (engine: Engine) => Promise<void>, on_global_update_callback?: (engine: Engine, time: number, delta_time: number) => void);
+    start(): Promise<void>;
+}
+
+type WebGLShaderType = number;
+declare enum WebGLUniformType {
+    TEXTURE_2D = 0,
+    TEXTURE_2D_ARRAY = 1,
+    TEXTURE_CUBE_MAP = 2,
+    SHADOW_2D = 3,
+    SHADOW_2D_ARRAY = 4,
+    SHADOW_CUBE_MAP = 5,
+    STRUCT = 6,
+    F = 7,
+    I = 8,
+    B = 9,
+    F2V = 10,
+    I2V = 11,
+    F3V = 12,
+    I3V = 13,
+    F4V = 14,
+    I4V = 15,
+    F2M = 16,
+    F3M = 17,
+    F4M = 18
+}
+interface WebGLUniform {
+    label: string;
+    type: WebGLUniformType;
+    is_array: boolean;
+    texture_unit?: number;
+}
+interface UBOParameter {
+    label: string;
+    index: number;
+    offset: number;
+}
+interface UBOBase {
+    webgl_buffer: WebGLBuffer;
+}
+interface UBOParameters {
+    [parameter: string]: UBOParameter;
+}
+type UBO = UBOBase & UBOParameters;
+declare class ShaderProgram {
+    gl: WebGLRenderingContext;
+    gm: GraphicsManager;
+    name: string;
+    shaders: Array<WebGLShader>;
+    webgl_shader_program: WebGLProgram | null;
+    uniforms: {
+        [key: string]: WebGLUniform;
+    };
+    uniform_locs: {
+        [key: string]: WebGLUniformLocation | null;
+    };
+    texture_counter: number;
+    ubo_counter: number;
+    ubos: {
+        [location: string]: UBO;
+    };
+    constructor(name: string, gm: GraphicsManager, gl: WebGLRenderingContext);
+    add_shader(type: WebGLShaderType, source: string): void;
+    add_uniform(label: string, uniform_type: WebGLUniformType): void;
+    build(): void;
+    use(): void;
+}
+
+declare enum TextureType {
+    COLOR = "COLOR",
+    DEPTH = "DEPTH",
+    COLOR_ARRAY = "COLOR_ARRAY",
+    DEPTH_ARRAY = "DEPTH_ARRAY"
+}
+declare class Texture implements Disposable {
+    gm: GraphicsManager;
+    name: string;
+    webgl_texture: WebGLTexture;
+    texture_type: TextureType;
+    internal_format: number;
+    format: number;
+    image_type: number;
+    width: number;
+    height: number;
+    image_array_size: number;
+    mip_level: number;
+    texture_parameters: {
+        [parameter_name: number]: number;
+    };
+    constructor(gm: GraphicsManager, name: string, width: number, height: number, texture_type: TextureType);
+    constructor(gm: GraphicsManager, name: string, width: number, height: number, texture_type: TextureType, texture_parameters: {
+        [parameter_name: number]: number;
+    });
+    constructor(gm: GraphicsManager, name: string, width: number, height: number, texture_type: TextureType, texture_parameters: {
+        [parameter_name: number]: number;
+    }, image_type: number);
+    constructor(gm: GraphicsManager, name: string, images: number, width: number, height: number, texture_type: TextureType);
+    constructor(gm: GraphicsManager, name: string, images: number, width: number, height: number, texture_type: TextureType, texture_parameters: {
+        [parameter_name: number]: number;
+    });
+    constructor(gm: GraphicsManager, name: string, images: number, width: number, height: number, texture_type: TextureType, texture_parameters: {
+        [parameter_name: number]: number;
+    }, mip_level: number);
+    constructor(gm: GraphicsManager, name: string, images: number, width: number, height: number, texture_type: TextureType, texture_parameters: {
+        [parameter_name: number]: number;
+    }, mip_level: number, image_type: number);
+    constructor(gm: GraphicsManager, name: string, images: TexImageSource[] | number, texture_type: TextureType, texture_parameters: {
+        [parameter_name: number]: number;
+    });
+    constructor(gm: GraphicsManager, name: string, images: TexImageSource[] | number, texture_type: TextureType, texture_parameters: {
+        [parameter_name: number]: number;
+    }, mip_level: number);
+    constructor(gm: GraphicsManager, name: string, images: TexImageSource[] | number, texture_type: TextureType, texture_parameters: {
+        [parameter_name: number]: number;
+    }, mip_level: number, image_type: number);
+    constructor(gm: GraphicsManager, name: string, image: TexImageSource, texture_type: TextureType, texture_parameters: {
+        [parameter_name: number]: number;
+    });
+    constructor(gm: GraphicsManager, name: string, image: TexImageSource, texture_type: TextureType, texture_parameters: {
+        [parameter_name: number]: number;
+    }, mip_level: number);
+    constructor(gm: GraphicsManager, name: string, image: TexImageSource, texture_type: TextureType, texture_parameters: {
+        [parameter_name: number]: number;
+    }, mip_level: number, image_type: number);
+    resize_texture_array(new_size: number): void;
+    [Symbol.dispose](): void;
+    private create_texture;
+    private create_depth_array_texture;
+    private create_color_array_texture;
+    private create_color_texture;
+    private create_depth_texture;
+}
+declare class CubeMapTexture implements Disposable {
+    gm: GraphicsManager;
+    name: string;
+    webgl_texture: WebGLTexture;
+    size: number;
+    constructor(gm: GraphicsManager, name: string, size: number, texture_type: TextureType);
+    constructor(gm: GraphicsManager, name: string, size: number, texture_type: TextureType, mip_level: number);
+    constructor(gm: GraphicsManager, name: string, size: number, texture_type: TextureType, mip_level: number, image_type: number);
+    constructor(gm: GraphicsManager, name: string, size: number, texture_type: TextureType, mip_level: number, image_type: number, texture_parameters: {
+        [parameter_name: number]: number;
+    });
+    constructor(gm: GraphicsManager, name: string, size: number, texture_type: TextureType, image_top: TexImageSource | Float32Array, image_bottom: TexImageSource | Float32Array, image_front: TexImageSource | Float32Array, image_back: TexImageSource | Float32Array, image_left: TexImageSource | Float32Array, image_right: TexImageSource | Float32Array, texture_parameters: {
+        [parameter_name: number]: number;
+    }, mip_level: number);
+    constructor(gm: GraphicsManager, name: string, size: number, texture_type: TextureType, image_top: TexImageSource | Float32Array, image_bottom: TexImageSource | Float32Array, image_front: TexImageSource | Float32Array, image_back: TexImageSource | Float32Array, image_left: TexImageSource | Float32Array, image_right: TexImageSource | Float32Array, texture_parameters: {
+        [parameter_name: number]: number;
+    }, mip_level: number, image_type: number);
+    constructor(gm: GraphicsManager, name: string, texture_type: TextureType, image_top: TexImageSource | Float32Array, image_bottom: TexImageSource | Float32Array, image_front: TexImageSource | Float32Array, image_back: TexImageSource | Float32Array, image_left: TexImageSource | Float32Array, image_right: TexImageSource | Float32Array, texture_parameters: {
+        [parameter_name: number]: number;
+    }, mip_level: number);
+    constructor(gm: GraphicsManager, name: string, texture_type: TextureType, image_top: TexImageSource | Float32Array, image_bottom: TexImageSource | Float32Array, image_front: TexImageSource | Float32Array, image_back: TexImageSource | Float32Array, image_left: TexImageSource | Float32Array, image_right: TexImageSource | Float32Array, texture_parameters: {
+        [parameter_name: number]: number;
+    }, mip_level: number, image_type: number);
+    [Symbol.dispose](): void;
+    private create_depth_texture;
+    private create_texture;
+}
+
+declare enum AttachmentType {
+    TEXTURE_COLOR = "TEXTURE_COLOR",
+    TEXTURE_DEPTH = "TEXTURE_DEPTH",
+    TEXTURE_STENCIL = "TEXTURE_STENCIL",
+    TEXTURE_DEPTH_STENCIL = "TEXTURE_DEPTH_STENCIL",
+    TEXTURE_ARRAY_COLOR = "TEXTURE_ARRAY_COLOR",
+    TEXTURE_ARRAY_DEPTH = "TEXTURE_ARRAY_DEPTH",
+    TEXTURE_ARRAY_STENCIL = "TEXTURE_ARRAY_STENCIL",
+    TEXTURE_ARRAY_DEPTH_STENCIL = "TEXTURE_ARRAY_DEPTH_STENCIL",
+    CUBEMAP_TEXTURE_COLOR = "CUBEMAP_TEXTURE_COLOR",
+    CUBEMAP_TEXTURE_DEPTH = "CUBEMAP_TEXTURE_DEPTH",
+    CUBEMAP_TEXTURE_STENCIL = "CUBEMAP_TEXTURE_STENCIL",
+    CUBEMAP_TEXTURE_DEPTH_STENCIL = "CUBEMAP_TEXTURE_DEPTH_STENCIL"
+}
+interface AttachmentInfo {
+    name: string;
+    type: AttachmentType;
+    texture: Texture | CubeMapTexture;
+    texture_array_index?: number;
+    mipmap_level?: number;
+    texture_parameters?: {
+        [key: number]: number;
+    };
+    buffer_source?: boolean;
+    color_attachment_number?: number;
+}
+declare enum DrawFlag {
+    DEPTH_TEST = 0,
+    CULL_FRONT = 1,
+    CULL_BACK = 2,
+    CULL_FRONT_AND_BACK = 4,
+    DEPTH_FUNC_NEVER = 8,
+    DEPTH_FUNC_LESS = 16,
+    DEPTH_FUNC_EQUAL = 32,
+    DEPTH_FUNC_LESS_EQUAL = 64,
+    DEPTH_FUNC_GREATER = 128,
+    DEPTH_FUNC_NOT_EQUAL = 256,
+    DEPTH_FUNC_GREATER_EQUAL = 512,
+    DEPTH_FUNC_ALWAYS = 1024,
+    FORCE_WRITE_DEPTH = 2048
+}
+type DrawBitFlags = number;
+declare function has_flag(bit_flag: DrawBitFlags, flag: DrawFlag): boolean;
+declare class Framebuffer implements Disposable {
+    name: string;
+    gl: WebGL2RenderingContext;
+    gm: GraphicsManager;
+    clear_color: Vec4;
+    width: number;
+    height: number;
+    webgl_frame_buffer: WebGLFramebuffer;
+    attachment_info_map: {
+        [key: string]: AttachmentInfo;
+    };
+    use_depth_buffer: boolean;
+    use_color_buffer: boolean;
+    color_attachment_count: number;
+    read_source_color_attachment: number;
+    draw_flags: DrawBitFlags;
+    constructor(name: string, gm: GraphicsManager, gl: WebGL2RenderingContext, attachment_infos: AttachmentInfo[], draw_flags: DrawBitFlags, clear_color?: Vec4, read_from_back_buffer?: boolean);
+    [Symbol.dispose](): void;
+    set_attachment_texture_index(attachment_name: string, index: number): void;
+    clear(): void;
+    set_attachment_cube_map_texture_face(attachment_name: string, face: number): void;
+    private create_attachment;
+    private create_attachment_depth_array_texture;
+    private create_attachment_color_array_texture;
+    private create_attachment_color_texture;
+    private create_attachment_depth_texture;
+    private create_attachment_color_cubemap_texture;
+    private create_attachment_depth_cubemap_texture;
+    use(): void;
+}
+
+declare class Light extends Node3D {
+    color: Vec3;
+    ambient: number;
+    diffuse: number;
+    specular: number;
+    energy: number;
+    constructor(engine: Engine, name: string, color: Vec3, ambient: number, diffuse: number, specular: number, energy: number);
+    set_shader_uniforms(shader_program: ShaderProgram, array_name: string, index: number): void;
+    set_uniforms(array_name: string, index: number): void;
+}
+
+declare class PointLight extends Light {
+    private stored_range;
+    shadow_index_offset: number;
+    shader_program: ShaderProgram;
+    framebuffer: Framebuffer;
+    shadow_projection: Mat4;
+    parent_world_matrix: Mat4;
+    point_light_space_matrices: Mat4[];
+    constructor(engine: Engine, name: string, color: Vec3, ambient: number, diffuse: number, specular: number, energy: number, range: number, shader_program?: ShaderProgram | null);
+    get range(): number;
+    set range(value: number);
+    private update_lsms;
+    protected on_change_range(value: number): void;
+    protected on_change_position(new_value: Vec3): void;
+    draw_shadow_map(view_matrix: Mat4, projection_matrix_3d: Mat4, projection_matrix_2d: Mat4, time: number, delta_time: number): void;
+    set_uniforms(array_name: string, index: number): void;
+    protected on_parented(): void;
+    protected on_removed(node: this, engine: Engine, parent: Node): void;
+}
+
+declare class DirectionalLight extends Light {
+    shader_program: ShaderProgram;
+    shadow_index: number;
+    framebuffer: Framebuffer;
+    directional_light_space_matrix: Mat4;
+    constructor(engine: Engine, name: string, color: Vec3, ambient: number, diffuse: number, specular: number, energy: number, shader_program?: ShaderProgram | null);
+    draw_shadow_map(view_matrix: Mat4, projection_matrix_3d: Mat4, projection_matrix_2d: Mat4, time: number, delta_time: number): void;
+    set_uniforms(array_name: string, index: number): void;
+    protected on_parented(): void;
+    protected on_removed(node: this, engine: Engine, parent: Node): void;
+    get_frustum_corners_world_space(projection_matrix: Mat4, view_matrix: Mat4): Vec4[];
+    get_light_space_matrix(light_dir: Vec3, corners: Vec4[]): Mat4;
+}
+
+declare class SpotLight extends Light {
+    range: number;
+    cookie_radius: number;
+    constructor(engine: Engine, name: string, color: Vec3, ambient: number, diffuse: number, specular: number, energy: number, range: number, cookie_radius: number);
+    set_uniforms(array_name: string, index: number): void;
+    protected on_parented(): void;
+    protected on_removed(node: this, engine: Engine, parent: Node): void;
+}
+
+type WebGLType = number;
+interface WebGLVertexAttribute {
+    label: string;
+    attribute_type: WebGLType;
+    size: number;
+    normalized: boolean;
+    dynamic: boolean;
+    vertex_buffer: WebGLBuffer;
+}
+declare class GraphicsManager {
+    engine: Engine;
+    canvas: HTMLCanvasElement;
+    gl: WebGL2RenderingContext;
+    shader_programs: {
+        [key: string]: ShaderProgram;
+    };
+    shader_program: ShaderProgram | null;
+    framebuffers: {
+        [key: string]: Framebuffer;
+    };
+    framebuffer: Framebuffer | null;
+    vertex_attributes: {
+        [key: string]: WebGLVertexAttribute;
+    };
+    vertex_count: number;
+    private last_frame_time;
+    default_2d_shader_program: ShaderProgram;
+    default_3d_shader_program: ShaderProgram;
+    default_skybox_shader_program: ShaderProgram;
+    point_lights: PointLight[];
+    directional_lights: DirectionalLight[];
+    spot_lights: SpotLight[];
+    directional_light_shadow_map_texture: Texture;
+    point_light_shadow_map_texture: Texture;
+    point_shadow_depth_buffer: Framebuffer;
+    directional_shadow_depth_buffer: Framebuffer;
+    shadow_resolution: number;
+    constructor(engine: Engine, canvas: HTMLCanvasElement);
+    webgl_enabled(): boolean;
+    add_vertex_attribute(label: string, attribute_type: WebGLType, size: number, initial_data: Float32Array, normalized?: boolean, dynamic?: boolean): void;
+    remove_vertex_attribute(label: string): void;
+    set_vertex_attribute_data(label: string, data: Float32Array, offset?: number): void;
+    create_shader_program(name: string): ShaderProgram;
+    use_shader(name: string): void;
+    clear_shader(): void;
+    create_framebuffer(name: string, attachment_info: AttachmentInfo[], draw_flags: DrawBitFlags): Framebuffer;
+    use_framebuffer(name: string): void;
+    unuse_framebuffer(): void;
+    set_uniform(label: string, value: any, transpose?: boolean, warn?: boolean): void;
+    static flatten_uniform_array_value(array_value: (Vec2 | Vec3 | Vec4 | Mat2 | Mat3 | Mat4 | number)[]): Float32Array;
+    resize_directional_shadow_map(): void;
+    resize_point_shadow_map(): void;
+    private resize_canvas;
+    render(): void;
+    private render_frame;
+    create_default_2d_shader_program(): ShaderProgram;
+    create_default_3d_shader_program(): ShaderProgram;
+    create_default_skybox_shader_program(): ShaderProgram;
+    create_default_directional_shadow_shader_program(): ShaderProgram;
+    create_default_point_shadow_shader_program(): ShaderProgram;
+}
+
+interface MaterialOptionsObject {
+    enable_depth_test?: boolean;
+    blend_function?: {
+        sfactor: GLenum;
+        dfactor: GLenum;
+    };
+}
+declare class Material {
+    gm: GraphicsManager;
+    name: string;
+    shader_program: ShaderProgram | null;
+    albedo: Vec3 | Texture;
+    metalic: number | Texture;
+    roughness: number | Texture;
+    ao: number | Texture;
+    normal: Texture | null;
+    enable_depth_test?: boolean;
+    blend_function?: {
+        sfactor: GLenum;
+        dfactor: GLenum;
+    };
+    constructor(gm: GraphicsManager, name: string, albedo: Vec3 | Texture, metalic: number | Texture, roughness: number | Texture, ao: number | Texture, normal?: Texture | null, shader_program?: string | ShaderProgram | null, options?: MaterialOptionsObject);
+    set_shader_program(shader_program: string | ShaderProgram): void;
+    set_shader_uniforms(shader_program: ShaderProgram): void;
+    set_uniforms(): void;
+    draw_start(set_uniforms?: boolean): void;
+    draw_end(): void;
+}
+
+declare class Mesh {
+    gm: GraphicsManager;
+    vao: WebGLVertexArrayObject;
+    vertexCount: number;
+    indexCount: number;
+    dimensions: Vec3;
+    center: Vec3;
+    constructor(gm: GraphicsManager, vertices: Float32Array | number[], // xyz
+    normals: Float32Array | number[], // xyz
+    uvs: Float32Array | number[], // uv
+    indices: Uint16Array | number[], // triangle indices
+    dimensions: Vec3, center: Vec3);
+    draw(): void;
+}
+
+declare class Model {
+    gm: GraphicsManager;
+    name: string;
+    mesh: Mesh;
+    material: Material;
+    constructor(gm: GraphicsManager, name: string, mesh: Mesh, material: Material);
+    draw_start(): void;
+    draw_end(): void;
+}
+
+declare namespace AssetFile {
+    namespace OBJ {
+        interface Data {
+            temp?: {
+                vertices: number[][];
+                normals: number[][];
+                uvs: number[][];
+                min_x: number;
+                min_y: number;
+                min_z: number;
+                max_x: number;
+                max_y: number;
+                max_z: number;
+                vertex_map: Map<string, number>;
+                vertices_final: number[];
+                normals_final: number[];
+                uvs_final: number[];
+                indices_final: number[];
+            };
+            vertices: Float32Array;
+            normals: Float32Array;
+            uvs: Float32Array;
+            indices: Uint16Array;
+            dimensions: Vec3;
+            center: Vec3;
+        }
+        enum BumpChannel {
+            RED = "r",
+            GREEN = "g",
+            BLUE = "b",
+            MATTE = "m",
+            LUMINANCE = "l",
+            Z_DEPTH = "z"
+        }
+        enum ReflectionMapType {
+            SPHERE = "sphere",
+            CUBE_TOP = "cube_top",
+            CUBE_BOTTOM = "cube_bottom",
+            CUBE_FRONT = "cube_front",
+            CUBE_BACK = "cube_back",
+            CUBE_LEFT = "cube_left",
+            CUBE_RIGHT = "cube_right"
+        }
+        interface TextureData {
+            name: string;
+            horizontal_blend?: boolean;
+            vertical_blend?: boolean;
+            mip_map_sharpness_boost?: number;
+            additive_color_offset?: number;
+            contrast_multiplier?: number;
+            offset?: Vec3;
+            scale?: Vec3;
+            turbulence?: Vec3;
+            generated_texture_resolution?: number;
+            clamp?: boolean;
+            bump_multiplier?: number;
+            bump_channel?: BumpChannel;
+            reflection_map_type?: ReflectionMapType;
+        }
+        enum IlluminationModel {
+            COLOR_ON_AMBIENT_OFF = 0,
+            COLOR_ON_AMBIENT_ON = 1,
+            HIGHLIGHT_ON = 2,
+            REFLECTION_ON_RAY_TRACE_ON = 3,
+            TRANSPARENCY_GLASS_ON__REFLECTION_RAY_TRACE_ON = 4,
+            REFLECTION_FRESNEL_ON_RAY_TRACE_ON = 5,
+            TRANSPARENCY_REFRACTION_ON__REFLECTION_FRESNEL_OFF_RAY_TRACE_ON = 6,
+            TRANSPARENCY_REFRACTION_ON__REFLECTION_FRESNEL_ON_RAY_TRACE_ON = 7,
+            REFLECTION_ON_RAY_TRACE_OFF = 8,
+            TRANSPARENCY_GLASS_ON__REFLECTION_RAY_TRACE_OFF = 9,
+            CAST_SHADOWS_ON_INVISIBLE_SURFACES = 10
+        }
+        interface MaterialData {
+            name: string;
+            ambient_color?: Vec3;
+            diffuse_color?: Vec3;
+            specular_color?: Vec3;
+            specular_exponent?: number;
+            transparency?: number;
+            transmission_filter_color?: Vec3;
+            transmission_filter_xyz?: boolean;
+            optical_density?: number;
+            illumination_model?: IlluminationModel;
+            ambient_texture?: TextureData;
+            diffuse_texture?: TextureData;
+            specular_color_texture?: TextureData;
+            specular_highlight_texture?: TextureData;
+            alpha_texture?: TextureData;
+            bump_texture?: TextureData;
+            displacement_texture?: TextureData;
+            decal_texture?: TextureData;
+            reflection_textures?: TextureData[];
+            roughness_texture?: TextureData;
+            metalic_texture?: TextureData;
+            sheen_texture?: TextureData;
+            roughness?: number;
+            metalic?: number;
+            sheen?: number;
+            clearcoat_thickness?: number;
+            clearcoat_roughness?: number;
+            emissive_texture?: TextureData;
+            emissive?: number;
+            anisotropy?: number;
+            anisotropy_rotation?: number;
+            normal_texture?: TextureData;
+        }
+        interface Object {
+            name: string;
+            data?: Data;
+            material?: string;
+            groups: Group[];
+        }
+        interface Group {
+            name: string;
+            data: Data;
+            material?: string;
+        }
+        function load_obj(engine: Engine, obj_path: string, image_assets_path: string): Promise<Node3D>;
+    }
+}
+declare function load_obj(gm: GraphicsManager, model_path: string, image_asset_paths: string[]): Promise<Model | null>;
+
+interface VAOInfo {
+    vao: WebGLVertexArrayObject;
+    index_count: number;
+    vertex_count: number;
+}
+declare function get_skybox_vao(gm: GraphicsManager): VAOInfo;
+declare function get_sprite_vao(gm: GraphicsManager): VAOInfo;
+
+declare class Object3D extends Node3D {
+    model: Model;
+    constructor(engine: Engine, name: string, model: Model);
+    render_class(view_matrix: Mat4, projection_matrix_3d: Mat4, projection_matrix_2d: Mat4, time: number, delta_time: number): void;
+}
+
+declare class Skybox extends Node {
+    vao: VAOInfo;
+    shader_program: ShaderProgram;
+    cubemap_texture: CubeMapTexture;
+    ambient_light: Vec3;
+    constructor(engine: Engine, name: string, cubemap_texture: CubeMapTexture, ambient_light: Vec3, shader_program?: ShaderProgram | null);
+    render_class(view_matrix: Mat4, projection_matrix_3d: Mat4, projection_matrix_2d: Mat4, time: number, delta_time: number): void;
+}
+
+declare class Sprite2D extends Node2D {
+    shader_program: ShaderProgram;
+    vao: VAOInfo;
+    sprite_texture: Texture;
+    constructor(engine: Engine, name: string, sprite_texture: Texture, shader_program?: ShaderProgram | null);
+    render_class(view_matrix: Mat4, projection_matrix_3d: Mat4, projection_matrix_2d: Mat4, time: number, delta_time: number): void;
+}
+
+declare function degrees_to_radians(degrees: number): number;
+declare function get_uniform_label_index(raw_label: string): number;
+declare function normalize_uniform_label(raw_label: string): string;
+declare function parse_path(p: string): {
+    root: string;
+    dir: string;
+    base: string;
+    ext: string;
+    name: string;
+};
+declare function join_path(...parts: string[]): string;
+declare function basename_path(path: string, ext?: string): string;
+declare function dirname_path(path: string): string;
+
+export { AssetFile, type AttachmentInfo, AttachmentType, Camera3D, CubeMapTexture, DirectionalLight, type DrawBitFlags, DrawFlag, Framebuffer, GraphicsManager, HookManager, InputManager, Light, Material, type MaterialOptionsObject, Mesh, Model, MouseButton, Node, Node2D, Node3D, Object3D, PointLight, Scene, ShaderProgram, Skybox, SpotLight, Sprite2D, Texture, TextureType, type UBO, type VAOInfo, type WebGLShaderType, type WebGLType, type WebGLUniform, WebGLUniformType, type WebGLVertexAttribute, basename_path, Engine as default, degrees_to_radians, dirname_path, get_skybox_vao, get_sprite_vao, get_uniform_label_index, has_flag, join_path, load_obj, normalize_uniform_label, parse_path };