ris-framework 0.1.0 → 0.2.0-dev.12

package/src/api/meshes/Mesh.ts

@@ -2,22 +2,23 @@
  * The mesh is a building class for a world shape.
  */
 import {State} from "../data/State.ts";
-import type { IVertexBuffer } from "../rendering/buffers/IVertexBuffer.ts";
-import type { IIndexBuffer } from "../rendering/buffers/IIndexBuffer.ts";
-import type { IFramework } from "../IFramework.ts";
-import type { IMesh } from "./IMesh.ts";
+import type {IVertexBuffer} from "../rendering/buffers/IVertexBuffer.ts";
+import type {IIndexBuffer} from "../rendering/buffers/IIndexBuffer.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 {GeometryFormat} from "../geometry/GeometryFormat.ts";
+import type {IGeometry} from "../geometry/IGeometry.ts";
 import {MeshParameters} from "./MeshParameters.ts";
 import {GeometryUtilities} from "../utilities/GeometryUtilities.ts";
+import type {GeometryFormat} from "../geometry/GeometryFormat.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 {
 
-    protected readonly _framework: IFramework;
     protected _bufferUsage = BufferUsage.VERTEX;
     protected _state = State.CREATED;
     protected _vertexData?: number[];
@@ -28,13 +29,23 @@ export class Mesh implements IMesh {
     protected _normals?: number[];
     protected _vertexBuffer?: IVertexBuffer;
     protected _indexBuffer?: IIndexBuffer;
+    protected _geometry?: IGeometry;
 
     /**
      * The constructor.
-     * @param framework The framework.
+     * @param _framework The framework.
      */
-    public constructor(framework: IFramework) {
-        this._framework = framework;
+    public constructor(protected readonly _framework: IFramework) {
+    }
+
+    /** The geometry the buffers were created from with {@link setGeometry}, if any. */
+    public get geometry(): IGeometry | undefined {
+        return this._geometry;
+    }
+
+    /** The geometry format used when {@link setGeometry} is called without one. Undefined for a plain mesh. */
+    protected get _defaultGeometryFormat(): GeometryFormat | undefined {
+        return undefined;
     }
 
     /**
@@ -90,7 +101,7 @@ export class Mesh implements IMesh {
      * The index buffer.
      */
     public get indexBuffer(): IIndexBuffer | undefined {
-        return this._indexBuffer ;
+        return this._indexBuffer;
     }
 
     /**
@@ -100,25 +111,24 @@ export class Mesh implements IMesh {
         this.applyChanges();
     }
 
-    private _fillColors(index: {vertexDataIndex: number, colorIndex: number}, colors: number[]): void {
+    private _fillColors(index: { vertexDataIndex: number, colorIndex: number }, colors: number[]): void {
 
-        if(!this._vertexData) {
+        if (!this._vertexData) {
             throw new Error("Vertex data is not initialized");
         }
 
         let v = index.vertexDataIndex;
         let c = index.colorIndex;
 
-        if(colors.length > index.colorIndex) {
+        if (colors.length > index.colorIndex) {
             this._vertexData[v++] = colors[c++];
             this._vertexData[v++] = colors[c++];
             this._vertexData[v++] = colors[c++];
             this._vertexData[v++] = colors[c++];
             index.vertexDataIndex = v;
-        }
-        else {
+        } else {
             // Just prefill with white color
-            this._vertexData[v++] =1;
+            this._vertexData[v++] = 1;
             this._vertexData[v++] = 1;
             this._vertexData[v++] = 1;
             this._vertexData[v++] = 1;
@@ -131,10 +141,8 @@ export class Mesh implements IMesh {
     /**
      * Apply changes to the mesh.
      */
-    public applyChanges()
-    {
-        if (!this._positions ||this._positions.length == 0)
-        {
+    public applyChanges() {
+        if (!this._positions || this._positions.length == 0) {
             //_framework.Logger.LogWarning("Cannot create buffers for a Mesh as Mesh has no positions.");
             throw new Error(`Cannot create buffers for a Mesh as Mesh has no positions`);
         }
@@ -152,31 +160,27 @@ export class Mesh implements IMesh {
         let normalIndex = 0;
         let uvsIndex = 0;
 
-        for (let i = 0; i < vertexCount; i++)
-        {
+        for (let i = 0; i < vertexCount; i++) {
             // Positions.
             this._vertexData[vertexIndex++] = this._positions[positionsIndex++];
             this._vertexData[vertexIndex++] = this._positions[positionsIndex++];
             this._vertexData[vertexIndex++] = this._positions[positionsIndex++];
 
             // Colors.
-            if (this._colors)
-            {
+            if (this._colors) {
                 const index = {vertexDataIndex: vertexIndex, colorIndex: colorIndex};
                 this._fillColors(index, this._colors);
                 vertexIndex = index.vertexDataIndex;
                 colorIndex = index.colorIndex;
             }
 
-            if (this._textureCoords)
-            {
+            if (this._textureCoords) {
                 // Uvs.
                 this._vertexData[vertexIndex++] = this._textureCoords[uvsIndex++];
                 this._vertexData[vertexIndex++] = this._textureCoords[uvsIndex++];
             }
 
-            if (this._normals)
-            {
+            if (this._normals) {
                 this._vertexData[vertexIndex++] = this._normals[normalIndex++];
                 this._vertexData[vertexIndex++] = this._normals[normalIndex++];
                 this._vertexData[vertexIndex++] = this._normals[normalIndex++];
@@ -186,13 +190,12 @@ export class Mesh implements IMesh {
         // Vertices
         this._vertexBuffer?.dispose();
         this._vertexBuffer = this._framework.bufferFactory.createVertexBuffer(
-                this._vertexData, stride, this._bufferUsage);
+            this._vertexData, stride, this._bufferUsage);
 
         // Indices
         this._indexBuffer?.dispose();
-        if (this._indices && this._indices.length > 0)
-        {
-            this._indexBuffer= this._framework.bufferFactory.createIndexBuffer(
+        if (this._indices && this._indices.length > 0) {
+            this._indexBuffer = this._framework.bufferFactory.createIndexBuffer(
                 this._indices);
         }
     }
@@ -201,19 +204,23 @@ export class Mesh implements IMesh {
      * Sets the mesh from a geometry.
      *
      * This will create vertex buffer and index buffer from geometry.
-     * Positions, Colors, TextureCoordinates  and Normals will be ignored.
      * @param geometry - The geometry.
-     * @param format - The format for geometry.
+     * @param geometryFormat - The vertex layout. A `RenderableMesh` defaults to its material's geometry format.
      */
-    public setGeometry(geometry: IGeometry, format: GeometryFormat): void {
-        if (geometry.vertexCount == 0)
-        {
+    public setGeometry(geometry: IGeometry, geometryFormat?: GeometryFormat): void {
+
+        const format = geometryFormat ?? this._defaultGeometryFormat;
+        if (format === undefined) {
+            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 =
-            "Cannot create buffers for a Mesh as Mesh has no positions. Check that geometry.vertexCount is set.";
+                "Cannot create buffers for a Mesh as Mesh has no positions. Check that geometry.vertexCount is set.";
             //_framework.Logger.LogError(message);
             throw new Error(message);
         }
 
+        this._geometry = geometry;
         const interleavedData = geometry.toInterleaved(format);
         const stride = GeometryUtilities.stride(format);
 
@@ -226,8 +233,7 @@ export class Mesh implements IMesh {
 
         // Indices
         this._indexBuffer?.dispose();
-        if (geometry.indices)
-        {
+        if (geometry.indices) {
             this._indexBuffer = this._framework.bufferFactory.createIndexBuffer(geometry.indices);
         }
     }
@@ -245,12 +251,13 @@ export class Mesh implements IMesh {
     }
 
     /**
-     * Dispose of the mesh.
+     * Disposes the vertex and index buffers.
      */
     public dispose(): void {
         this._vertexBuffer?.dispose();
         this._vertexBuffer = undefined;
         this._indexBuffer?.dispose();
         this._indexBuffer = undefined;
+        this._state = State.DISPOSED;
     }
 }

package/src/api/meshes/MeshFactory.ts

@@ -1,11 +1,15 @@
+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 {GeometryFormat} from "../geometry/GeometryFormat.ts";
 import type { IMesh } from "./IMesh.ts";
 import {QuadMesh} from "./QuadMesh.ts";
 import type { IFramework } from "../IFramework.ts";
 import {Mesh} from "./Mesh.ts";
 import {vec2} from "gl-matrix";
+import type { IMaterial } from "../material/IMaterial.ts";
+import type { SubMeshDescriptor } from "./IMeshFactory.ts";
 
 /**
  * The implementation of the mesh factory interface.
@@ -20,17 +24,46 @@ export class MeshFactory implements IMeshFactory {
     }
 
     /** @inheritDoc */
-    public create(geometry: IGeometry, geometryFormat: GeometryFormat): IMesh {
+    public createMesh(geometry: IGeometry, geometryFormat: GeometryFormat): IMesh {
         const mesh = new Mesh(this._framework);
         mesh.setGeometry(geometry, geometryFormat);
         return mesh;
     }
 
     /** @inheritDoc */
-    public createQuadMesh(isUpdatable: boolean, scale?: vec2): QuadMesh {
-        const quadMesh = new QuadMesh(this._framework, isUpdatable, scale);
+    public create(geometry: IGeometry, material: IMaterial): IRenderableMesh {
+        const mesh = new RenderableMesh(this._framework, material);
+        mesh.setGeometry(geometry);
+        return mesh;
+    }
+
+    /** @inheritDoc */
+    public createWithSubMeshes(geometry: IGeometry, subMeshes: SubMeshDescriptor[]): IRenderableMesh {
+        if (subMeshes.length == 0) {
+            throw new Error("createWithSubMeshes needs at least one submesh.");
+        }
+        const format = subMeshes[0].material.geometryFormat;
+        if (subMeshes.some(s => s.material.geometryFormat != format)) {
+            throw new Error("All submesh materials must use the same geometry format, as they share one vertex buffer.");
+        }
+
+        const mesh = new RenderableMesh(this._framework);
+        mesh.setGeometry(geometry, format);
+        for (const subMesh of subMeshes) {
+            mesh.addSubMesh(subMesh.material, subMesh.indexStart, subMesh.indexCount);
+        }
+        return mesh;
+    }
+
+    /** @inheritDoc */
+    public createQuadMesh(_isUpdatable: boolean, _scale?: vec2): QuadMesh {
+
+        throw new Error("Meshes not implemented.");
+        /*  const quadMesh = new QuadMesh(this._framework, isUpdatable, scale);
         quadMesh.initialize();
         return quadMesh;
+
+       */
     }
 
 }

package/src/api/meshes/QuadMesh.ts

@@ -1,13 +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";
 
 /**
  * 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;
@@ -16,11 +17,12 @@ export class QuadMesh extends Mesh {
     /**
      * The constructor.
      * @param framework The framework.
+     * @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, private _isUpdatable: boolean, scale?: vec2) {
-    super(framework);
+    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,6 +1,8 @@
 export * from "./IMeshFactory.ts";
-export * from "./IMesh.ts"
-export * from "./Mesh.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",
 }