ris-framework 0.2.0-dev.11 → 0.2.0-dev.13

package/CHANGELOG.md

@@ -9,44 +9,36 @@ Compared with `main` (0.1.0).
 
 ### Breaking changes
 
-- **tsyringe and reflect-metadata removed.** Services are created by `Framework` and get their dependencies through constructors. Consumers no longer need `reflect-metadata` or decorator settings.
-- **Perspective camera.** `cameraFactory.createPerspectiveCamera(descriptor?, scene?)` takes a `PerspectiveCameraDescriptor` (`fov` in degrees, `aspectRatio`, `near`, `far`, `eye`, `target`, `up`) instead of `(fov, aspectRatio, near, far)`. The `PerspectiveCamera` constructor is `(framework, descriptor?, scene?)` instead of `(framework, fov, aspectRatio, nearPlane, farPlane)`.
-- **`ICamera.positionBuffer`.** This new member is required (std140 world-space eye). Custom `ICamera` implementations must provide it. `PerspectiveCamera`, `OrthographicCamera` and `OrbitCamera` implement it.
-- **Meshes.** `meshFactory.create(scene, geometry, material)` replaces `create(geometry, geometryFormat)`. The `Mesh` constructor is `(framework, scene, material?)` instead of `(framework)`. The `QuadMesh` constructor is `(framework, scene, material, isUpdatable, scale?)`.
-- **Materials.** `IMaterial.modelMatrix` is replaced by `IMaterial.modelBuffer`. The mesh owns the model buffer and assigns it before drawing. `UnlitMaterial` and `InspectTextureMipsMaterial` no longer create their own model buffer. They create their render pipeline once a model buffer is assigned, and rendering without one throws.
-- **Render pipelines.** `createUnlitRenderPipeline` and `createInspectTextureMipsRenderPipeline` throw when no model buffer is passed.
+- `FrameworkConfiguration` is no longer exported; pass an `IFrameworkConfiguration` object to `new Framework(...)`.
+- `tsyringe` and `reflect-metadata` are removed; services use plain constructor wiring.
+- `cameraFactory.createPerspectiveCamera` takes a descriptor object, and every `ICamera` now requires a `positionBuffer`.
+- Meshes are split into `IMesh`/`Mesh` (geometry and buffers) and `IRenderableMesh`/`RenderableMesh` (material, index range, sub meshes, transform).
+- Materials take a `modelBuffer` owned by the mesh instead of `modelMatrix`, and `renderMesh` takes an `IRenderableMesh`.
+- Render pipelines throw when no model buffer is passed.
+- Requires `ris-ktx2` 0.2.
 
 ### Added
 
-- `Scene` holds meshes, lights and the active camera. `scene.add(item)` and `scene.remove(item)` accept a mesh, `AmbientLight`, `DirectionalLight`, `PointLight` or camera. Adding the same item twice does nothing. Meshes, lights and the perspective camera given a scene in their constructor add themselves, and a disposed mesh removes itself. Removing the active camera clears `scene.camera`. `scene.update(time)` assigns the camera to materials and uploads changed lights. `scene.render()` draws every mesh.
-- Lights: `AmbientLight`, `DirectionalLight` and `PointLight` (constant, linear and quadratic attenuation) are plain data classes with descriptors, `intensity`, auto-assigned ids and an optional `scene` constructor argument. `LightsBuffer` is a std140 lights buffer with configurable directional and point light slots, and it uploads only when light data changed. `framework.lightsFactory` creates them.
-- `ForwardBlinnPhongMaterial` with ambient, diffuse and Blinn-Phong specular lighting from directional and point lights. Normals use the normal matrix, so non-uniform scale is handled. Specular colour and shininess come from MTL `Ks` and `Ns`, and shader variants are cached per light count. Its descriptor requires `projectionViewBuffer` and `cameraPositionBuffer`, and `materialFactory.createForwardBlinnPhongMaterial(descriptor)` creates it.
-- Mesh transforms: `mesh.position`, `mesh.rotation` (Euler radians, applied Y, then X, then Z), `mesh.scale` and a lazily computed `mesh.modelMatrix` / `mesh.modelBuffer`. Submeshes use their parent's transform.
-- Submeshes: one mesh can draw several index ranges, each with its own material (`mesh.addSubMesh`, `meshFactory.createWithSubMeshes`).
-- OBJ/MTL loading:
-  - `ObjLoader` is framework-independent and produces plain definitions. `ObjLoader.loadAsync(path, options)` supports `resolveMaterialUrl` and `ignoreMaterials`.
-  - `content.loadMeshAsync(path, scene)` loads a mesh with unlit materials, and `content.loadBlinnPhongMeshAsync(path, scene)` loads one with Blinn-Phong materials.
-- `geometryBuilder.create(descriptor)` with `GeometryDescriptor`. `BaseGeometry` is exported.
-- `SpriteMaterial` and `materialFactory.createSpriteMaterial`; sprite batches draw through it.
-- `UnlitMaterialDescriptor.camera` and a `camera` property on the unlit and Blinn-Phong materials. A scene assigns its camera through this property.
-- Examples: `unlit_mesh`, `blinn_phong_mesh` and `sprite_batch`, with `npm run dev:examples` and `npm run build:examples`.
+- `Scene` with `add`/`remove` for meshes, lights and the camera, plus `SceneMesh` for owning a mesh and its materials.
+- Lights: `AmbientLight`, `DirectionalLight` and `PointLight`.
+- `ForwardBlinnPhongMaterial`, `SpriteMaterial`, and the `ICameraMaterial`/`ILightsMaterial` interfaces.
+- Mesh transforms (`position`, `rotation`, `scale`) and sub meshes (`addSubMesh`, `meshFactory.createWithSubMeshes`).
+- OBJ/MTL loading through `framework.objLoader`, `ObjParser`, and `content.loadMeshAsync`, `loadUnlitMeshAsync` and `loadBlinnPhongMeshAsync`.
+- `geometryBuilder.create(descriptor)` and the exported `BaseGeometry`.
+- sRGB compressed texture formats (BC1, BC3, BC7, ETC2), with KTX2 loading choosing sRGB automatically.
+- Examples: `unlit_mesh`, `blinn_phong_mesh` and `sprite_batch`.
 
 ### Changed
 
