ris-framework 0.1.0-dev.9 → 0.2.0-dev.11

package/src/api/material/UnlitMaterial.ts

@@ -12,6 +12,7 @@ import {BufferUsage} from "../rendering/buffers/BufferUsage.ts";
 import {Color} from "../data/Color.ts";
 import type { IUnlitRenderPipeline } from "../rendering/render-pipelines/IUnlitRenderPipeline.ts";
 import type { IPrimitiveState } from "../rendering/primitive/IPrimitiveState.ts";
+import type {ICamera} from "../camera/ICamera.ts";
 
 /** The additional material config options */
 export class UnlitMaterialDescriptor {
@@ -19,8 +20,8 @@ export class UnlitMaterialDescriptor {
     /** The primitive state. */
     public primitiveState?: IPrimitiveState;
 
-    /** The projection view buffer to use */
-    public projectionViewBuffer?: IUniformBuffer;
+    /** The camera used to render this material. */
+    public camera?: ICamera;
 }
 
 
@@ -32,13 +33,19 @@ export class UnlitMaterial {
     private readonly _framework: IFramework;
     private _color = Color.white();
     private _materialData = [1,1,1,1];
-    private _pipeline: IUnlitRenderPipeline;
+    /** Created when the model buffer is assigned (the pipeline requires one). */
+    private _pipeline?: IUnlitRenderPipeline;
+    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;
     /** False when the projection view buffer came from the descriptor. The caller owns that one. */
-    private readonly _ownsProjectionViewBuffer: boolean;
+    private _ownsProjectionViewBuffer: boolean;
+    private _camera?: ICamera;
     private _materialBuffer: IUniformBuffer;
-    private _modelBuffer: IUniformBuffer;
-    private _previousModelMatrix = mat4.create();
+    private _modelBuffer?: IUniformBuffer;
 
     /**
      * The constructor.
@@ -47,18 +54,59 @@ export class UnlitMaterial {
      */
     public constructor(framework: IFramework, config? :UnlitMaterialDescriptor) {
         this._framework = framework;
-        void this._framework;
         const usage = BufferUsage.UNIFORM | BufferUsage.COPY_DST;
-        this._ownsProjectionViewBuffer = !config?.projectionViewBuffer;
-        this._projectionViewBuffer = config?.projectionViewBuffer ?? framework.bufferFactory.createUniformBuffer(this._previousModelMatrix, usage);
-        this._modelBuffer = framework.bufferFactory.createUniformBuffer(this._previousModelMatrix, usage);
+        this._camera = config?.camera;
+        // Without a camera an own zero buffer is bound, so rendering before the scene assigns one does not crash.
+        this._ownsProjectionViewBuffer = !config?.camera?.projectionViewBuffer;
+        this._projectionViewBuffer = config?.camera?.projectionViewBuffer ?? framework.bufferFactory.createUniformBuffer(mat4.create(), usage);
         this._materialBuffer = framework.bufferFactory.createUniformBuffer(this._materialData, usage);
-        this._pipeline = framework.renderPipelineFactory.createUnlitRenderPipeline(
+        this._primitiveState = config?.primitiveState;
+        // The pipeline is created once a model buffer is assigned (see modelBuffer).
+    }
+
+    /** Creates the pipeline with the current bindings. */
+    private _createPipeline(modelBuffer: IUniformBuffer): IUnlitRenderPipeline {
+        const pipeline = this._framework.renderPipelineFactory.createUnlitRenderPipeline(
             this._projectionViewBuffer,
-            this._modelBuffer,
+            modelBuffer,
             this._materialBuffer,
-            config?.primitiveState
+            this._primitiveState
         );
+        if (this._pendingTexture) {
+            pipeline.diffuseTexture = this._pendingTexture;
+        }
+        if (this._samplerSet) {
+            pipeline.diffuseTextureSampler = this._pendingSampler;
+        }
+        this._pipeline = pipeline;
+        return pipeline;
+    }
+
+    /**
+     * The camera. Setting it binds the camera's projection view buffer to the pipeline
+     * (the material's own placeholder buffer is disposed). Setting undefined keeps the last bound buffer.
+     */
+    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._ownsProjectionViewBuffer) {
+            this._projectionViewBuffer.dispose();
+            this._ownsProjectionViewBuffer = false;
+        }
+        this._projectionViewBuffer = camera.projectionViewBuffer;
+        if (this._pipeline) {
+            this._pipeline.projectionViewBuffer = this._projectionViewBuffer;
+        }
     }
 
     /**
@@ -70,34 +118,60 @@ export class UnlitMaterial {
      * The texture to inspect.
      */
     public get diffuseTexture(): ITexture2D {
-        return this._pipeline.diffuseTexture;
+        return this._pipeline?.diffuseTexture ?? this._pendingTexture!;
     }
 
     /**
      * The texture to inspect.
      */
     public set diffuseTexture(value: ITexture2D) {
-        this._pipeline.diffuseTexture = value;
+        this._pendingTexture = value;
+        if (this._pipeline) {
+            this._pipeline.diffuseTexture = value;
+        }
     }
 
     /**
      * The texture sampler.
      */
     public get diffuseTextureSampler(): ISampler | undefined {
-        return this._pipeline.diffuseTextureSampler;
+        return this._pipeline ? this._pipeline.diffuseTextureSampler : this._pendingSampler;
     }
 
     /**
      * The texture sampler.
      */
     public set diffuseTextureSampler(value: ISampler | undefined) {
-        this._pipeline.diffuseTextureSampler = value;
+        this._pendingSampler = value;
+        this._samplerSet = true;
+        if (this._pipeline) {
+            this._pipeline.diffuseTextureSampler = 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.
@@ -114,30 +188,28 @@ export class UnlitMaterial {
             this._materialData[3] = this._color.a;
             this._materialBuffer.update(this._materialData);
         }
-
-        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!);
+        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("UnlitMaterial: 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;
         if (this._ownsProjectionViewBuffer) {
             this._projectionViewBuffer.dispose();
         }
-        this._modelBuffer.dispose();
         this._materialBuffer.dispose();
     }
 }

package/src/api/material/_export.ts

@@ -2,4 +2,6 @@ export * from "./IMaterial.ts"
 export * from "./IMaterialFactory.ts"
 export * from "./InspectTextureMipsMaterial.ts"
 export * from "./MaterialFactory.ts"
-export * from "./UnlitMaterial.ts"
+export * from "./SpriteMaterial.ts"
+export * from "./UnlitMaterial.ts"
+export * from "./ForwardBlinnPhongMaterial.ts"

package/src/api/meshes/IMesh.ts

@@ -1,20 +1,59 @@
 import type { IVertexBuffer } from "../rendering/buffers/IVertexBuffer.ts";
 import type { IDisposable } from "../core/IDisposable.ts";
 import type { IIndexBuffer } from "../rendering/buffers/IIndexBuffer.ts";
+import type { IMaterial } from "../material/IMaterial.ts";
+import type { mat4, vec3 } from "gl-matrix";
+import type { IUniformBuffer } from "../rendering/buffers/IUniformBuffer.ts";
 
 /**
- * The mesh interface.
+ * Represents a mesh containing geometry, material information, and optionally child submeshes.
+ * A mesh may contain vertex and index buffers directly, or act as a container for submeshes.
+ * @public
  */
 export interface IMesh extends IDisposable {
 
+    /** The vertex buffer containing the mesh's vertex data, if any. */
+    readonly vertexBuffer?: IVertexBuffer;
+
+    /** The index buffer containing the mesh's index data, if any. */
+    readonly indexBuffer?: IIndexBuffer;
+
+    /** The material assigned to this mesh, if any. */
+    material?: IMaterial;
+
+    /** First index in {@link indexBuffer} to draw. Undefined draws from 0. */
+    readonly indexStart?: number;
+
+    /** Number of indices to draw. Undefined draws the whole index buffer. */
+    readonly indexCount?: number;
+
+    /** The child submeshes contained in this mesh, if any. */
+    readonly subMeshes?: IMesh[];
+
+    /** World position. Defaults to the origin. In-place edits are detected. */
+    position: vec3;
+
     /**
-     * The positions buffer.
+     * Euler rotation in radians, applied in Y, X, Z order (yaw, pitch, roll): `R = Ry * Rx * Rz`.
+     * Defaults to (0, 0, 0). In-place edits are detected.
      */
-    readonly vertexBuffer?: IVertexBuffer;
+    rotation: vec3;
+
+    /** Scale. Defaults to (1, 1, 1). In-place edits are detected. */
+    scale: vec3;
 
     /**
-     * The indices buffer.
+     * The model matrix `T * R * S`, recomputed only when position, rotation or scale changed.
      */
-    readonly indexBuffer?: IIndexBuffer;
+    readonly modelMatrix: mat4;
+
+    /**
+     * The model buffer (std140 `mat4`) holding {@link modelMatrix}. Owned by the mesh (submeshes share the parent's),
+     * uploaded when the transform changed and assigned to the material(s) before drawing.
+     * Created on first use.
+     */
+    readonly modelBuffer: IUniformBuffer;
 
-}
+    /** Render the mesh. */
+    render(): void;
+}

