ris-framework 0.1.0 → 0.2.0-dev.12

package/src/api/material/ForwardBlinnPhongMaterial.ts

@@ -0,0 +1,328 @@
+import type {IRenderableMesh} from "../meshes/IRenderableMesh.ts";
+import type {ITexture2D} from "../rendering/texture/ITexture2D.ts";
+import type {ISampler} from "../rendering/sampler/ISampler.ts";
+import {GeometryFormat} from "../geometry/GeometryFormat.ts";
+import type {IUniformBuffer} from "../rendering/buffers/IUniformBuffer.ts";
+import type {IIndexBuffer} from "../rendering/buffers/IIndexBuffer.ts";
+import type {IVertexBuffer} from "../rendering/buffers/IVertexBuffer.ts";
+import type {IFramework} from "../IFramework.ts";
+import {BufferUsage} from "../rendering/buffers/BufferUsage.ts";
+import {Color} from "../data/Color.ts";
+import type {IPrimitiveState} from "../rendering/primitive/IPrimitiveState.ts";
+import type {ICamera} from "../camera/ICamera.ts";
+import type {LightsBuffer} from "../lights/LightsBuffer.ts";
+import type {AmbientLight} from "../lights/AmbientLight.ts";
+import type {DirectionalLight} from "../lights/DirectionalLight.ts";
+import type {PointLight} from "../lights/PointLight.ts";
+import type {ICameraMaterial} from "./ICameraMaterial.ts";
+import type {ILightsMaterial} from "./ILightsMaterial.ts";
+import type {IForwardBlinnPhongRenderPipeline} from "../rendering/render-pipelines/IForwardBlinnPhongRenderPipeline.ts";
+
+/**
+ * The additional material config options.
+ * @public
+ **/
+export class ForwardBlinnPhongMaterialDescriptor {
+
+    /** The primitive state. */
+    public primitiveState?: IPrimitiveState;
+
+    /** The projection view buffer. */
+    public projectionViewBuffer!: IUniformBuffer;
+
+    /** The camera position buffer. */
+    public cameraPositionBuffer!: IUniformBuffer;
+}
+
+
+/**
+ * The Blinn-Phong material with forward calculated lighting.
+ * @public
+ */
+export class ForwardBlinnPhongMaterial implements ICameraMaterial, ILightsMaterial {
+
+    /** The directional light slots of the material's lights buffer and shader. */
+    public static readonly MAX_DIRECTIONAL_LIGHTS = 3;
+
+    /** The point light slots of the material's lights buffer and shader. */
+    public static readonly MAX_POINT_LIGHTS = 5;
+
+    private readonly _framework: IFramework;
+
+    private readonly _lightsBuffer: LightsBuffer;
+    private _diffuseColorCache: Color;
+    private _ambientColorCache: Color;
+    private _specularColorCache: Color;
+    private _shininessCache: number;
+
+    // std140: each vec3 starts on a 16-byte boundary, so pad each colour to 4 floats.
+    private _materialData = [
+        0.1, 0.1, 0.1, 0, // Ambient
+        0.8, 0.8, 0.8, 0, // Diffuse
+        0.5, 0.5, 0.5, 32, // Specular, shininess (the float fills the vec3's padding)
+    ];
+
+    /** Created when the model buffer is assigned (the pipeline requires one). */
+    private _pipeline?: IForwardBlinnPhongRenderPipeline;
+    private readonly _primitiveState?: IPrimitiveState;
+    /** Texture and sampler set before the pipeline exists; applied when it is created. */
+    private _pendingTexture?: ITexture2D;
+    private _pendingSampler?: ISampler;
+    private _samplerSet = false;
+    private _projectionViewBuffer: IUniformBuffer;
+    private _camera?: ICamera;
+    private _cameraPositionBuffer: IUniformBuffer;
+    private _materialBuffer: IUniformBuffer;
+    private _modelBuffer?: IUniformBuffer;
+
+    /**
+     * The constructor.
+     * @param framework The framework.
+     * @param descriptor The material descriptor. Its projection view and camera position buffers are shared and are not disposed by this material.
+     * @throws Error when `descriptor`, `descriptor.projectionViewBuffer` or `descriptor.cameraPositionBuffer` is missing.
+     */
+    public constructor(framework: IFramework, descriptor: ForwardBlinnPhongMaterialDescriptor) {
+
+        // Runtime check: JavaScript callers can omit the required buffers.
+        const missing = [
+            descriptor?.projectionViewBuffer ? undefined : "descriptor.projectionViewBuffer",
+            descriptor?.cameraPositionBuffer ? undefined : "descriptor.cameraPositionBuffer",
+        ].filter(x => x !== undefined);
+        if (missing.length > 0) {
+            throw new Error(`ForwardBlinnPhongMaterial: ${missing.join(" and ")} ${missing.length > 1 ? "are" : "is"} required (e.g. camera.projectionViewBuffer and camera.positionBuffer).`);
+        }
+
+        this._framework = framework;
+        const usage = BufferUsage.UNIFORM | BufferUsage.COPY_DST;
+        this._diffuseColorCache = this.diffuseColor.copy();
+        this._ambientColorCache = this.ambientColor.copy();
+        this._specularColorCache = this.specularColor.copy();
+        this._shininessCache = this.shininess;
+        this._projectionViewBuffer = descriptor.projectionViewBuffer;
+        this._cameraPositionBuffer = descriptor.cameraPositionBuffer;
+        this._materialBuffer = framework.bufferFactory.createUniformBuffer(this._materialData, usage);
+        this._primitiveState = descriptor.primitiveState;
+        // Owned by the material, like C#: 3 directional + 5 point slots (88 floats), uploaded only when the lights changed.
+        this._lightsBuffer = framework.lightsFactory.__createLightsBuffer({
+            maxDirectionalLights: ForwardBlinnPhongMaterial.MAX_DIRECTIONAL_LIGHTS,
+            maxPointLights: ForwardBlinnPhongMaterial.MAX_POINT_LIGHTS,
+        });
+        // The pipeline is created once a model buffer is assigned (see modelBuffer).
+    }
+
+    /** Creates the pipeline with the current bindings. */
+    private _createPipeline(modelBuffer: IUniformBuffer): IForwardBlinnPhongRenderPipeline {
+        const pipeline = this._framework.renderPipelineFactory.createForwardBlinnPhongRenderPipeline({
+            projectionViewBuffer: this._projectionViewBuffer,
+            modelBuffer,
+            materialBuffer: this._materialBuffer,
+            cameraPositionBuffer: this._cameraPositionBuffer,
+            lightsBuffer: this._lightsBuffer.buffer,
+            maxDirectionalLights: this._lightsBuffer.maxDirectionalLights,
+            maxPointLights: this._lightsBuffer.maxPointLights,
+            primitiveState: this._primitiveState,
+        });
+        if (this._pendingTexture) {
+            pipeline.diffuseTexture = this._pendingTexture;
+        }
+        if (this._samplerSet) {
+            pipeline.diffuseTextureSampler = this._pendingSampler;
+        }
+        this._pipeline = pipeline;
+        return pipeline;
+    }
+
+    /**
+     * The ambient color of this material.
+     * Alpha is ignored. By default, it is (0.1,0.1,0.1).
+     */
+    public ambientColor: Color = new Color(0.1, 0.1, 0.1);
+
+    /**
+     * The diffuse color of this material.
+     * Alpha is ignored. By default, it is (0.8,0.8,0.8).
+     */
+    public diffuseColor: Color = new Color(0.8, 0.8, 0.8);
+
+    /**
+     * The specular color of this material (MTL `Ks`).
+     * Alpha is ignored. By default, it is (0.5,0.5,0.5).
+     */
+    public specularColor: Color = new Color(0.5, 0.5, 0.5);
+
+    /**
+     * The specular exponent (MTL `Ns`). Higher values give smaller, sharper highlights. By default, it is 32.
+     */
+    public shininess = 32;
+
+    /**
+     * The camera. Setting it binds the camera's projection view and position buffers to the pipeline
+     * (used by the scene when its camera changes). Setting undefined keeps the last bound buffers.
+     * Undefined until set: the constructor only takes the buffers.
+     */
+    public get camera(): ICamera | undefined {
+        return this._camera;
+    }
+
+    /** @inheritDoc */
+    public set camera(camera: ICamera | undefined) {
+        if (camera === this._camera) {
+            return;
+        }
+        this._camera = camera;
+        if (!camera) {
+            return;
+        }
+        if (this._projectionViewBuffer !== camera.projectionViewBuffer) {
+            this._projectionViewBuffer = camera.projectionViewBuffer;
+            if (this._pipeline) {
+                this._pipeline.projectionViewBuffer = this._projectionViewBuffer;
+            }
+        }
+        if (this._cameraPositionBuffer !== camera.positionBuffer) {
+            this._cameraPositionBuffer = camera.positionBuffer;
+            if (this._pipeline) {
+                this._pipeline.cameraPositionBuffer = this._cameraPositionBuffer;
+            }
+        }
+    }
+
+    /** @inheritDoc Defaults to a black ambient light; a `Scene` assigns its active ambient light. */
+    public get ambientLight(): AmbientLight {
+        return this._lightsBuffer.ambientLight;
+    }
+
+    public set ambientLight(value: AmbientLight) {
+        this._lightsBuffer.ambientLight = value;
+    }
+
+    /** @inheritDoc Only the first 3 are used. A `Scene` assigns its own list. */
+    public get directionalLights(): DirectionalLight[] {
+        return this._lightsBuffer.directionalLights;
+    }
+
+    public set directionalLights(value: DirectionalLight[]) {
+        this._lightsBuffer.directionalLights = value;
+    }
+
+    /** @inheritDoc Only the first 5 are used. A `Scene` assigns its own list. */
+    public get pointLights(): PointLight[] {
+        return this._lightsBuffer.pointLights;
+    }
+
+    public set pointLights(value: PointLight[]) {
+        this._lightsBuffer.pointLights = value;
+    }
+
+    /**
+     * The texture to inspect.
+     */
+    public get diffuseTexture(): ITexture2D {
+        return this._pipeline?.diffuseTexture ?? this._pendingTexture!;
+    }
+
+    /**
+     * The texture to inspect.
+     */
+    public set diffuseTexture(value: ITexture2D) {
+        this._pendingTexture = value;
+        if (this._pipeline) {
+            this._pipeline.diffuseTexture = value;
+        }
+    }
+
+    /**
+     * The texture sampler.
+     */
+    public get diffuseTextureSampler(): ISampler | undefined {
+        return this._pipeline ? this._pipeline.diffuseTextureSampler : this._pendingSampler;
+    }
+
+    /**
+     * The texture sampler.
+     */
+    public set diffuseTextureSampler(value: ISampler | undefined) {
+        this._pendingSampler = value;
+        this._samplerSet = true;
+        if (this._pipeline) {
+            this._pipeline.diffuseTextureSampler = value;
+        }
+    }
+
+    /**
+     * The model buffer (std140 `mat4`). Owned by the mesh, which assigns it before drawing; never disposed by this material.
+     * Undefined until assigned: rendering without one throws.
+     */
+    public get modelBuffer(): IUniformBuffer | undefined {
+        return this._modelBuffer;
+    }
+
+    /** Binds the model buffer to the pipeline. */
+    public set modelBuffer(value: IUniformBuffer | undefined) {
+        if (value === this._modelBuffer) {
+            return;
+        }
+        this._modelBuffer = value;
+        if (!value) {
+            return;
+        }
+        if (this._pipeline) {
+            this._pipeline.modelBuffer = value;
+        } else {
+            this._createPipeline(value);
+        }
+    }
+
+    /**
+     * The geometry format.
+     */
+    public readonly geometryFormat = GeometryFormat.POS3_COLOR4_TEXTURECOORDS2_NORMAL3;
+
+    /** @inheritDoc */
+    public beforeRender(): void {
+        this._lightsBuffer.update();
+
+
+        if (!this._diffuseColorCache.equals(this.diffuseColor)
+            || !this._ambientColorCache.equals(this.ambientColor)
+            || !this._specularColorCache.equals(this.specularColor)
+            || this._shininessCache !== this.shininess) {
+            this._ambientColorCache.set(this.ambientColor);
+            this._diffuseColorCache.set(this.diffuseColor);
+            this._specularColorCache.set(this.specularColor);
+            this._shininessCache = this.shininess;
+            this._materialData[0] = this._ambientColorCache.r;
+            this._materialData[1] = this._ambientColorCache.g;
+            this._materialData[2] = this._ambientColorCache.b;
+            this._materialData[4] = this._diffuseColorCache.r;
+            this._materialData[5] = this._diffuseColorCache.g;
+            this._materialData[6] = this._diffuseColorCache.b;
+            this._materialData[8] = this._specularColorCache.r;
+            this._materialData[9] = this._specularColorCache.g;
+            this._materialData[10] = this._specularColorCache.b;
+            this._materialData[11] = this._shininessCache;
+            this._materialBuffer.update(this._materialData);
+        }
+    }
+
+    /** @inheritDoc */
+    public renderMesh(mesh: IRenderableMesh): void {
+        this.render(mesh.vertexBuffer!, mesh.indexBuffer!, mesh.indexCount ?? -1, mesh.indexStart ?? 0);
+    }
+
+    /** @inheritDoc */
+    public render(vertexBuffer: IVertexBuffer, indexBuffer: IIndexBuffer, indicesCount?: number, indicesOffset?: number): void {
+        if (!this._modelBuffer) {
+            throw new Error("ForwardBlinnPhongMaterial: no modelBuffer. Render it through a mesh (the mesh assigns its model buffer) or set material.modelBuffer.");
+        }
+        (this._pipeline ?? this._createPipeline(this._modelBuffer)).render(vertexBuffer, indexBuffer, indicesCount, indicesOffset);
+    }
+
+    /** @inheritDoc */
+    public dispose(): void {
+        this._pipeline?.dispose();
+        this._pipeline = undefined;
+        this._materialBuffer.dispose();
+        this._lightsBuffer.dispose();
+    }
+}