-- `content.loadShaderModule(id, replacements?)` takes optional `##KEY##` replacement values, and they are part of the shader cache key.
+- `content.loadShaderModule` accepts optional replacement values.
 
 ### Fixed
 
-- The sprite fragment shader added `vec4(1.0)` to every pixel, so sprites rendered white.
-- The orthographic camera's default eye was at z = -1 instead of z = 1.
-- The default texture was a static shared by every `Framework` instance, so a second framework (a new GL context) reused a texture from the old one. It is now per framework.
-- The anisotropic filtering helper cached the extension object from the first GL context on a shared static. It is now looked up per context.
-- A leftover `debugger` statement in `WebGlGraphicsDevice` initialization is removed.
-
-### Removed
-
-- The `tsyringe` and `reflect-metadata` dependencies.
-- `IMaterial.modelMatrix`, replaced by `modelBuffer` (see Breaking changes).
+- Sprites rendered white because of a stray value in the sprite shader.
+- The orthographic camera's default eye was on the wrong side (z = -1).
+- A second `Framework` instance reused the default texture and anisotropic-filtering extension from the first.
+- A leftover `debugger` statement in WebGL device initialization.
+- Swapped BC/S3TC compression flags could select BC7 on GPUs without BPTC support.
 
 ## [0.1.0]
 

package/README.md

@@ -1,200 +1,149 @@
 # ris-framework
 
-`ris-framework` is a browser WebGL2 framework, published as an ES module. Version 0.1.0. An application imports the compiled package. This repository also contains a sample page that runs the framework.
+A browser WebGL2 framework for TypeScript, published as an ES module (version 0.2.0). Runtime dependencies are `gl-matrix` and `ris-ktx2`.
 
-Open `index.html`. The module script is `src/main.ts`. That file builds the page, constructs a `Framework`, and starts the frame loop. Shared interfaces and value types (`IFramework`, `Color`, `Rect`, `TextureDescriptor`, and the rest) ship from this package. They used to live in `ris-framework-api`. This repository implements them.
+```sh
+npm install ris-framework
+```
 
-## Layout
+Everything public is exported from the package entry: `Framework`, `TextureSamplerFilteringPreset`, and the API types (scenes, meshes, materials, lights, cameras, textures, loaders, input).
 
-| Path | What lives there |
-| --- | --- |
-| `index.html` | The page. It has `#app` and `<canvas id="game-canvas" width="800" height="600">`. |
-| `src/main.ts` | Application entry. |
-| `src/index.ts` | Package entry. Exports `Framework`, `FrameworkConfiguration`, `TextureSamplerFilteringPreset`, and everything under `src/api`. |
-| `src/Framework.ts` | `Framework`, which wires the renderer, factories, managers, and the frame loop together. |
-| `src/api` | Interfaces and value types formerly published as `ris-framework-api` (input, textures, cameras, `TextureUtilities`, and the rest). It also holds `FrameworkConfiguration` and the backend-independent implementations: `WindowManager`, `InputManager`, `ContentManager`, `SpriteBatch`, `GeometryBuilder`, and `BaseGeometry`. `src/api/content/ShaderModuleContent.ts` maps the built-in shader module ids to GLSL from `shaders/glsl`. |
-| `src/core` | Renderer and graphics-device base classes (`ARenderer`, `AGraphicsDevice`), the texture base class, blend and sampler descriptors, `VertexBufferLayout`, and `TextureSamplerFilteringPreset`. |
-| `src/webgl` | The WebGL2 graphics device, renderer, textures, buffers, samplers, and render pipelines. |
-| `shaders/glsl` | Vertex and fragment shaders used by the built-in shader modules. |
-| `tests` | Vitest tests for the types under `src/api`. |
+## Create and start a framework
 