package/src/api/meshes/IMeshFactory.ts

@@ -1,8 +1,19 @@
 import type { IGeometry } from "../geometry/IGeometry.ts";
-import {GeometryFormat} from "../geometry/GeometryFormat.ts";
 import {QuadMesh} from "./QuadMesh.ts";
 import {vec2} from "gl-matrix";
 import type { IMesh } from "./IMesh.ts";
+import type { IMaterial } from "../material/IMaterial.ts";
+import type { Scene } from "../scene/Scene.ts";
+
+/** Describes one submesh: a material and the index range it draws. */
+export interface SubMeshDescriptor {
+    /** The material. */
+    readonly material: IMaterial;
+    /** The first index of the range. */
+    readonly indexStart: number;
+    /** The number of indices in the range. */
+    readonly indexCount: number;
+}
 
 /**
  * The mesh factory.
@@ -10,12 +21,24 @@ import type { IMesh } from "./IMesh.ts";
 export interface IMeshFactory {
 
     /**
-     * Creates a mesh.
+     * Creates a mesh and adds it to the scene.
+     * @param scene - The scene the mesh adds itself to.
+     * @param geometry - The geometry.
+     * @param material - The material.
+     * @returns The mesh.
+     */
+    create(scene: Scene, geometry: IGeometry, material: IMaterial): IMesh;
+
+    /**
+     * Creates a mesh made of submeshes that share one vertex and one index buffer.
+     * The mesh itself has no material; `scene.render()` (or `mesh.render()`) draws its submeshes.
+     * Only the mesh is added to the scene, not the submeshes.
+     * @param scene - The scene the mesh adds itself to.
      * @param geometry - The geometry.
-     * @param geometryFormat - The geometry format.
+     * @param subMeshes - One entry per submesh. All materials must use the same geometry format.
      * @returns The mesh.
      */