package/src/api/material/ICameraMaterial.ts

@@ -0,0 +1,22 @@
+import type { IMaterial } from "./IMaterial.ts";
+import type { ICamera } from "../camera/ICamera.ts";
+
+/**
+ * A material that renders with a camera (unlit, Blinn-Phong, inspect mips).
+ * A `Scene` assigns its camera to these materials in `scene.update()`.
+ * @public
+ */
+export interface ICameraMaterial extends IMaterial {
+
+    /** The camera. Setting it binds the camera's buffers. */
+    camera?: ICamera;
+}
+
+/**
+ * Whether a material is an {@link ICameraMaterial}.
+ * @param material The material.
+ * @public
+ */
+export function isCameraMaterial(material: IMaterial | undefined): material is ICameraMaterial {
+    return !!material && "camera" in material;
+}

package/src/api/material/ILightsMaterial.ts

@@ -0,0 +1,32 @@
+import type { IMaterial } from "./IMaterial.ts";
+import type { AmbientLight } from "../lights/AmbientLight.ts";
+import type { DirectionalLight } from "../lights/DirectionalLight.ts";
+import type { PointLight } from "../lights/PointLight.ts";
+
+/**
+ * A material lit by an ambient light, directional lights and point lights (Blinn-Phong).
+ * The material owns its lights buffer and uploads it only when the lights changed.
+ * A `Scene` hands each lights material its active ambient light and its own light lists (the same arrays, not copies)
+ * in `scene.update()`, so lights added to the scene reach every lit material.
+ * @public
+ */
+export interface ILightsMaterial extends IMaterial {
+
+    /** The ambient light. */
+    ambientLight: AmbientLight;
+
+    /** The directional lights. The list is used by reference and may be edited; extra lights beyond the slots are ignored. */
+    directionalLights: DirectionalLight[];
+
+    /** The point lights. The list is used by reference and may be edited; extra lights beyond the slots are ignored. */
+    pointLights: PointLight[];
+}
+
+/**
+ * Whether a material is an {@link ILightsMaterial}.
+ * @param material The material.
+ * @public
+ */
+export function isLightsMaterial(material: IMaterial | undefined): material is ILightsMaterial {
+    return !!material && "directionalLights" in material && "pointLights" in material && "ambientLight" in material;
+}

