ris-framework 0.1.0-dev.6 → 0.1.0-dev.9

package/dist/webgl/utilities/WebGlTextureUtilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebGlTextureUtilities.d.ts","sourceRoot":"","sources":["../../../src/webgl/utilities/WebGlTextureUtilities.ts"],"names":[],"mappings":"AACA,OAAO,EAAiB,aAAa,EAAC,MAAM,oBAAoB,CAAC;AACjE,OAAO,EAAC,IAAI,EAAC,MAAM,WAAW,CAAC;AAE/B;;GAEG;AACH,qBAAa,qBAAqB;IAE9B;;;;;;;;;;;OAWG;IACI,eAAe,CAClB,EAAE,EAAE,sBAAsB,EAC1B,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAC7B,IAAI,GAAE,UAAU,EAAE,GAAG,gBAAgB,EAAE,GAAG,IAAW,EACrD,aAAa,gBAA6B,EAC1C,UAAU,UAAQ,EAClB,UAAU,SAAM,EAChB,KAAK,GAAE,MAAM,GAAG,IAAW,GAC5B,YAAY;IA2Df;;;;;;;;;;OAUG;IACI,yBAAyB,CAC5B,EAAE,EAAE,sBAAsB,EAC1B,SAAS,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAChC,IAAI,GAAE,UAAU,EAAE,GAAG,IAAW,EAChC,KAAK,GAAE,MAAM,GAAG,IAAW,EAC3B,aAAa,gBAA6B,EAC1C,UAAU,SAAM,GACjB,YAAY;CAgElB"}

package/dist/webgl/utilities/WebGlUtilities.d.ts

@@ -0,0 +1,60 @@
+import { WebGLBlendingUtilities } from "./webgl-blending-utilities";
+import { WebGlBufferUtilities } from "./WebGlBufferUtilities.js";
+import { WebGLCullingUtilities } from "./webgl-culling-utilities";
+import { WebGLFilterAnisotropicUtilities } from "./webgl-filter-anisotropic-utilities";
+import { WebGlFrameBufferUtilities } from "./WebGlFrameBufferUtilities.js";
+import { WebGLProgramUtilities } from "./webgl-program-utilities";
+import { WebGLRenderbufferUtilities } from "./webgl-renderbuffer-utilities";
+import { WebGlSamplerUtilities } from "./WebGlSamplerUtilities.js";
+import { WebGlShaderUtilities } from "./WebGlShaderUtilities.js";
+import { WebGlTextureUtilities } from "./WebGlTextureUtilities.js";
+/**
+ * The utility class for WebGL operations.
+ */
+export declare class WebGlUtilities {
+    /**
+     * The WebGL blending utilities.
+     */
+    static readonly blending: WebGLBlendingUtilities;
+    /**
+     * The WebGL anisotropic filtering utilities.
+     */
+    static readonly anisotropy: WebGLFilterAnisotropicUtilities;
+    /**
+     * The WebGL culling utilities.
+     */
+    static readonly culling: WebGLCullingUtilities;
+    /**
+     * The WebGL texture utilities.
+     */
+    static readonly texture: WebGlTextureUtilities;
+    /**
+     * The WebGL framebuffer utilities.
+     */
+    static readonly framebuffer: WebGlFrameBufferUtilities;
+    /**
+     * The WebGL render buffer utilities.
+     */
+    static readonly renderbuffer: WebGLRenderbufferUtilities;
+    /**
+     * The WebGL buffer utilities.
+     */
+    static readonly buffer: WebGlBufferUtilities;
+    /**
+     * The WebGL render buffer utilities.
+     */
+    static readonly renderBuffer: WebGLRenderbufferUtilities;
+    /**
+     * The WebGL sampler utilities.
+     */
+    static readonly sampler: WebGlSamplerUtilities;
+    /**
+     * The WebGL shader utilities.
+     */
+    static readonly shader: WebGlShaderUtilities;
+    /**
+     * The WebGL program utilities.
+     */
+    static readonly program: WebGLProgramUtilities;
+}
+//# sourceMappingURL=WebGlUtilities.d.ts.map