-Runtime dependencies are `ris-ktx2` and `gl-matrix`. The KTX2 types (`IKtx2Texture`, `VkFormat`, `KtxTranscodeFormat`, and the rest) are imported from `ris-ktx2`. The library build includes the browser portion of `ris-ktx2`, with its Node loader replaced by a stub, so the published entry does not import Node built-ins. TypeScript, Vite, and Vitest are dev dependencies. Notices for the bundled KTX loader are in [THIRD_PARTY_NOTICES.md](THIRD_PARTY_NOTICES.md). The package license is Apache License 2.0. Copyright 2026 Luka Erkapic. See [LICENSE](LICENSE) and [NOTICE](NOTICE).
+Pass an `IFrameworkConfiguration` object. Every field is optional.
 
-## Prerequisites
+```ts
+import { Color, Framework, type IFrameworkConfiguration, TextureSamplerFilteringPreset } from "ris-framework";
 
-- Node.js 22. Continuous integration uses Node.js 22. Vite 7 in this repo requires `^20.19.0` or `>=22.12.0`.
-- npm.
-- A browser that can create a WebGL2 context. If `canvas.getContext("webgl2")` fails, startup throws `WebGL not supported.`
+const config: IFrameworkConfiguration = {
+    canvas: document.querySelector<HTMLCanvasElement>("#game-canvas")!,
+    textureFiltering: TextureSamplerFilteringPreset.BILINEAR,
+    useKtx2: true,
+};
 
-## Install
+const framework = new Framework(config);
 
-Install the package in an application:
+framework.addOnLoadContentListener(async () => { /* load content */ });
+framework.addOnUpdateListener(time => { /* update, time.deltaTimeSec */ });
+framework.addOnRenderListener(() => { /* draw */ });
 
-```sh
-npm install ris-framework
+framework.initialize();
+framework.renderer.clearColor = Color.cornerFlowerBlue();
 ```
 
-The published entry is compiled JavaScript and TypeScript declarations (`dist/index.js` and `dist/index.d.ts`). Import the public surface by package name:
+| Field | Default | Meaning |
+| --- | --- | --- |
+| `canvas` | created and appended | The canvas to render into. |
+| `backBufferSize` | `800 × 600` | Back buffer size. |
+| `textureFiltering` | `BILINEAR` | Default sampler preset. |
+| `textureColorSpace` | `SRGB` | Default texture colour space. |
+| `useKtx2` | `false` | Creates `framework.ktx2Factory`. |
+| `alpha` | `false` | Whether the back buffer has an alpha channel. |
+| `powerPreference` | `DEFAULT` | GPU preference on multi-GPU systems. |
 
-```ts
-import { Framework, FrameworkConfiguration, TextureSamplerFilteringPreset } from "ris-framework";
-```
+Register listeners before `initialize()`. Load-content and initialized listeners run inside that call.
 
-The same entry re-exports the former `ris-framework-api` surface, so a consumer can import those names from `ris-framework`:
+## Scenes, cameras and lights
 
 ```ts
-import { Color, Rect, TextureFormat, TextureUtilities, type IInputManager } from "ris-framework";
-```
-
-`Framework`, `FrameworkConfiguration`, `TextureSamplerFilteringPreset`, and that API surface are the public entry. Built-in GLSL is compiled into `dist/index.js`, so a consumer does not load this repository's `shaders/` directory at runtime. The same file includes the browser KTX2 loader. A consuming Vite app can import the package and build without adding a Node stub of its own.
-
-To work in this repository:
+import { Color, DirectionalLight, PointLight, Scene } from "ris-framework";
 
-```sh
-npm ci
-```
+const scene = new Scene(framework);
 
-`Framework` creates its services itself and passes dependencies through their constructors; no dependency-injection container or `reflect-metadata` import is needed.
+// Passing the scene makes this the scene's camera.
+const camera = framework.cameraFactory.createPerspectiveCamera({
+    aspectRatio: canvas.width / canvas.height,
+    eye: [0, 0, 3],
+}, scene);
 
-## Create a framework instance
+scene.activeAmbientLight.color = new Color(0.4, 0.4, 0.4);
+// Lights take an optional scene; passing it adds them.
+new DirectionalLight({ color: new Color(1, 1, 1), intensity: 0.8, direction: [-0.4, -0.6, 1] }, scene);
+new PointLight({ color: new Color(1, 0.5, 0.2), intensity: 1.2, linear: 0.35, quadratic: 0.44 }, scene);
 
-Construct `FrameworkConfiguration`, then pass it to `Framework`. The constructor is `constructor(options?: IFrameworkConfiguration)`. Omitting the argument uses `new FrameworkConfiguration()`. The constructor writes the resolved `backBufferSize` back onto the object you pass.
+framework.addOnUpdateListener(time => {
+    camera.update(time);
+    scene.update(time);
+});
+framework.addOnRenderListener(() => scene.render());
+```
 
-Another project imports that public entry by package name: `import { Framework, FrameworkConfiguration, TextureSamplerFilteringPreset } from "ris-framework"`.
+`scene.add(item)` and `scene.remove(item)` accept a renderable mesh, a `SceneMesh`, a light or a camera. Blinn-Phong materials support up to 3 directional and 5 point lights.
 
-No config field is required. Each field has a default.
+## Meshes and materials
 
