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

package/src/api/meshes/Mesh.ts

@@ -1,24 +1,21 @@
 /**
  * The mesh is a building class for a world shape.
  */
-import {mat4, quat, vec3} from "gl-matrix";
 import {State} from "../data/State.ts";
 import type {IVertexBuffer} from "../rendering/buffers/IVertexBuffer.ts";
 import type {IIndexBuffer} from "../rendering/buffers/IIndexBuffer.ts";
-import type {IUniformBuffer} from "../rendering/buffers/IUniformBuffer.ts";
 import type {IFramework} from "../IFramework.ts";
 import type {IMesh} from "./IMesh.ts";
 import {BufferUsage} from "../rendering/buffers/BufferUsage.ts";
 import type {IGeometry} from "../geometry/IGeometry.ts";
 import {MeshParameters} from "./MeshParameters.ts";
 import {GeometryUtilities} from "../utilities/GeometryUtilities.ts";
-import type {IMaterial} from "../material/IMaterial.ts";
 import type {GeometryFormat} from "../geometry/GeometryFormat.ts";
-import {SubMesh} from "./SubMesh.ts";
-import type {Scene} from "../scene/Scene.ts";
 
 /**
- * The mesh.
+ * The base mesh: geometry and the vertex and index buffers created from it (C# `BaseMesh`).
+ * No material and no transform; {@link RenderableMesh} adds those.
+ * @public
  */
 export class Mesh implements IMesh {
 
@@ -32,116 +29,23 @@ export class Mesh implements IMesh {
     protected _normals?: number[];
     protected _vertexBuffer?: IVertexBuffer;
     protected _indexBuffer?: IIndexBuffer;
-    protected _subMeshes: SubMesh[] = [];
-    private readonly _modelMatrix = mat4.create();
-    private readonly _rotationQuat = quat.create();
-    // Cached copies to detect in-place edits; NaN forces the first computation.
-    private readonly _lastPosition = vec3.fromValues(NaN, NaN, NaN);
-    private readonly _lastRotation = vec3.create();
-    private readonly _lastScale = vec3.create();
-    private _modelBuffer?: IUniformBuffer;
-    /** The matrix last uploaded to the model buffer. */
-    private readonly _uploadedMatrix = mat4.create();
-
-    /** @inheritDoc */
-    public position: vec3 = vec3.create();
-
-    /** @inheritDoc */
-    public rotation: vec3 = vec3.create();
-
-    /** @inheritDoc */
-    public scale: vec3 = vec3.fromValues(1, 1, 1);
-
-    /** @inheritDoc */
-    public get modelMatrix(): mat4 {
-        if (!vec3.exactEquals(this._lastPosition, this.position)
-            || !vec3.exactEquals(this._lastRotation, this.rotation)
-            || !vec3.exactEquals(this._lastScale, this.scale)) {
-            vec3.copy(this._lastPosition, this.position);
-            vec3.copy(this._lastRotation, this.rotation);
-            vec3.copy(this._lastScale, this.scale);
-            const q = quat.identity(this._rotationQuat);
-            quat.rotateY(q, q, this.rotation[1]);
-            quat.rotateX(q, q, this.rotation[0]);
-            quat.rotateZ(q, q, this.rotation[2]);
-            mat4.fromRotationTranslationScale(this._modelMatrix, q, this.position, this.scale);
-        }
-        return this._modelMatrix;
-    }
-
-    /** @inheritDoc Created on first access and disposed with the mesh. */
-    public get modelBuffer(): IUniformBuffer {
-        if (!this._modelBuffer) {
-            mat4.copy(this._uploadedMatrix, this.modelMatrix);
-            this._modelBuffer = this._framework.bufferFactory.createUniformBuffer(
-                this._uploadedMatrix, BufferUsage.UNIFORM | BufferUsage.COPY_DST, "Mesh.modelBuffer");
-        }
-        return this._modelBuffer;
-    }
-
-    /** Uploads the model matrix when the transform changed since the last upload. */
-    private _updateModelBuffer(): IUniformBuffer {
-        const buffer = this.modelBuffer;
-        const matrix = this.modelMatrix;
-        if (!mat4.exactEquals(this._uploadedMatrix, matrix)) {
-            mat4.copy(this._uploadedMatrix, matrix);
-            buffer.update(this._uploadedMatrix);
-        }
-        return buffer;
-    }
-
-    /**
-     * Assigns this mesh's model buffer to a material that uses one (has a `modelBuffer` property),
-     * only when it differs. Materials without one (e.g. sprites) are skipped and no buffer is created for them.
-     * @internal
-     */
-    __assignModelBuffer(material: IMaterial): void {
-        if (!("modelBuffer" in material)) {
-            return;
-        }
-        const buffer = this._updateModelBuffer();
-        if (material.modelBuffer !== buffer) {
-            material.modelBuffer = buffer;
-        }
-    }
+    protected _geometry?: IGeometry;
 
     /**
      * The constructor.
      * @param _framework The framework.
-     * @param scene The scene. The mesh adds itself to it and removes itself on dispose.
-     *              `null` only for internal meshes drawn outside a scene (e.g. the sprite batch).
-     * @param _material The material. Optional for a mesh that only holds submeshes.
      */
-    public constructor(protected readonly _framework: IFramework, public readonly scene: Scene | null, protected _material?: IMaterial) {
-        scene?.add(this);
+    public constructor(protected readonly _framework: IFramework) {
     }
 
-    /** The material. Undefined for a mesh drawn through its submeshes. */
-    public get material(): IMaterial | undefined {
-        return this._material;
+    /** The geometry the buffers were created from with {@link setGeometry}, if any. */
+    public get geometry(): IGeometry | undefined {
+        return this._geometry;
     }
 
-    /** Sets the material. */
-    public set material(material: IMaterial | undefined) {
-        this._material = material;
-    }
-
-    /** The submeshes. They share this mesh's vertex and index buffers. */
-    public get subMeshes(): SubMesh[] {
-        return this._subMeshes;
-    }
-
-    /**
-     * Adds a submesh that draws a range of this mesh's index buffer with its own material.
-     * @param material The material of the submesh.
-     * @param indexStart The first index of the range.
-     * @param indexCount The number of indices in the range.
-     * @returns The submesh.
-     */
-    public addSubMesh(material: IMaterial, indexStart: number, indexCount: number): SubMesh {
-        const subMesh = new SubMesh(this, material, indexStart, indexCount);
-        this._subMeshes.push(subMesh);
-        return subMesh;
+    /** The geometry format used when {@link setGeometry} is called without one. Undefined for a plain mesh. */
+    protected get _defaultGeometryFormat(): GeometryFormat | undefined {
+        return undefined;
     }
 
     /**
@@ -301,13 +205,13 @@ export class Mesh implements IMesh {
      *
      * This will create vertex buffer and index buffer from geometry.
      * @param geometry - The geometry.
-     * @param geometryFormat - The vertex layout. Defaults to the material's geometry format.
+     * @param geometryFormat - The vertex layout. A `RenderableMesh` defaults to its material's geometry format.
      */
     public setGeometry(geometry: IGeometry, geometryFormat?: GeometryFormat): void {
 
-        const format = geometryFormat ?? this._material?.geometryFormat;
+        const format = geometryFormat ?? this._defaultGeometryFormat;
         if (format === undefined) {
-            throw new Error("Cannot create buffers for a Mesh without a material or geometry format.");
+            throw new Error("Cannot create buffers for a Mesh without a geometry format (pass one, or give a RenderableMesh a material).");
         }
         if (geometry.vertexCount == 0) {
             const message =
@@ -316,6 +220,7 @@ export class Mesh implements IMesh {
             throw new Error(message);
         }
 
+        this._geometry = geometry;
         const interleavedData = geometry.toInterleaved(format);
         const stride = GeometryUtilities.stride(format);
 
@@ -345,34 +250,14 @@ export class Mesh implements IMesh {
         this.applyChanges();
     }
 
-    /** @inheritDoc */
-    public render(): void {
-
-        // Render submeshes.
-        if (this.subMeshes?.length > 0) {
-            for (let i = 0; i < this.subMeshes.length; ++i) {
-                this.subMeshes[i].render();
-            }
-        }
-
-        if (this.material) {
-            this.__assignModelBuffer(this.material);
-            this.material.beforeRender();
-            this.material.renderMesh(this);
-        }
-    }
-
     /**
-     * Dispose of the mesh.
+     * Disposes the vertex and index buffers.
      */
     public dispose(): void {
-        this.scene?.remove(this);
-        this._subMeshes.length = 0;
         this._vertexBuffer?.dispose();
         this._vertexBuffer = undefined;
         this._indexBuffer?.dispose();
         this._indexBuffer = undefined;
-        this._modelBuffer?.dispose();
-        this._modelBuffer = undefined;
+        this._state = State.DISPOSED;
     }
 }

package/src/api/meshes/MeshFactory.ts

@@ -1,4 +1,6 @@
-import type {Scene} from "../scene/Scene.ts";
+import {RenderableMesh} from "./RenderableMesh.ts";
+import type { IRenderableMesh } from "./IRenderableMesh.ts";
+import type { GeometryFormat } from "../geometry/GeometryFormat.ts";
 import type { IMeshFactory } from "./IMeshFactory.ts";
 import type { IGeometry } from "../geometry/IGeometry.ts";
 import type { IMesh } from "./IMesh.ts";
@@ -22,14 +24,21 @@ export class MeshFactory implements IMeshFactory {
     }
 
     /** @inheritDoc */
-    public create(scene: Scene, geometry: IGeometry, material: IMaterial): IMesh {
-        const mesh = new Mesh(this._framework, scene, material);
+    public createMesh(geometry: IGeometry, geometryFormat: GeometryFormat): IMesh {
+        const mesh = new Mesh(this._framework);
+        mesh.setGeometry(geometry, geometryFormat);
+        return mesh;
+    }
+
+    /** @inheritDoc */
+    public create(geometry: IGeometry, material: IMaterial): IRenderableMesh {
+        const mesh = new RenderableMesh(this._framework, material);
         mesh.setGeometry(geometry);
         return mesh;
     }
 
     /** @inheritDoc */
-    public createWithSubMeshes(scene: Scene, geometry: IGeometry, subMeshes: SubMeshDescriptor[]): IMesh {
+    public createWithSubMeshes(geometry: IGeometry, subMeshes: SubMeshDescriptor[]): IRenderableMesh {
         if (subMeshes.length == 0) {
             throw new Error("createWithSubMeshes needs at least one submesh.");
         }
@@ -38,7 +47,7 @@ export class MeshFactory implements IMeshFactory {
             throw new Error("All submesh materials must use the same geometry format, as they share one vertex buffer.");
         }
 
-        const mesh = new Mesh(this._framework, scene);
+        const mesh = new RenderableMesh(this._framework);
         mesh.setGeometry(geometry, format);
         for (const subMesh of subMeshes) {
             mesh.addSubMesh(subMesh.material, subMesh.indexStart, subMesh.indexCount);

package/src/api/meshes/QuadMesh.ts

@@ -1,15 +1,14 @@
-import {Mesh} from "./Mesh.ts";
+import {RenderableMesh} from "./RenderableMesh.ts";
 import {Rect} from "../data/Rect.ts";
 import type { IFramework } from "../IFramework.ts";
 import {vec2} from "gl-matrix";
 import {BufferUsage} from "../rendering/buffers/BufferUsage.ts";
 import type {IMaterial} from "../material/IMaterial.ts";
-import type {Scene} from "../scene/Scene.ts";
 
 /**
  * The mesh of a quad.
  */
-export class QuadMesh extends Mesh {
+export class QuadMesh extends RenderableMesh {
 
     private readonly ELEMENTS_IN_VERTEX = 9;
     private readonly TEX_COORD_POS_S = 7;
@@ -18,13 +17,12 @@ export class QuadMesh extends Mesh {
     /**
      * The constructor.
      * @param framework The framework.
-     * @param scene The scene the quad adds itself to.
      * @param material The material.
      * @param _isUpdatable Makes mesh updatable.
      * @param scale The scale factor for geometry. If not set, it is set to (1,1).
      */
-    public constructor(framework: IFramework, scene: Scene, material: IMaterial, private _isUpdatable: boolean, scale?: vec2) {
-    super(framework, scene, material);
+    public constructor(framework: IFramework, material: IMaterial, private _isUpdatable: boolean, scale?: vec2) {
+        super(framework, material);
         if(_isUpdatable) {
             this._bufferUsage = BufferUsage.VERTEX | BufferUsage.COPY_DST;
         }

package/src/api/meshes/RenderableMesh.ts

@@ -0,0 +1,207 @@
+import {mat4, quat, vec3} from "gl-matrix";
+import {Mesh} from "./Mesh.ts";
+import type {IRenderableMesh} from "./IRenderableMesh.ts";
+import type {IFramework} from "../IFramework.ts";
+import type {IMaterial} from "../material/IMaterial.ts";
+import type {IUniformBuffer} from "../rendering/buffers/IUniformBuffer.ts";
+import type {IVertexBuffer} from "../rendering/buffers/IVertexBuffer.ts";
+import type {IIndexBuffer} from "../rendering/buffers/IIndexBuffer.ts";
+import type {GeometryFormat} from "../geometry/GeometryFormat.ts";
+import {BufferUsage} from "../rendering/buffers/BufferUsage.ts";
+
+/**
+ * A mesh that can be drawn (C# `RenderableMesh`). See {@link IRenderableMesh}.
+ *
+ * - Root: `new RenderableMesh(framework, material?)` owns the vertex and index buffers, the transform and the model buffer.
+ * - Sub mesh: `new RenderableMesh(framework, material, parent, indexStart, indexCount)` (or `parent.addSubMesh(...)`)
+ *   shares the parent's buffers, transform and model buffer, and only stores its index range.
+ * @public
+ */
+export class RenderableMesh extends Mesh implements IRenderableMesh {
+
+    private readonly _subMeshes: RenderableMesh[] = [];
+    private readonly _parent?: RenderableMesh;
+
+    // Transform; only used on the root.
+    private _position: vec3 = vec3.create();
+    private _rotation: vec3 = vec3.create();
+    private _scale: vec3 = vec3.fromValues(1, 1, 1);
+    private readonly _modelMatrix = mat4.create();
+    private readonly _rotationQuat = quat.create();
+    // Cached copies to detect in-place edits; NaN forces the first computation.
+    private readonly _lastPosition = vec3.fromValues(NaN, NaN, NaN);
+    private readonly _lastRotation = vec3.create();
+    private readonly _lastScale = vec3.create();
+    private _modelBuffer?: IUniformBuffer;
+    /** The matrix last uploaded to the model buffer. */
+    private readonly _uploadedMatrix = mat4.create();
+
+    /** @inheritDoc */
+    public material?: IMaterial;
+
+    /** @inheritDoc */
+    public readonly indexStart: number;
+
+    /** @inheritDoc */
+    public readonly indexCount: number;
+
+    /**
+     * The constructor.
+     * @param framework The framework.
+     * @param material The material. Optional for a root mesh drawn only through its sub meshes.
+     * @param parent The parent, for a sub mesh. A sub mesh shares the parent's buffers and transform and is added to `parent.subMeshes`.
+     * @param indexStart The first index of the range. Defaults to 0.
+     * @param indexCount The number of indices of the range. -1 (default) draws all indices.
+     */
+    public constructor(framework: IFramework, material?: IMaterial, parent?: RenderableMesh, indexStart = 0, indexCount = -1) {
+        super(framework);
+        this.material = material;
+        this._parent = parent;
+        this.indexStart = indexStart;
+        this.indexCount = indexCount;
+        parent?._subMeshes.push(this);
+    }
+
+    /** The root mesh: the one owning the buffers and the transform. */
+    private get _root(): RenderableMesh {
+        return this._parent ? this._parent._root : this;
+    }
+
+    /** @inheritDoc */
+    public get parent(): RenderableMesh | undefined {
+        return this._parent;
+    }
+
+    /** @inheritDoc */
+    public get subMeshes(): readonly RenderableMesh[] {
+        return this._subMeshes;
+    }
+
+    /**
+     * Adds a sub mesh that draws a range of this mesh's index buffer with its own material.
+     * @param material The material of the sub mesh.
+     * @param indexStart The first index of the range.
+     * @param indexCount The number of indices in the range; -1 draws all.
+     * @returns The sub mesh.
+     */
+    public addSubMesh(material: IMaterial | undefined, indexStart: number, indexCount: number): RenderableMesh {
+        return new RenderableMesh(this._framework, material, this, indexStart, indexCount);
+    }
+
+    /** The parent's vertex buffer for a sub mesh, else its own. */
+    public override get vertexBuffer(): IVertexBuffer | undefined {
+        return this._parent ? this._parent.vertexBuffer : this._vertexBuffer;
+    }
+
+    /** The parent's index buffer for a sub mesh, else its own. */
+    public override get indexBuffer(): IIndexBuffer | undefined {
+        return this._parent ? this._parent.indexBuffer : this._indexBuffer;
+    }
+
+    /** The material's geometry format. */
+    protected override get _defaultGeometryFormat(): GeometryFormat | undefined {
+        return this.material?.geometryFormat;
+    }
+
+    /** @inheritDoc */
+    public get position(): vec3 { return this._root._position; }
+    public set position(value: vec3) { this._root._position = value; }
+
+    /** @inheritDoc */
+    public get rotation(): vec3 { return this._root._rotation; }
+    public set rotation(value: vec3) { this._root._rotation = value; }
+
+    /** @inheritDoc */
+    public get scale(): vec3 { return this._root._scale; }
+    public set scale(value: vec3) { this._root._scale = value; }
+
+    /** @inheritDoc */
+    public get modelMatrix(): mat4 {
+        const root = this._root;
+        if (root !== this) {
+            return root.modelMatrix;
+        }
+        if (!vec3.exactEquals(this._lastPosition, this._position)
+            || !vec3.exactEquals(this._lastRotation, this._rotation)
+            || !vec3.exactEquals(this._lastScale, this._scale)) {
+            vec3.copy(this._lastPosition, this._position);
+            vec3.copy(this._lastRotation, this._rotation);
+            vec3.copy(this._lastScale, this._scale);
+            const q = quat.identity(this._rotationQuat);
+            quat.rotateY(q, q, this._rotation[1]);
+            quat.rotateX(q, q, this._rotation[0]);
+            quat.rotateZ(q, q, this._rotation[2]);
+            mat4.fromRotationTranslationScale(this._modelMatrix, q, this._position, this._scale);
+        }
+        return this._modelMatrix;
+    }
+
+    /** @inheritDoc Created on first access and disposed with the root mesh. */
+    public get modelBuffer(): IUniformBuffer {
+        const root = this._root;
+        if (root !== this) {
+            return root.modelBuffer;
+        }
+        if (!this._modelBuffer) {
+            mat4.copy(this._uploadedMatrix, this.modelMatrix);
+            this._modelBuffer = this._framework.bufferFactory.createUniformBuffer(
+                this._uploadedMatrix, BufferUsage.UNIFORM | BufferUsage.COPY_DST, "RenderableMesh.modelBuffer");
+        }
+        return this._modelBuffer;
+    }
+
+    /** Uploads the root's model matrix when the transform changed since the last upload. */
+    private _updateModelBuffer(): IUniformBuffer {
+        const root = this._root;
+        const buffer = root.modelBuffer;
+        const matrix = root.modelMatrix;
+        if (!mat4.exactEquals(root._uploadedMatrix, matrix)) {
+            mat4.copy(root._uploadedMatrix, matrix);
+            buffer.update(root._uploadedMatrix);
+        }
+        return buffer;
+    }
+
+    /**
+     * Assigns the model buffer to a material that uses one (has a `modelBuffer` property), only when it differs.
+     * Materials without one (e.g. sprites) are skipped and no buffer is created for them.
+     */
+    private _assignModelBuffer(material: IMaterial): void {
+        if (!("modelBuffer" in material)) {
+            return;
+        }
+        const buffer = this._updateModelBuffer();
+        if (material.modelBuffer !== buffer) {
+            material.modelBuffer = buffer;
+        }
+    }
+
+    /** @inheritDoc */
+    public render(): void {
+        if (this.material) {
+            this._assignModelBuffer(this.material);
+            this.material.beforeRender();
+            this.material.renderMesh(this);
+        }
+        for (const subMesh of this._subMeshes) {
+            subMesh.render();
+        }
+    }
+
+    /**
+     * Disposes the sub meshes, then (for a root) the vertex, index and model buffers, once.
+     * A sub mesh never disposes the shared buffers. Materials are not disposed.
+     */
+    public override dispose(): void {
+        for (const subMesh of this._subMeshes) {
+            subMesh.dispose();
+        }
+        this._subMeshes.length = 0;
+        if (this._parent) {
+            return;
+        }
+        super.dispose();
+        this._modelBuffer?.dispose();
+        this._modelBuffer = undefined;
+    }
+}

package/src/api/meshes/_export.ts

@@ -1,7 +1,8 @@
 export * from "./IMeshFactory.ts";
-export * from "./IMesh.ts"
-export * from "./Mesh.ts"
-export * from "./SubMesh.ts"
+export * from "./IMesh.ts";
+export * from "./IRenderableMesh.ts";
+export * from "./Mesh.ts";
+export * from "./RenderableMesh.ts";
 export * from "./QuadMesh.ts";
-export * from "./MeshParameters.ts"
-export * from "./MeshFactory.ts";
+export * from "./MeshParameters.ts";
+export * from "./MeshFactory.ts";

package/src/api/rendering/IGraphicsDeviceFeatures.ts

@@ -3,30 +3,37 @@
  */
 export interface IGraphicsDeviceFeatures {
 
-/**
- * Supports S3TC / DXT (BC1–BC3) texture compression.
- */
-  readonly supportsTextureCompressionS3TC: boolean;
+    /**
+     * Supports S3TC / DXT (BC1–BC3) texture compression.
+     */
+    readonly supportsTextureCompressionS3TC: boolean;
 
-/**
- * Supports full Block Compression (BC1–BC7) textures.
-    Includes S3TC (BC1–BC3) plus BC4–BC7.
- */
-  readonly supportsTextureCompressionBC: boolean;
+    /**
+     * Supports the sRGB variants of S3TC / DXT (BC1–BC3).
+     * In WebGL2 this needs WEBGL_compressed_texture_s3tc_srgb; in WebGPU it is part of texture-compression-bc.
+     */
+    readonly supportsTextureCompressionS3TCSrgb: boolean;
 
-/**
- * Supports ETC2 / EAC texture compression (OpenGL/ES and Vulkan standard).
- */
-  readonly supportsTextureCompressionETC2: boolean;
+    /**
+     * Supports full Block Compression (BC1–BC7) textures.
+     Includes S3TC (BC1–BC3) plus BC4–BC7.
+     */
+    readonly supportsTextureCompressionBC: boolean;
 
-/**
- * Supports ASTC (Adaptive Scalable Texture Compression) — LDR and HDR profiles.
- */
-  readonly supportsTextureCompressionASTC: boolean;
+    /**
+     * Supports ETC2 / EAC texture compression (OpenGL/ES and Vulkan standard).
+     */
+    readonly supportsTextureCompressionETC2: boolean;
 
-/**
- * Supports PVRTC (PowerVR Texture Compression) 1 and 2.
- */
-  readonly supportsTextureCompressionPVRTC: boolean;
+    /**
+     * Supports ASTC (Adaptive Scalable Texture Compression) — LDR and HDR profiles.
+     */
+    readonly supportsTextureCompressionASTC: boolean;
+
+    /**
+     * Supports PVRTC (PowerVR Texture Compression) 1.
+     * PVRTC 2 is not supported by either WebGL2 or WebGPU context.
+     */
+    readonly supportsTextureCompressionPVRTC: boolean;
 
 }

package/src/api/rendering/IRenderer.ts

@@ -3,10 +3,40 @@ import {TextureFormat} from "./texture/TextureFormat.ts";
 import {Color} from "../data/Color.ts";
 import {RenderingBackend} from "./RenderingBackend.ts";
 import {vec2} from "gl-matrix";
+import type {PowerPreferenceType} from "./PowerPreference.ts";
+import type {TextureSamplerFilteringPreset} from "../../core/rendering/enums.ts";
+import type {TextureColorSpace} from "./enums.ts";
 
 
+/**
+ * The configuration for the renderer. This is used to initialize the renderer.
+ * @internal
+ */
+export interface IRendererConfiguration {
+
+    /**The size of the main frame buffer. */
+    backBufferSize: vec2;
+
+    /** 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 preset for texture sampler filtering.
+     * This is used to configure the default texture sampler in the graphics device.
+     * The default texture sampler is used when a texture is sampled without a specific sampler being bound.
+     */
+    textureFiltering: TextureSamplerFilteringPreset;
+
+    /** The desired texture color space. */
+    textureColorSpace: TextureColorSpace;
+}
+
 /**
  * The interface for a renderer.
+ * @public
  */
 export interface IRenderer {
 
@@ -16,7 +46,10 @@ export interface IRenderer {
     readonly graphicsDevice: IGraphicsDevice;
 
     /**
-     * The surface preferred a texture format.
+     * The preferred texture format.
+     * This will encode texture which do not specify texture format to:
+     * - {@link TextureFormat.} // TODO: describe SRGB depending on TextureSurfaceFormat requested
+     * - {@link TextureFormat.} // TODO: describe RGBA depending on TextureSurfaceFormat requested
      */
     readonly preferredTextureFormat: TextureFormat;
 

package/src/api/rendering/enums.ts

@@ -17,4 +17,14 @@ export enum Culling {
      * The front faces will be culled. Only back faces will be rendered.
      */
     Front
+}
+
+/** TODO: */
+export enum TextureColorSpace
+{
+    /** TODO */
+    LINEAR = "LINEAR",
+
+    /** TODO */
+    SRGB = "S_RGBA",
 }