package/dist/webgl/utilities/WebGlUtilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebGlUtilities.d.ts","sourceRoot":"","sources":["../../../src/webgl/utilities/WebGlUtilities.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,4BAA4B,CAAC;AACpE,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AACjE,OAAO,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AAClE,OAAO,EAAE,+BAA+B,EAAE,MAAM,sCAAsC,CAAC;AACvF,OAAO,EAAE,yBAAyB,EAAE,MAAM,gCAAgC,CAAC;AAC3E,OAAO,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AAClE,OAAO,EAAE,0BAA0B,EAAE,MAAM,gCAAgC,CAAC;AAC5E,OAAO,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AACnE,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AACjE,OAAO,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AAEnE;;GAEG;AACH,qBAAa,cAAc;IAEvB;;OAEG;IACH,gBAAuB,QAAQ,yBAAgC;IAE/D;;OAEG;IACH,gBAAuB,UAAU,kCAAyC;IAE1E;;OAEG;IACH,gBAAuB,OAAO,wBAA+B;IAE7D;;OAEG;IACH,gBAAuB,OAAO,wBAA+B;IAE7D;;OAEG;IACH,gBAAuB,WAAW,4BAAmC;IAErE;;OAEG;IACH,gBAAuB,YAAY,6BAAoC;IAEvE;;OAEG;IACH,gBAAuB,MAAM,uBAA8B;IAE3D;;OAEG;IACH,gBAAuB,YAAY,6BAAoC;IAEvE;;OAEG;IACH,gBAAuB,OAAO,wBAA+B;IAE7D;;OAEG;IACH,gBAAuB,MAAM,uBAA8B;IAE3D;;OAEG;IACH,gBAAuB,OAAO,wBAA+B;CAChE"}

package/dist/webgl/utilities/spector-js-utilities.d.ts

@@ -0,0 +1,9 @@
+export declare class SpectorJSUtilities {
+    /**
+     * Sets the label for a WebGL object to be used by Spector.js.
+     * @param target The WebGL object to set the label for (e.g., WebGLBuffer, WebGLTexture, WebGLFramebuffer, etc.).
+     * @param label The label to set for the WebGL object. This will be displayed in Spector.js for easier identification.
+     */
+    static setLabel(target: any, label: string): void;
+}
+//# sourceMappingURL=spector-js-utilities.d.ts.map

package/dist/webgl/utilities/spector-js-utilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spector-js-utilities.d.ts","sourceRoot":"","sources":["../../../src/webgl/utilities/spector-js-utilities.ts"],"names":[],"mappings":"AAAA,qBAAa,kBAAkB;IAE3B;;;;OAIG;WACW,QAAQ,CAAC,MAAM,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;CAK3D"}

package/dist/webgl/utilities/webgl-blending-utilities.d.ts

@@ -0,0 +1,17 @@
+/**
+ * The utility class for WebGL blending operations.
+ */
+export declare class WebGLBlendingUtilities {
+    /**
+     * Enables blending with the specified parameters.
+     * @param gl The WebGL2RenderingContext context.
+     * @param colorFunc The color function. By default, it is FUNC_ADD.
+     * @param srcColorFactor The source color factor. By default, it is SRC_ALPHA.
+     * @param dstColorFactor The destination color factor. By default, it is ONE_MINUS_SRC_ALPHA.
+     * @param alphaFunc The alpha function. By default, it is FUNC_ADD.
+     * @param srcAlphaFactor The source alpha factor. By default, it is SRC_ALPHA.
+     * @param dstAlphaFactor The destination alpha factor. By default, it is ONE_MINUS_SRC_ALPHA.
+     */
+    enableBlend(gl: WebGL2RenderingContext, colorFunc?: number | null, srcColorFactor?: number | null, dstColorFactor?: number | null, alphaFunc?: number | null, srcAlphaFactor?: number | null, dstAlphaFactor?: number | null): void;
+}
+//# sourceMappingURL=webgl-blending-utilities.d.ts.map