-| Field | Default | What the code does with it |
-| --- | --- | --- |
-| `canvas` | `undefined` | The canvas the WebGL2 context is created from. When unset, `Framework` logs a warning and `WindowManager` creates a canvas and appends it to `document.body`. `src/main.ts` sets this to `#game-canvas`. |
-| `backBufferSize` | `undefined` (the constructor uses `vec2.fromValues(800, 600)`) | Copied onto an internal `IRendererConfiguration`. `WebGlRenderer` leaves that copy unused. The main render target starts at the canvas element's `width` and `height`. The canvas in `index.html` is 800 by 600. |
-| `textureFiltering` | `TextureSamplerFilteringPreset.BILINEAR` | Preset for the graphics device's default texture sampler. `POINT` is nearest filtering with no mipmaps. `BILINEAR` is linear filtering with no mipmaps. `TRILINEAR` is linear filtering with linear mipmaps. `undefined` is treated as `BILINEAR`. |
-| `useKtx2` | `false` | When `true`, the constructor sets `framework.ktx2Factory` to a `Ktx2Factory`. `initialize()` then calls `initializeAsync()` on it and does not wait. When `false`, `ktx2Factory` stays unset. |
-| `alpha` | `false` | Passed as the WebGL2 context's `alpha` attribute, so it decides whether the canvas back buffer has an alpha channel. |
-| `powerPreference` | `PowerPreferenceType.DEFAULT` | Passed as the WebGL2 context's `powerPreference` (`"default"`, `"low-power"`, or `"high-performance"`). It only matters on machines with more than one GPU. |
+- `IMesh` / `Mesh` hold geometry and the vertex and index buffers.
+- `IRenderableMesh` / `RenderableMesh` add a material, an index range and sub meshes (`mesh.addSubMesh(material, start, count)` or `meshFactory.createWithSubMeshes`). The root mesh owns the transform and one model buffer, which all its sub meshes share.
+- Transforms: `mesh.position`, `mesh.rotation` (Euler radians, applied Y, then X, then Z) and `mesh.scale`. `mesh.modelMatrix` is recomputed only when one of them changes.
+- `SceneMesh`: `scene.add(mesh)` wraps a renderable mesh in a `SceneMesh`, which owns its materials. `sceneMesh.dispose()` and `scene.dispose()` dispose the mesh and each material once.
+- Materials come from `framework.materialFactory`. They include unlit, `ForwardBlinnPhongMaterial` and `SpriteMaterial`.
 
-Every field is optional on `IFrameworkConfiguration`. A new `FrameworkConfiguration` sets `useKtx2`, `textureFiltering`, `alpha`, and `powerPreference`. `canvas` and `backBufferSize` start unset.
+## Loading OBJ/MTL
 
 ```ts
-import { Framework, FrameworkConfiguration, TextureSamplerFilteringPreset } from "ris-framework";
-
-const config = new FrameworkConfiguration();
-config.canvas = document.getElementById("game-canvas") as HTMLCanvasElement;
-config.textureFiltering = TextureSamplerFilteringPreset.BILINEAR;
+// Unlit or Blinn-Phong materials (one per usemtl), coloured from the .mtl.
+const cube = await framework.content.loadBlinnPhongMeshAsync("/assets/cube.obj", camera);
+const flat = await framework.content.loadUnlitMeshAsync("/assets/cube.obj", camera);
+scene.add(cube);
+
+// Lower level: pass a Blinn-Phong descriptor or a material factory per sub mesh.
+const mesh = await framework.objLoader.loadAsync("/assets/cube.obj", {
+    projectionViewBuffer: camera.projectionViewBuffer,
+    cameraPositionBuffer: camera.positionBuffer,
+});
 
-const framework = new Framework(config);
+// Geometry only, with no materials (GeometryFormat is exported from "ris-framework").
+const geometry = await framework.content.loadMeshAsync("/assets/cube.obj", GeometryFormat.POS3_COLOR4_TEXTURECOORDS2);
 ```
 
-`src/main.ts` constructs the sample the same way, but it imports those three symbols from the source files under `src/` instead of from the package name.
-
-`framework.renderingBackend` is `RenderingBackend.WEB_GL`. After `initialize()`, `framework.graphicsDevice` is the renderer's WebGL2 device.
+`ObjLoader.parseAsync(path)` and `ObjParser` return plain data without creating GPU resources.
 
+## Textures and KTX2
 
-## From startup to the first frame
-
-`src/main.ts` is the current startup path. It still fills `#app` with the Vite starter page (logos and a heading) and then starts the framework on `#game-canvas`.
+```ts
+const png = await framework.content.loadTexture2DAsync("/assets/test.png");
+const ktx = await framework.content.loadTexture2DAsync("/assets/kodim23.ktx2");
+```
 
-Register listeners before `initialize()`. Load-content and initialized listeners run only inside that call. Update and render listeners stay on the loop, so a listener added later still runs on a following frame. `initialize()` does this:
+Paths ending in `.ktx2` are loaded through `ris-ktx2`.
 