package/src/api/material/IMaterial.ts

@@ -1,23 +1,24 @@
-import {mat4} from "gl-matrix";
 import type { IDisposable } from "../core/IDisposable.ts";
 import {GeometryFormat} from "../geometry/GeometryFormat.ts";
-import type { IMesh } from "../meshes/IMesh.ts";
+import type { IRenderableMesh } from "../meshes/IRenderableMesh.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";
 
 /**
  * The material interface.
+ * @public
  */
 export interface IMaterial extends IDisposable {
 
     /**
-     * The model matrix.
+     * The model buffer (std140 `mat4`) for materials that use one (unlit, Blinn-Phong, inspect mips).
+     * A mesh owns it and assigns it before drawing, like the scene assigns its camera; materials never dispose it.
+     * Materials without the property (e.g. the sprite material) are left alone.
      */
-    modelMatrix: mat4;
+    modelBuffer?: IUniformBuffer;
 
-    /**
-     * The geometry format required by the material.
-     */
+    /** The geometry format required by the material.*/
     readonly geometryFormat: GeometryFormat;
 
     /**
@@ -26,16 +27,18 @@ export interface IMaterial extends IDisposable {
     beforeRender(): void;
 
     /**
-     * Renders the material.
+     * Renders the mesh with this material, honouring the mesh's index range.
      * @param mesh - The mesh.
      */
-    renderMesh(mesh: IMesh): void;
+    renderMesh(mesh: IRenderableMesh): void;
 
     /**
      * Renders the material.
      * @param vertexBuffer - The vertex buffer.
      * @param indexBuffer - The index buffer.
+     * @param indicesCount - The number of indices to draw. -1 or undefined draws all.
+     * @param indicesOffset - The first index to draw. Defaults to 0.
      */
-    render(vertexBuffer: IVertexBuffer, indexBuffer: IIndexBuffer): void;
+    render(vertexBuffer: IVertexBuffer, indexBuffer: IIndexBuffer, indicesCount?: number, indicesOffset?: number): void;
 
 }