package/dist/webgl/utilities/webgl-blending-utilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webgl-blending-utilities.d.ts","sourceRoot":"","sources":["../../../src/webgl/utilities/webgl-blending-utilities.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,qBAAa,sBAAsB;IAC/B;;;;;;;;;OASG;IACI,WAAW,CACd,EAAE,EAAE,sBAAsB,EAC1B,SAAS,GAAE,MAAM,GAAG,IAAW,EAC/B,cAAc,GAAE,MAAM,GAAG,IAAW,EACpC,cAAc,GAAE,MAAM,GAAG,IAAW,EACpC,SAAS,GAAE,MAAM,GAAG,IAAW,EAC/B,cAAc,GAAE,MAAM,GAAG,IAAW,EACpC,cAAc,GAAE,MAAM,GAAG,IAAW,GACrC,IAAI;CA8DV"}

package/dist/webgl/utilities/webgl-culling-utilities.d.ts

@@ -0,0 +1,13 @@
+import { Culling } from "../../api/rendering/enums.js";
+/**
+ * The WebGL culling utilities.
+ */
+export declare class WebGLCullingUtilities {
+    /**
+     * Sets the culling mode.
+     * @param gl The WebGL2RenderingContext.
+     * @param culling The culling mode.
+     */
+    setCulling(gl: WebGL2RenderingContext, culling: Culling): void;
+}
+//# sourceMappingURL=webgl-culling-utilities.d.ts.map

package/dist/webgl/utilities/webgl-culling-utilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webgl-culling-utilities.d.ts","sourceRoot":"","sources":["../../../src/webgl/utilities/webgl-culling-utilities.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,8BAA8B,CAAC;AAGvD;;GAEG;AACH,qBAAa,qBAAqB;IAE9B;;;;OAIG;IACI,UAAU,CAAC,EAAE,EAAE,sBAAsB,EAAE,OAAO,EAAE,OAAO;CASjE"}

package/dist/webgl/utilities/webgl-filter-anisotropic-utilities.d.ts

@@ -0,0 +1,24 @@
+/**
+ * The utility class for WebGL anisotropic filtering operations.
+ */
+export declare class WebGLFilterAnisotropicUtilities {
+    /**
+     * The max anisotropy extension string.
+     */
+    private MAX_ANISOTROPY_EXT;
+    private _extension;
+    /**
+     * Gets the max anisotropy.
+     * @param gl The WebGL2 rendering context.
+     * @returns The maximum supported level of anisotropic filtering. `0` if not supported.
+     */
+    getMaxAnisotropy(gl: WebGL2RenderingContext): number;
+    /**
+     * Sets the anisotropy filtering level for texture.
+     * @param gl The WebGL2 rendering context.
+     * @param texture The WebGL texture.
+     * @param anisotropy The level of anisotropic filtering
+     */
+    setAnisotropy(gl: WebGL2RenderingContext, texture: WebGLTexture, anisotropy: number): void;
+}
+//# sourceMappingURL=webgl-filter-anisotropic-utilities.d.ts.map

package/dist/webgl/utilities/webgl-filter-anisotropic-utilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webgl-filter-anisotropic-utilities.d.ts","sourceRoot":"","sources":["../../../src/webgl/utilities/webgl-filter-anisotropic-utilities.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,qBAAa,+BAA+B;IACxC;;OAEG;IACH,OAAO,CAAC,kBAAkB,CAA4C;IAEtE,OAAO,CAAC,UAAU,CAAM;IAExB;;;;OAIG;IACI,gBAAgB,CAAC,EAAE,EAAE,sBAAsB,GAAG,MAAM;IAU3D;;;;;OAKG;IACI,aAAa,CAAC,EAAE,EAAE,sBAAsB,EAAE,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM;CAI7F"}

package/dist/webgl/utilities/webgl-program-utilities.d.ts

@@ -0,0 +1,14 @@
+/**
+ * This module provides utility functions for working with WebGL programs, such as creating and linking shader programs.
+ */
+export declare class WebGLProgramUtilities {
+    /**
+     * Creates a WebGL program with the given vertex shader and fragment shader.
+     * @param gl The WebGL2 rendering context.
+     * @param vertexShader The vertex shader to be attached to the program.
+     * @param fragmentShader The fragment shader to be attached to the program.
+     * @returns The linked WebGLProgram object.
+     */
+    create(gl: WebGL2RenderingContext, vertexShader: WebGLShader, fragmentShader: WebGLShader): WebGLProgram;
+}
+//# sourceMappingURL=webgl-program-utilities.d.ts.map