-1. Starts KTX2 initialization when `useKtx2` is set, without awaiting it.
-2. Creates the WebGL2 context, swap chain, and default sampler, blend state, and primitive state.
-3. Initializes the sprite batch (a default orthographic camera and a 1×1 white texture).
-4. Initializes input. Mouse move, mouse buttons, and wheel events on the canvas update `framework.input.getMouseState()`. Touch start, move, end, and cancel events on the canvas update `framework.input.getTouchCollection()`, using the same viewport `clientX` / `clientY` coordinates as the mouse. A cancel is `TouchLocationState.CANCELLED`, which is not a finger lift. The canvas `touch-action` is set to `none`, and touch start and move call `preventDefault`, so the browser does not scroll or pinch-zoom that canvas.
-5. Prepares the time manager.
-6. Calls every `addOnLoadContentListener` callback. Async callbacks are not awaited.
-7. Calls every `addOnInitializedListener` callback.
-8. Creates the main render target at the canvas size and a swap-chain pass. The clear color at this moment is `Color.lightPink()`, the renderer default.
-9. Subscribes an update callback and a render callback, then runs both once before returning. Later frames are scheduled with `requestAnimationFrame`.
+- **Basis Universal files** are transcoded to the best format the GPU supports, in this order: BC7, ASTC 4×4, BC3, ETC2, PVRTC, and RGBA8 as a last resort.
+- **Other KTX2 files** are uploaded in their stored format.
+- **sRGB:** sRGB files load as sRGB formats (`BC7_RGBA_SRGB`, `BC3_RGBA_SRGB`, `BC1_RGB_SRGB`, `ETC2_RGBA8_SRGB`, `ETC2_RGB8_SRGB`, `ASTC_*_RGBA_SRGB`, `RGBA_8_UNORM_SRGB`), so the GPU decodes them to linear.
+- **sRGB fallback:** if `WEBGL_compressed_texture_s3tc_srgb` is missing, sRGB BC1 and BC3 textures fall back to linear with a warning.
 
-Each update calls `timeManager.frameStart()`, updates input, then calls `addOnUpdateListener` callbacks with that frame's `GameTime`. `src/main.ts` registers no update listener. Each render begins the main pass, calls `addOnRenderListener` callbacks, calls `spriteBatch.frameEnd()`, and presents.
+`framework.graphicsDevice.features` reports compression support: `supportsTextureCompressionBC` (BPTC/BC7), `supportsTextureCompressionS3TC`, `supportsTextureCompressionS3TCSrgb`, `supportsTextureCompressionETC2`, `supportsTextureCompressionASTC` and `supportsTextureCompressionPVRTC`.
 
-Before that call, `src/main.ts` registers the listeners below. The sample loads images, creates a nearest sampler, and draws with the sprite batch:
+## Sprites
 
 ```ts
-import {
-  Color,
-  Rect,
-  SamplerDescriptor,
-  SamplerFilter,
-  TextureDescriptor,
-  TextureFormat,
-  type ISampler,
-  type ITexture2D,
-} from "ris-framework";
-
-const rect = new Rect(200, 200, 200, 200);
-const texRect = new Rect(500, 200, 200, 200);
-const color = Color.blue();
-const white = Color.white();
-let tex: ITexture2D;
-let sampler: ISampler;
-
-framework.addOnLoadContentListener(async () => {
-  const texDesc = new TextureDescriptor();
-  texDesc.generateMipmaps = true;
-  texDesc.textureFormat = TextureFormat.RGBA_8_UNORM;
-
-  tex = await framework.content.loadTexture2DAsync("/assets/test.png", texDesc);
-});
-
-framework.addOnInitializedListener(() => {
-  const desc = new SamplerDescriptor();
-  desc.minFilter = SamplerFilter.NEAREST;
-  desc.magFilter = SamplerFilter.NEAREST;
-  sampler = framework.graphicsDevice.createSampler(desc);
-});
-
 framework.addOnRenderListener(() => {
-  const spriteBatch = framework.spriteBatch;
-  spriteBatch.begin(undefined, sampler);
-  spriteBatch.drawRect(rect, color);
-  if (tex != null) {
-    spriteBatch.draw(tex, texRect, white);
-  }
-  spriteBatch.end();
+    framework.spriteBatch.begin();
+    framework.spriteBatch.draw(texture, new Rect(200, 200, 200, 200), Color.white());
+    framework.spriteBatch.drawRect(new Rect(500, 200, 100, 100), Color.blue());
+    framework.spriteBatch.end();
 });
-
-framework.initialize();
-framework.renderer.clearColor = Color.lightPink();
 ```
 