package/src/api/material/IMaterialFactory.ts

@@ -1,5 +1,7 @@
 import {InspectTextureMipsMaterial} from "./InspectTextureMipsMaterial.ts";
+import type {SpriteMaterial, SpriteMaterialDescriptor} from "./SpriteMaterial.ts";
 import {UnlitMaterial, UnlitMaterialDescriptor} from "./UnlitMaterial.ts";
+import type {ForwardBlinnPhongMaterial, ForwardBlinnPhongMaterialDescriptor} from "./ForwardBlinnPhongMaterial.ts";
 
 /**
  * The material factory.
@@ -14,8 +16,23 @@ export interface IMaterialFactory {
 
     /**
      * Creates an unlit material.
-     * @param config The optional additional configuration options for material, such as rendering options.
+     * @param descriptor The optional additional configuration options for material, such as rendering options.
      * @returns The Unlit Material.
      */
-    createUnlitMaterial(config?: UnlitMaterialDescriptor): UnlitMaterial;
+    createUnlitMaterial(descriptor?: UnlitMaterialDescriptor): UnlitMaterial;
+
+    /**
+     * Creates a sprite material.
+     * @param descriptor The sprite material descriptor with projection view buffer, texture and sampler.
+     * @returns The Sprite Material.
+     */
+    createSpriteMaterial(descriptor: SpriteMaterialDescriptor): SpriteMaterial;
+
+    /**
+     * Creates a Blinn-Phong material with forward calculated lighting.
+     * @param descriptor The configuration: the required projection view and camera position buffers, plus optional lights buffer and primitive state.
+     * @throws Error when a required buffer is missing.
+     * @returns The Forward Blinn-Phong Material.
+     */
+    createForwardBlinnPhongMaterial(descriptor: ForwardBlinnPhongMaterialDescriptor): ForwardBlinnPhongMaterial;
 }