package/dist/webgl/utilities/webgl-program-utilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webgl-program-utilities.d.ts","sourceRoot":"","sources":["../../../src/webgl/utilities/webgl-program-utilities.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,qBAAa,qBAAqB;IAE9B;;;;;;OAMG;IACI,MAAM,CAAC,EAAE,EAAE,sBAAsB,EAAE,YAAY,EAAE,WAAW,EAAE,cAAc,EAAE,WAAW,GAAG,YAAY;CAgBlH"}

package/dist/webgl/utilities/webgl-renderbuffer-utilities.d.ts

@@ -0,0 +1,17 @@
+import type { TextureFormat } from "../../api/index.js";
+/**
+ * The utility class for WebGL render buffer operations. It provides methods for creating render buffers with specified formats, dimensions, and labels. Render buffers are used in WebGL for off-screen rendering, particularly for depth and stencil attachments in framebuffers. This class abstracts the details of creating and configuring render buffers, making it easier to manage them in a WebGL application.
+ */
+export declare class WebGLRenderbufferUtilities {
+    /**
+     * Creates a render buffer with the specified internal format, width, height, and label.
+     * @param gl The WebGL2 rendering context.
+     * @param internalFormat The internal format of the render buffer, which determines the type of data stored in the buffer (e.g., depth, stencil, or depth-stencil).
+     * @param width The width of the render buffer in pixels.
+     * @param height The height of the render buffer in pixels.
+     * @param label The label of the render buffer, which can be used for debugging purposes. It is optional and can be null or undefined.
+     * @returns The created WebGLRenderbuffer object.
+     */
+    create(gl: WebGL2RenderingContext, internalFormat: TextureFormat, width: number, height: number, label: string | null | undefined): WebGLRenderbuffer;
+}
+//# sourceMappingURL=webgl-renderbuffer-utilities.d.ts.map

package/dist/webgl/utilities/webgl-renderbuffer-utilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webgl-renderbuffer-utilities.d.ts","sourceRoot":"","sources":["../../../src/webgl/utilities/webgl-renderbuffer-utilities.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAIxD;;GAEG;AACH,qBAAa,0BAA0B;IACnC;;;;;;;;OAQG;IACI,MAAM,CAAC,EAAE,EAAE,sBAAsB,EAAE,cAAc,EAAE,aAAa,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,iBAAiB;CAiB/J"}

package/package.json

@@ -1,44 +1,51 @@
 {
   "name": "ris-framework",
-  "version": "0.1.0-dev.6",
+  "version": "0.1.0-dev.9",
+  "license": "Apache-2.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/luka712/ris-framework-ts"
   },
   "type": "module",