-`loadTexture2DAsync(path, textureDescriptor?, contentConfig?)` is the image path used above. For a path that does not end in `.ktx2`, the descriptor's `textureFormat` is used when it is not `TextureFormat.UNDEFINED`; otherwise the renderer's preferred format is used. `generateMipmaps` is passed through. Width, height, pixel data, usage, label, and block size on that descriptor are not applied to this load. An optional `ContentConfig` only forwards `keepDataCached` to the image loader.
-
-The first `begin` / `drawRect` / `end` runs inside `initialize()`, before the texture promise resolves, so the blue rectangle is the first draw. Later frames draw the texture once `tex` is set. `spriteBatch.begin` with no matrix keeps the default orthographic camera. The sampler argument overrides the device's default sampler for that batch. `drawRect` draws the 1×1 white texture tinted by `color`.
-
-`src/main.ts` also loads `/assets/cat.jpg` the same way and draws it at `new Rect(200, 500, 200, 200)`. Those two files are absent from this repository. Put them under `public/assets/` before those loads can succeed. The blue rectangle still draws when the image loads fail.
-
-Setting `framework.renderer.clearColor` after `initialize()` updates later frames. The first frame has already cleared with the default light pink.
+## Examples and scripts
 
-## Scene
-
-`new Scene(framework)` holds meshes, lights and the camera. `scene.add(item)` and `scene.remove(item)` accept a mesh, an `AmbientLight`, `DirectionalLight`, `PointLight` or a camera; adding twice does nothing. Meshes, lights and the perspective camera given a scene in their constructor add themselves, and a disposed mesh removes itself. Adding a camera makes it `scene.camera`; removing the active camera clears it. `addLight`/`removeLight` remain as deprecated aliases.
-
-## Examples
-
-Browser examples live in [`examples/`](examples/), one folder per example. See [`examples/README.md`](examples/README.md).
+Examples live in [`examples/`](examples/): `unlit_mesh`, `blinn_phong_mesh` and `sprite_batch` (see [`examples/README.md`](examples/README.md)).
 
 ```sh
-npm run dev:examples      # serve the examples index, e.g. /sprite_batch/
-npm run build:examples    # build every example into examples/dist/
+npm ci
+npm run dev:examples     # serve the examples
+npm run build:examples   # build them into examples/dist/
+npm run dev              # src/main.ts playground
+npm test                 # type-check and Vitest
+npm run build            # library (dist/) and app build
 ```
 
-## What is still unfinished
-
-These throw, or they accept a call and do not do the work the name suggests:
+Requires Node.js 22 (or `^20.19.0`) and a WebGL2-capable browser.
 
-- `WindowManager.addOnResizeListener`, `removeOnResizeListener`, `initializeForWebGPU`, `initializeForWebGl`, and `dispose` throw `Method not implemented.` `title` and `windowBounds` are stored and never applied. There is no WebGPU backend.
-- `Framework.dispose()` is empty. It does not release the window, device, or GPU resources.
-- `renderer.beginComputePass()` and `renderer.endComputePass()` throw `Method not implemented.` `ARenderer.limits` throws the same error.
-- `graphicsDevice.setupDebugCallback()`, `frameEnd()`, `pushDebugGroup()`, and `popDebugGroup()` throw `Method not implemented.`
-- `ITexture2D.createView()` throws `Method not implemented.`
-- `content.loadShaderModule` only resolves the built-in ids `sprite`, `unlit_material`, `inspect_texture_mips`, and `main_render_target_flip_y`. Any other id throws `Not implemented`.
-- `SpriteBatch.draw` and `drawRect` accept rotation arguments and do not use them. `layerDepth` is written as the sprite's z position.
-- Keyboard and gamepad queries return empty state. `getKeyboardState()` is an empty `KeyboardState`. `getGamePadState()` is a disconnected `GamePadState`. `thumbstickDeadZone` is stored and not applied.
-- A render pass that enables stencil without depth throws `Not implemented`.
-- Paths ending in `.ktx2` go through `content.loadKtx2Async`, which uses its own `Ktx2Factory` and does not call `initializeAsync`. The libktx module is shared by every `Ktx2Factory`, so `loadAsync` works only after some factory has finished `initializeAsync()`. `useKtx2` starts that call in `initialize()` but does not wait for it. To load a `.ktx2` file, set `useKtx2`, await `framework.ktx2Factory.initializeAsync()` before `initialize()`, and then call `loadTexture2DAsync` from a load-content listener. `src/main.ts` does not load a `.ktx2` file.
-- The geometry and unlit-pipeline steps at the bottom of `src/main.ts` are comments. `geometryBuilder.quadGeometry()` can build quad data; the entry file does not upload it or draw it.
+## Known limitations
 
-## Version
+- Window resize listeners and compute passes throw `Method not implemented.`
+- Keyboard and gamepad state are stubs.
+- `SpriteBatch` ignores rotation.
 
-`package.json` `version` stays a release version with no prerelease suffix. It is `0.1.0`. Branch and publish rules are in [CONTRIBUTING.md](CONTRIBUTING.md).
+Branch and publish rules are in [CONTRIBUTING.md](CONTRIBUTING.md). Changes are listed in [CHANGELOG.md](CHANGELOG.md).

package/dist/Framework.d.ts