package/src/api/material/InspectTextureMipsMaterial.ts

@@ -1,4 +1,4 @@
-import type { IMesh } from "../meshes/IMesh.ts";
+import type {IRenderableMesh} from "../meshes/IRenderableMesh.ts";
 import type { ITexture2D } from "../rendering/texture/ITexture2D.ts";
 import type { IInspectTextureMipsRenderPipeline } from "../rendering/render-pipelines/IInspectTextureMipsRenderPipeline.ts";
 import type { ISampler } from "../rendering/sampler/ISampler.ts";
@@ -17,24 +17,39 @@ export class InspectTextureMipsMaterial {
 
     private readonly _framework: IFramework;
     private _mipLevel = [0];
-    private _pipeline: IInspectTextureMipsRenderPipeline;
+    /** Created when the model buffer is assigned (the pipeline requires one). */
+    private _pipeline?: IInspectTextureMipsRenderPipeline;
+    /** Texture and sampler set before the pipeline exists; applied when it is created. */
+    private _pendingTexture?: ITexture2D;
+    private _pendingSampler?: ISampler;
+    private _samplerSet = false;
     private _projectionViewBuffer: IUniformBuffer;
     private _fragmentDataBuffer: IUniformBuffer;
-    private _modelBuffer: IUniformBuffer;
-    private _previousModelMatrix = mat4.create();
+    private _modelBuffer?: IUniformBuffer;
 
     public constructor(framework: IFramework) {
         this._framework = framework;
-        void this._framework;
         const usage = BufferUsage.UNIFORM | BufferUsage.COPY_DST;
-        this._projectionViewBuffer = framework.bufferFactory.createUniformBuffer(this._previousModelMatrix, usage);
-        this._modelBuffer = framework.bufferFactory.createUniformBuffer(this._previousModelMatrix, usage);
+        this._projectionViewBuffer = framework.bufferFactory.createUniformBuffer(mat4.create(), usage);
         this._fragmentDataBuffer = framework.bufferFactory.createUniformBuffer(this._mipLevel, usage);
-        this._pipeline = framework.renderPipelineFactory.createInspectTextureMipsRenderPipeline(
+        // The pipeline is created once a model buffer is assigned (see modelBuffer).
+    }
+
+    /** Creates the pipeline with the current bindings. */
+    private _createPipeline(modelBuffer: IUniformBuffer): IInspectTextureMipsRenderPipeline {
+        const pipeline = this._framework.renderPipelineFactory.createInspectTextureMipsRenderPipeline(
             this._projectionViewBuffer,
-            this._modelBuffer,
+            modelBuffer,
             this._fragmentDataBuffer,
         );
+        if (this._pendingTexture) {
+            pipeline.spriteTexture = this._pendingTexture;
+        }
+        if (this._samplerSet) {
+            pipeline.textureSampler = this._pendingSampler;
+        }
+        this._pipeline = pipeline;
+        return pipeline;
     }
 
     /**
@@ -46,34 +61,60 @@ export class InspectTextureMipsMaterial {
      * The texture to inspect.
      */
     public get texture(): ITexture2D {
-        return this._pipeline.spriteTexture;
+        return this._pipeline?.spriteTexture ?? this._pendingTexture!;
     }
 
     /**
      * The texture to inspect.
      */
     public set texture(value: ITexture2D) {
-        this._pipeline.spriteTexture = value;
+        this._pendingTexture = value;
+        if (this._pipeline) {
+            this._pipeline.spriteTexture = value;
+        }
     }
 
     /**
      * The texture sampler.
      */
     public get textureSampler(): ISampler | undefined {
-        return this._pipeline.textureSampler;
+        return this._pipeline ? this._pipeline.textureSampler : this._pendingSampler;
     }
 
     /**
      * The texture sampler.
      */
     public set textureSampler(value: ISampler | undefined) {
-        this._pipeline.textureSampler = value;
+        this._pendingSampler = value;
+        this._samplerSet = true;
+        if (this._pipeline) {
+            this._pipeline.textureSampler = value;
+        }
     }
 
     /**
-     * The model matrix.
+     * The model buffer (std140 `mat4`). Owned by the mesh, which assigns it before drawing; never disposed by this material.
+     * Undefined until assigned: rendering without one throws.
      */
-    public modelMatrix: mat4 = mat4.create();
+    public get modelBuffer(): IUniformBuffer | undefined {
+        return this._modelBuffer;
+    }
+
+    /** Binds the model buffer to the pipeline. */
+    public set modelBuffer(value: IUniformBuffer | undefined) {
+        if (value === this._modelBuffer) {
+            return;
+        }
+        this._modelBuffer = value;
+        if (!value) {
+            return;
+        }
+        if (this._pipeline) {
+            this._pipeline.modelBuffer = value;
+        } else {
+            this._createPipeline(value);
+        }
+    }
 
     /**
      * The geometry format.
@@ -86,28 +127,26 @@ export class InspectTextureMipsMaterial {
             this._mipLevel[0] = this.mipLevel;
             this._fragmentDataBuffer.update(this._mipLevel);
         }
-
-        if (!mat4.equals(this._previousModelMatrix, this.modelMatrix)) {
-            mat4.copy(this._previousModelMatrix, this.modelMatrix);
-            this._modelBuffer.update(this._previousModelMatrix);
-        }
     }
 
     /** @inheritDoc */
-    public renderMesh(mesh: IMesh): void {
-        this.render(mesh.vertexBuffer!, mesh.indexBuffer!);
+    public renderMesh(mesh: IRenderableMesh): void {
+        this.render(mesh.vertexBuffer!, mesh.indexBuffer!, mesh.indexCount ?? -1, mesh.indexStart ?? 0);
     }
 
     /** @inheritDoc */
-    public render(vertexBuffer: IVertexBuffer, indexBuffer: IIndexBuffer): void {
-        this._pipeline.render(vertexBuffer, indexBuffer);
+    public render(vertexBuffer: IVertexBuffer, indexBuffer: IIndexBuffer, indicesCount?: number, indicesOffset?: number): void {
+        if (!this._modelBuffer) {
+            throw new Error("InspectTextureMipsMaterial: no modelBuffer. Render it through a mesh (the mesh assigns its model buffer) or set material.modelBuffer.");
+        }
+        (this._pipeline ?? this._createPipeline(this._modelBuffer)).render(vertexBuffer, indexBuffer, indicesCount, indicesOffset);
     }
 
     /** @inheritDoc */
     public dispose(): void {
-        this._pipeline.dispose();
+        this._pipeline?.dispose();
+        this._pipeline = undefined;
         this._projectionViewBuffer.dispose();
-        this._modelBuffer.dispose();
         this._fragmentDataBuffer.dispose();
     }
 }

package/src/api/material/MaterialFactory.ts

@@ -1,7 +1,9 @@
 import {InspectTextureMipsMaterial} from "./InspectTextureMipsMaterial.ts";
 import type { IFramework } from "../IFramework.ts";
 import type { IMaterialFactory } from "./IMaterialFactory.ts";
+import {SpriteMaterial, type SpriteMaterialDescriptor} from "./SpriteMaterial.ts";
 import {UnlitMaterial, UnlitMaterialDescriptor} from "./UnlitMaterial.ts";
+import {ForwardBlinnPhongMaterial, type ForwardBlinnPhongMaterialDescriptor} from "./ForwardBlinnPhongMaterial.ts";
 
 /**
  * The material factory.
@@ -24,4 +26,14 @@ export class MaterialFactory implements IMaterialFactory {
     public createUnlitMaterial(descriptor? : UnlitMaterialDescriptor): UnlitMaterial {
         return new UnlitMaterial(this._framework, descriptor );
     }
+
+    /** @inheritDoc */
+    public createSpriteMaterial(descriptor: SpriteMaterialDescriptor): SpriteMaterial {
+        return new SpriteMaterial(this._framework, descriptor);
+    }
+
+    /** @inheritDoc */
+    public createForwardBlinnPhongMaterial(descriptor: ForwardBlinnPhongMaterialDescriptor): ForwardBlinnPhongMaterial {
+        return new ForwardBlinnPhongMaterial(this._framework, descriptor);
+    }
 }