-  "main": "./src/index.ts",
-  "types": "./src/index.ts",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "types": "./src/index.ts",
-      "import": "./src/index.ts",
-      "default": "./src/index.ts"
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
     }
   },
   "scripts": {
     "dev": "vite",
-    "build": "tsc && vite build",
+    "build": "tsc --noEmit && npm run build:lib && npm run build:app",
+    "build:lib": "rm -rf dist && vite build --config vite.lib.config.ts && tsc -p tsconfig.lib.json && node scripts/rewrite-declaration-extensions.mjs",
+    "build:app": "vite build",
     "preview": "vite preview",
-    "test": "tsc --noEmit"
+    "test": "tsc --noEmit && tsc -p tsconfig.test.json --noEmit && vitest run"
   },
   "devDependencies": {
     "typescript": "~5.9.3",
-    "vite": "^7.2.4"
+    "vite": "^7.2.4",
+    "vitest": "^5.0.3"
   },
   "dependencies": {
     "gl-matrix": "^3.4.4",
     "reflect-metadata": "^0.2.2",
-    "ris-framework-api": "0.1.0-dev.5",
-    "ris-ktx2": "^0.1.0-dev.2",
+    "ris-ktx2": "^0.1.0",
     "tsyringe": "^4.10.0"
   },
   "files": [
     "dist",
     "src",
     "shaders",
+    "LICENSES",
     "LICENSE",
+    "NOTICE",
     "README.md",
-    "CHANGELOG.md"
+    "CHANGELOG.md",
+    "THIRD_PARTY_NOTICES.md"
   ],
   "publishConfig": {
     "access": "public"

package/shaders/glsl/sprite_fs.glsl

@@ -10,5 +10,5 @@ uniform sampler2D u_texture;
 
 void main()
 {
-    o_outputColor = texture(u_texture, v_texCoords) * v_color;
+    o_outputColor = texture(u_texture, v_texCoords) * v_color + vec4(1.0);
 }

package/src/{core/Framework.ts → Framework.ts}

@@ -1,32 +1,50 @@
 import {container, type DependencyContainer} from "tsyringe";
-import {WindowManager} from "./window/window-manager.ts";
-import {FrameworkConfig} from "./FrameworkConfig.ts";
-import {IFrameworkSymbol} from "./dependency-injection/register-services-interface.ts";
-import { RenderConfiguration, RenderConfigurationSymbol} from "./renderer/renderer-interface.ts";
-import {GeometryBuilder} from "../geometry/GeometryBuilder.ts";
-import {ContentManager} from "./content/ContentManager.ts";
-import {WebGlRenderer} from "../webgl/WebGlRenderer.ts";
-import {WebGlBuffersFactory} from "../webgl/buffers/WebGlBuffersFactory.ts";
+import {WindowManager} from "./api/window/WindowManager.ts";
+import {FrameworkConfiguration} from "./api/FrameworkConfiguration.ts";
+import {type IRendererConfiguration, RenderConfigurationSymbol} from "./api/rendering/renderer-interface.ts";
+import {GeometryBuilder} from "./api/geometry/GeometryBuilder.ts";
+import {ContentManager} from "./api/content/ContentManager.ts";
+import {WebGlRenderer} from "./webgl/WebGlRenderer.ts";
+import {WebGlBuffersFactory} from "./webgl/buffers/WebGlBuffersFactory.ts";
 import {
-    CameraFactory, CpuImageProcessor, GameTime,
-    type IBufferFactory, type IGeometryBuilder, type IGraphicsDevice, type IImageProcessor, type IInputManager,
+    type ICameraFactory,
+    type IContentManager,
+    type IFramework, IFrameworkConfiguration,
+    type IImageLoader,
+    type IRenderer,
+    type IRenderPipelineFactory,
+    type IWindowManager
+} from "./api/index.ts";
+import {
+    CameraFactory,
+    CpuImageProcessor,
+    GameTime,
+    type IBufferFactory,
+    type IGeometryBuilder,
+    type IGraphicsDevice,
+    type IImageProcessor,
+    type IInputManager,
     ImageLoader,
-    type IMeshFactory, type ISpriteBatch, type ITextureFactory, type ITimeManager, RenderingBackend, TimeManager
-} from "ris-framework-api";
-import {WebGlShaderModuleLoader} from "../webgl/shader/WebGlShaderModuleLoader.ts";
-import {TextureSamplerFilteringPreset} from "./rendering/enums.ts";
-import {SpriteBatch} from "./sprite-batch/SpriteBatch.ts";
-import type {ICameraFactory, IContentManager, IFramework, IImageLoader,
-    IRenderer,
-    IWindowManager
-} from "ris-framework-api";
-import {WebGlTextureFactory} from "../webgl/texture/WebGlTextureFactory.ts";
-import {WebGlRenderPipelineFactory} from "../webgl/render-pipelines/WebGlRenderPipelineFactory.ts";
-import type {IRenderPipelineFactory} from "ris-framework-api";
-import {MeshFactory, type IMaterialFactory, MaterialFactory} from "ris-framework-api";
-import {InputManager} from "./input/InputManager.ts";
+    type IMaterialFactory,
+    type IMeshFactory,
+    type ISpriteBatch,
+    type ITextureFactory,
+    type ITimeManager,
+    MaterialFactory,
+    MeshFactory,
+    RenderingBackend,
+    TimeManager
+} from "./api/index.ts";
+import {WebGlShaderModuleLoader} from "./webgl/shader/WebGlShaderModuleLoader.ts";
+import {TextureSamplerFilteringPreset} from "./core/rendering/enums.ts";
+import {SpriteBatch} from "./api/sprites/SpriteBatch.ts";
+import {WebGlTextureFactory} from "./webgl/texture/WebGlTextureFactory.ts";
+import {WebGlRenderPipelineFactory} from "./webgl/render-pipelines/WebGlRenderPipelineFactory.ts";
+import {InputManager} from "./api/input/InputManager.ts";
+import type {IKtx2Factory} from "ris-ktx2";
 import {Ktx2Factory} from "ris-ktx2";