-    create(geometry: IGeometry, geometryFormat: GeometryFormat): IMesh;
+    createWithSubMeshes(scene: Scene, geometry: IGeometry, subMeshes: SubMeshDescriptor[]): IMesh;
 
     /**
      * Creates the quad mesh.

package/src/api/meshes/Mesh.ts

@@ -1,23 +1,27 @@
 /**
  * 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 { 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 {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 {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 {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.
  */
 export class Mesh implements IMesh {
 
-    protected readonly _framework: IFramework;
     protected _bufferUsage = BufferUsage.VERTEX;
     protected _state = State.CREATED;
     protected _vertexData?: number[];
@@ -28,13 +32,116 @@ 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;
+        }
+    }
 
     /**
      * The constructor.
-     * @param framework The framework.
+     * @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(framework: IFramework) {
-        this._framework = framework;
+    public constructor(protected readonly _framework: IFramework, public readonly scene: Scene | null, protected _material?: IMaterial) {
+        scene?.add(this);
+    }
+
+    /** The material. Undefined for a mesh drawn through its submeshes. */
+    public get material(): IMaterial | undefined {
+        return this._material;
+    }
+
+    /** 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;
     }
 
     /**
@@ -90,7 +197,7 @@ export class Mesh implements IMesh {
      * The index buffer.
      */
     public get indexBuffer(): IIndexBuffer | undefined {
-        return this._indexBuffer ;
+        return this._indexBuffer;
     }
 
     /**
@@ -100,25 +207,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 +237,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 +256,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 +286,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,15 +300,18 @@ 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. Defaults to the 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._material?.geometryFormat;
+        if (format === undefined) {
+            throw new Error("Cannot create buffers for a Mesh without a material or geometry format.");
+        }
+        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);
         }
@@ -226,8 +328,7 @@ export class Mesh implements IMesh {
 
         // Indices
         this._indexBuffer?.dispose();
-        if (geometry.indices)
-        {
+        if (geometry.indices) {
             this._indexBuffer = this._framework.bufferFactory.createIndexBuffer(geometry.indices);
         }
     }
@@ -244,13 +345,34 @@ 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.
      */
     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;
     }
 }