@@ -1,29 +1,38 @@
-import { type ICameraFactory, type IContentManager, type IFramework, IFrameworkConfiguration, type IImageLoader, type IRenderer, type IRenderPipelineFactory, type IWindowManager } from "./api/index.js";
-import { GameTime, type IBufferFactory, type IGeometryBuilder, type IGraphicsDevice, type IImageProcessor, type IInputManager, type IMaterialFactory, type AmbientLightFactory, type IMeshFactory, type ISpriteBatch, type ITextureFactory, type ITimeManager, RenderingBackend } from "./api/index.js";
+import { ObjLoader } from "./api/loaders/ObjLoader.js";
+import { type AmbientLightFactory, GameTime, type IBufferFactory, type ICameraFactory, type IContentManager, type IFramework, IFrameworkConfiguration, type IGeometryBuilder, type IGraphicsDevice, type IImageLoader, type IImageProcessor, type IInputManager, type IMaterialFactory, type IMeshFactory, type IRenderer, type IRenderPipelineFactory, type ISpriteBatch, type ITextureFactory, type ITimeManager, type IWindowManager, RenderingBackend } from "./api/index.js";
 import type { IKtx2Factory } from "ris-ktx2";
+/** The Ris framework */
 export declare class Framework implements IFramework {
     private readonly _onLoadContentListeners;
     private readonly _onInitializeListeners;
     private readonly _onUpdateListeners;
     private readonly _onRenderListeners;
-    private readonly _textureFactory;
-    private readonly _buffersFactory;
-    private readonly _contentManager;
+    private _configuration;
+    private _textureFactory;
+    private _buffersFactory;
+    private _contentManager;
+    private readonly _rendererConfiguration;
+    private _renderer;
     private readonly _geometryBuilder;
     private readonly _meshFactory;
     private _disposed;
     /**
      * The constructor for the Framework class.
-     * @param options The optional framework configuration. When omitted, a default `FrameworkConfiguration` is used.
+     * @param configuration The optional framework configuration. When omitted, a default `FrameworkConfiguration` is used.
      */
-    constructor(options?: IFrameworkConfiguration);
+    constructor(configuration?: IFrameworkConfiguration);
     /** @inheritDoc */
     readonly imageLoader: IImageLoader;
     renderingBackend: RenderingBackend;
     /** @inheritDoc */
     readonly imageProcessor: IImageProcessor;
     /** @inheritDoc */
-    readonly renderer: IRenderer;
+    get renderer(): IRenderer;
+    /**
+     * Creates the backend-specific services: renderer, texture factory, pipeline factory, shader loader and buffers factory.
+     * @param backend WEB_GL or WEB_GPU.
+     */
+    private _setupBackendServices;
     /** @inheritDoc */
     readonly spriteBatch: ISpriteBatch;
     /** @inheritDoc */
@@ -68,6 +77,8 @@ export declare class Framework implements IFramework {
     /** @inheritdoc */
     get meshFactory(): IMeshFactory;
     /** @inheritDoc */
+    readonly objLoader: ObjLoader;
+    /** @inheritDoc */
     readonly materialFactory: IMaterialFactory;
     /** @inheritDoc */
     readonly lightsFactory: AmbientLightFactory;
@@ -77,6 +88,13 @@ export declare class Framework implements IFramework {
     readonly input: IInputManager;
     /** @inheritdoc */
     initialize(): void;
+    /**
+     * Initializes the framework and starts the event loop. Required for WebGPU, which requests its adapter
+     * and device asynchronously; for WebGL it behaves like {@link initialize}.
+     * If the WebGPU device cannot be acquired, the framework falls back to WebGL with a warning.
+     */
+    initializeAsync(): Promise<void>;
+    private _initializeCore;
     /**
      * Stops the event loop and disposes the framework's services and GL resources,
      * including per-framework caches such as the default texture and the shader modules.

package/dist/Framework.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Framework.d.ts","sourceRoot":"","sources":["../src/Framework.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"Framework.d.ts","sourceRoot":"","sources":["../src/Framework.ts"],"names":[],"mappings":"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"}

package/dist/api/IFramework.d.ts

@@ -7,6 +7,7 @@ import type { IBufferFactory } from "./rendering/buffers/IBufferFactory.js";
 import type { IGeometryBuilder } from "./geometry/IGeometryBuilder.js";
 import type { ICameraFactory } from "./camera/ICameraFactory.js";
 import type { ITextureFactory } from "./rendering/texture/ITextureFactory.js";
+import type { ObjLoader } from "./loaders/ObjLoader.js";
 import type { IContentManager } from "./content/IContentManager.js";
 import type { IImageLoader } from "./loaders/IImageLoader.js";
 import type { IMeshFactory } from "./meshes/IMeshFactory.js";
@@ -19,6 +20,39 @@ import { GameTime } from "./time/GameTime.js";
 import type { IImageProcessor } from "./image/IImageProcessor.js";
 import type { IKtx2Factory } from "ris-ktx2";
 import type { IDisposable } from "./core/IDisposable.js";
+import type { vec2 } from "gl-matrix";
+import type { TextureSamplerFilteringPreset } from "../core/rendering/enums.js";
+import type { PowerPreferenceType } from "./rendering/PowerPreference.js";
+import type { TextureColorSpace } from "./rendering/enums.js";
+/**
+ * The configuration for the framework.
+ * @public
+ **/
+export declare class IFrameworkConfiguration {
+    /** If true, creates and makes the KTX2 factory available. */
+    useKtx2?: boolean;
+    /** The size of back buffer. By default, if not specified (800, 600). */
+    backBufferSize?: vec2;
+    /** The texture filtering to configure */
+    textureFiltering?: TextureSamplerFilteringPreset;
+    /** The texture color space to use by default. By default, it is {@link TextureColorSpace.SRGB}. */
+    textureColorSpace?: TextureColorSpace;
+    /**
+    * 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;
+    /**
+     * The rendering backend. Defaults to WebGL.
+     * WebGPU requires `Framework.initializeAsync()`; when `navigator.gpu` is missing or no device is available,
+     * the framework falls back to WebGL with a warning.
+     */
+    renderingBackend?: RenderingBackend;
+}
 /** The framework interface. */
 export interface IFramework extends IDisposable {
     /**
@@ -72,6 +106,10 @@ export interface IFramework extends IDisposable {
      * The mesh factory.
      */
     readonly meshFactory: IMeshFactory;
+    /**
+     * The OBJ loader: `objLoader.loadAsync(path, blinnPhongDescriptor | subMesh => material)`.
+     */
+    readonly objLoader: ObjLoader;
     /**
      * The material factory.
      */
@@ -122,5 +160,10 @@ export interface IFramework extends IDisposable {
     removeOnRenderListener(event: () => void): void;
     /** Initializes the framework. */
     initialize(): void;
+    /**
+     * Initializes the framework asynchronously and starts the event loop.
+     * Required for the WebGPU backend; for WebGL it behaves like {@link initialize}.
+     */
+    initializeAsync(): Promise<void>;
 }
 //# sourceMappingURL=IFramework.d.ts.map

package/dist/api/IFramework.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"IFramework.d.ts","sourceRoot":"","sources":["../../src/api/IFramework.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"IFramework.d.ts","sourceRoot":"","sources":["../../src/api/IFramework.ts"],"names":[],"mappings":"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"}

package/dist/api/_export.d.ts

@@ -1,5 +1,4 @@
 export * from "./IFramework.js";
-export * from "./IFrameworkConfiguration.js";
 export * from "./rendering/texture/_export-texture.js";
 export * from "./rendering/buffers/_export-buffers.js";
 export * from "./data/_export.js";
@@ -24,6 +23,7 @@ export * from "./meshes/_export.js";
 export * from "./material/_export.js";
 export * from "./lights/_export.js";
 export * from "./scene/Scene.js";
+export * from "./scene/SceneMesh.js";
 export * from "./input/_export.js";
 export * from "./image/_export.js";
 //# sourceMappingURL=_export.d.ts.map

package/dist/api/_export.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"_export.d.ts","sourceRoot":"","sources":["../../src/api/_export.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,wCAAwC,CAAC;AACvD,cAAc,wCAAwC,CAAC;AACvD,cAAc,mBAAmB,CAAC;AAClC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,kCAAkC,CAAC;AACjD,cAAc,0DAA0D,CAAC;AACzE,cAAc,8BAA8B,CAAC;AAC7C,cAAc,qBAAqB,CAAC;AACpC,cAAc,wBAAwB,CAAC;AACvC,cAAc,wBAAwB,CAAC;AACvC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,kCAAkC,CAAC;AACjD,cAAc,iCAAiC,CAAC;AAChD,cAAc,sBAAsB,CAAC;AACrC,cAAc,mCAAmC,CAAC;AAClD,cAAc,qBAAqB,CAAC;AACpC,cAAc,kCAAkC,CAAC;AACjD,cAAc,gCAAgC,CAAA;AAC9C,cAAc,wBAAwB,CAAA;AACtC,cAAc,qBAAqB,CAAC;AACpC,cAAc,uBAAuB,CAAC;AACtC,cAAc,qBAAqB,CAAC;AACpC,cAAc,kBAAkB,CAAC;AACjC,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC"}
+{"version":3,"file":"_export.d.ts","sourceRoot":"","sources":["../../src/api/_export.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,wCAAwC,CAAC;AACvD,cAAc,wCAAwC,CAAC;AACvD,cAAc,mBAAmB,CAAC;AAClC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,kCAAkC,CAAC;AACjD,cAAc,0DAA0D,CAAC;AACzE,cAAc,8BAA8B,CAAC;AAC7C,cAAc,qBAAqB,CAAC;AACpC,cAAc,wBAAwB,CAAC;AACvC,cAAc,wBAAwB,CAAC;AACvC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,kCAAkC,CAAC;AACjD,cAAc,iCAAiC,CAAC;AAChD,cAAc,sBAAsB,CAAC;AACrC,cAAc,mCAAmC,CAAC;AAClD,cAAc,qBAAqB,CAAC;AACpC,cAAc,kCAAkC,CAAC;AACjD,cAAc,gCAAgC,CAAA;AAC9C,cAAc,wBAAwB,CAAA;AACtC,cAAc,qBAAqB,CAAC;AACpC,cAAc,uBAAuB,CAAC;AACtC,cAAc,qBAAqB,CAAC;AACpC,cAAc,kBAAkB,CAAC;AACjC,cAAc,sBAAsB,CAAC;AACrC,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC"}