-import type {IKtx2Factory} from "ris-ktx2-api";
+import {PowerPreferenceType} from "./api/rendering/PowerPreference.ts";
+import {vec2} from "gl-matrix";
 
 export class Framework implements IFramework {
 
@@ -44,19 +62,27 @@ export class Framework implements IFramework {
 
     /**
      * The constructor for the Framework class.
-     * @param options The optional options for them framework.
+     * @param options The optional framework configuration. When omitted, a default `FrameworkConfiguration` is used.
      */
-    constructor(options: FrameworkConfig | null = null) {
-        options = options ?? new FrameworkConfig();
+    constructor(options?: IFrameworkConfiguration) {
+        options = options ?? new FrameworkConfiguration();
+
+        // Without a canvas, WindowManager creates one and appends it to document.body.
+        if(!options.canvas){
+            console.warn("Canvas not provided. Creating canvas and appending it to document.body.")
+        }
+        options.backBufferSize = options.backBufferSize ?? vec2.fromValues(800, 600);
 
         this._container = container.createChildContainer();
-        this.windowManager = new WindowManager(options.canvas);
+        this.windowManager = new WindowManager(options.canvas ?? null);
 
         // Setup container.
-        this._container.registerInstance(IFrameworkSymbol, this);
-        const rendererConfig = new RenderConfiguration();
-        rendererConfig.backBufferSize = options.backBufferSize;
-        rendererConfig.textureFiltering = options.textureFiltering ?? TextureSamplerFilteringPreset.BILINEAR;
+        const rendererConfig: IRendererConfiguration = {
+            backBufferSize: options.backBufferSize,
+            textureFiltering: options.textureFiltering ?? TextureSamplerFilteringPreset.BILINEAR,
+            alpha: options.alpha ?? false,
+            powerPreference: options.powerPreference ?? PowerPreferenceType.DEFAULT
+        };
         this._container.registerInstance(RenderConfigurationSymbol, rendererConfig);
         this.renderer = new WebGlRenderer(this, rendererConfig);
         this.renderingBackend = RenderingBackend.WEB_GL;
@@ -107,7 +133,7 @@ export class Framework implements IFramework {
 
     /** @inheritDoc */
     public removeOnInitializedListener(event: () => void): void {
-        this._onInitializeListeners.splice(this._onInitializeListeners.indexOf(event), 1);
+        Framework._removeListener(this._onInitializeListeners, event);
     }
 
     /** @inheritdoc */
@@ -117,7 +143,7 @@ export class Framework implements IFramework {
 
     /** @inheritdoc */
     public removeOnLoadContentListener(event: () => void): void {
-        this._onLoadContentListeners.splice(this._onLoadContentListeners.indexOf(event), 1);
+        Framework._removeListener(this._onLoadContentListeners, event);
     }
 
     /** @inheritdoc */
@@ -127,7 +153,7 @@ export class Framework implements IFramework {
 
     /** @inheritdoc */
     public removeOnUpdateListener(event: (gameTime: GameTime) => void): void {
-        this._onUpdateListeners.splice(this._onUpdateListeners.indexOf(event), 1);
+        Framework._removeListener(this._onUpdateListeners, event);
     }
 
     /** @inheritdoc */
@@ -137,7 +163,18 @@ export class Framework implements IFramework {
 
     /** @inheritdoc */
     public removeOnRenderListener(event: () => void): void {
-        this._onRenderListeners.splice(this._onRenderListeners.indexOf(event), 1);
+        Framework._removeListener(this._onRenderListeners, event);
+    }
+
+    /**
+     * Removes a listener if it is registered. An unknown listener is ignored,
+     * instead of `splice(-1, 1)` removing the last registered one.
+     */
+    private static _removeListener<T>(listeners: T[], listener: T): void {
+        const index = listeners.indexOf(listener);
+        if (index >= 0) {
+            listeners.splice(index, 1);
+        }
     }
 
     /** @inheritdoc */
@@ -188,7 +225,10 @@ export class Framework implements IFramework {
     /** @inheritdoc */
     public initialize(): void {
 
-        this.ktx2Factory?.initializeAsync();
+        if(this.ktx2Factory) {
+            this.ktx2Factory.initializeAsync();
+        }
+
         (this.renderer as WebGlRenderer).initialize();
         this.spriteBatch.initialize();
         this.input.initialize();

package/src/api/FrameworkConfiguration.ts

@@ -0,0 +1,29 @@
+import { TextureSamplerFilteringPreset } from "../core/rendering/enums.ts";
+import {vec2} from "gl-matrix";
+import type {IFrameworkConfiguration} from "./IFrameworkConfiguration.ts";
+import {PowerPreferenceType} from "./rendering/PowerPreference.ts";
+
+/**
+ * The options for configuring the Framework.
+ * @public
+ */
+export class FrameworkConfiguration implements IFrameworkConfiguration {
+
+    /** @inheritDoc */
+    useKtx2 = false;
+
+    /** @inheritDoc */
+    canvas?: HTMLCanvasElement;
+
+    /** @inheritDoc */
+    backBufferSize?: vec2;
+
+    /** @inheritDoc */
+    textureFiltering? = TextureSamplerFilteringPreset.BILINEAR;
+
+    /** @inheritDoc */
+    alpha = false;
+
+    /** @inheritDoc */
+    powerPreference = PowerPreferenceType.DEFAULT;
+}

package/src/api/IFramework.ts

@@ -0,0 +1,153 @@
+import {RenderingBackend} from "./rendering/RenderingBackend.ts";
+import type { ISpriteBatch } from "./sprites/ISpriteBatch.ts";
+import type { IRenderer } from "./rendering/IRenderer.ts";
+import type { IGraphicsDevice } from "./rendering/IGraphicsDevice.ts";
+import type { IRenderPipelineFactory } from "./rendering/render-pipelines/IRenderPipelineFactory.ts";
+import type { IBufferFactory } from "./rendering/buffers/IBufferFactory.ts";
+import type { IGeometryBuilder } from "./geometry/IGeometryBuilder.ts";
+import type { ICameraFactory } from "./camera/ICameraFactory.ts";
+import type { ITextureFactory } from "./rendering/texture/ITextureFactory.ts";
+import type { IContentManager } from "./content/IContentManager.ts";
+import type { IImageLoader } from "./loaders/IImageLoader.ts";
+import type { IMeshFactory } from "./meshes/IMeshFactory.ts";
+import type { IMaterialFactory } from "./material/IMaterialFactory.ts";
+import type { ITimeManager } from "./time/ITimeManager.ts";
+import type { IInputManager } from "./input/IInputManager.ts";
+import type { IWindowManager } from "./window/IWindowManager.ts";
+import {GameTime} from "./time/GameTime.ts";
+import type { IImageProcessor } from "./image/IImageProcessor.ts";
+import type { IKtx2Factory } from "ris-ktx2";
+import type { IDisposable } from "./core/IDisposable.ts";
+
+/** The framework interface. */
+export interface IFramework extends IDisposable {
+
+    /**
+     * The image loader.
+     */
+    readonly imageLoader: IImageLoader;
+
+    /**
+     * The used rendering backend.
+     */
+    readonly renderingBackend: RenderingBackend;
+
+    /**
+     * The sprite batches.
+     */
+    readonly spriteBatch: ISpriteBatch;
+
+    /**
+     * The renderer used by the framework.
+     */
+    readonly renderer: IRenderer;
+
+    /**
+     * The graphics device used by the framework.
+     */
+    readonly graphicsDevice: IGraphicsDevice;
+
+    /**
+     * The pipeline factory.
+     * Responsible for creating low-level rendering pipelines.
+     * Pipeline includes everything necessary to render some geometry
+     * and can be thought of as a material or renderer.
+     */
+    readonly renderPipelineFactory: IRenderPipelineFactory;
+
+    /**
+     * The buffer factory, responsible for creating GPU memory buffers.
+     */
+    readonly bufferFactory: IBufferFactory;
+
+    /**
+     * The geometry builder.
+     */
+    readonly geometryBuilder: IGeometryBuilder;
+
+    /** The texture factory. */
+    readonly textureFactory: ITextureFactory;
+
+    /** The KTX2 factory. Initialized only if KTX2 is requested or loaded. */
+    readonly ktx2Factory?: IKtx2Factory;
+
+    /**
+     * The camera factory.
+     */
+    readonly cameraFactory: ICameraFactory;
+
+    /**
+     * The content manager.
+     */
+    readonly content: IContentManager;
+
+    /**
+     * The mesh factory.
+     */
+    readonly meshFactory: IMeshFactory;
+
+    /**
+     * The material factory.
+     */
+    readonly materialFactory: IMaterialFactory;
+
+    /**
+     * The time manager.
+     */
+    readonly timeManager: ITimeManager;
+
+    /** The input manager. */
+    readonly input: IInputManager;
+
+    /** The window manager. */
+    readonly windowManager: IWindowManager;
+
+    /** The image processor. */
+    readonly imageProcessor: IImageProcessor;
+
+    /**
+     * Called right after the framework is initialized and before the render loop starts.
+     * Content can be loaded here.
+     */
+    addOnLoadContentListener(event: () => void): void;
+
+    /**
+     * Called right after the framework is initialized and before the render loop starts.
+     * Content can be loaded here.
+     */
+    removeOnLoadContentListener(event: () => void): void;
+
+    /**
+     * Called when the framework is initialized.
+     */
+    addOnInitializedListener(event: () => void): void;
+
+    /**
+     * Called when the framework is initialized.
+     */
+    removeOnInitializedListener(event: () => void): void;
+
+    /**
+     * Called when framework is updated.
+     */
+    addOnUpdateListener(event: (gameTime: GameTime) => void): void;
+
+    /**
+     * Called when framework is updated.
+     */
+    removeOnUpdateListener(event: (gameTime: GameTime) => void): void;
+
+    /**
+     * Called when the framework is rendered.
+     */
+    addOnRenderListener(event: () => void): void;
+
+    /**
+     * Called when the framework is rendered.
+     */
+    removeOnRenderListener(event: () => void): void;
+
+    /** Initializes the framework. */
+    initialize(): void;
+
+}

package/src/api/IFrameworkConfiguration.ts

@@ -0,0 +1,30 @@
+import {PowerPreferenceType} from "./rendering/PowerPreference.ts";
+import type {vec2} from "gl-matrix";
+import type {TextureSamplerFilteringPreset} from "../core/rendering/enums.ts";
+
+/**
+ * The configuration for the framework.
+ * @public
+ **/
+export class IFrameworkConfiguration {
+    /** If true, creates and makes the KTX2 factory available. */
+    useKtx2?: boolean;
+
+    /** The size of back buffer. */
+    backBufferSize?: vec2;
+
+    /** The texture filtering to configure */
+    textureFiltering?: TextureSamplerFilteringPreset;
+
+    /**
+     * The HTMLCanvasElement to use for rendering.
+     * If null, a new canvas will be created and added to the document body.
+     */
+    canvas?: HTMLCanvasElement;
+
+    /** Should back buffer use alpha. */
+    alpha?: boolean;
+
+    /** The preference when it comes to selecting GPU device. Only makes sense to set on multi-GPU devices. */
+    powerPreference ?: PowerPreferenceType;
+}