ris-framework 0.1.0-dev.7 → 0.1.0-dev.9

package/src/api/loaders/ImageLoader.ts

@@ -0,0 +1,93 @@
+import type { IImageLoader } from "./IImageLoader.ts";
+import type { IFramework } from "../IFramework.ts";
+import {TextureFormat} from "../rendering/texture/TextureFormat.ts";
+import {RawImageData} from "../image/RawImageData.ts";
+
+/**
+ * The image loader.
+ *
+ * Loads images through the browser Fetch API and converts them
+ * into raw pixel data suitable for the rendering backend.
+ */
+export class ImageLoader implements IImageLoader {
+
+    /**
+     * A temporary cache is released when the engine clears it.
+     * It exists only for the duration of a loading/initialization operation.
+     */
+    private readonly _tempCache: Record<string, RawImageData> = {};
+
+    /**
+     * Persistent cache is released only when the application
+     * is closed or the cache is manually cleared.
+     */
+    private readonly _permanentCache: Record<string, RawImageData> = {};
+
+    /**
+     * The constructor.
+     * @param _framework The framework.
+     */
+    public constructor(
+        private readonly _framework: IFramework,
+    ) {
+    }
+
+    /**
+     * Loads a PNG/JPEG/etc. image using fetch.
+     */
+    private async _loadImage(
+        path: string,
+        preferredTextureFormat: TextureFormat,
+    ): Promise<RawImageData> {
+        void preferredTextureFormat;
+
+        return new Promise((resolve, reject) => {
+            const image = new Image();
+            image.onload = () => {
+                resolve(new RawImageData([image], image.width, image.height, 4));
+            };
+            image.onerror = (e) => {
+                console.error("failed to load", image.src, e);
+                reject();
+            }
+            image.src = path;
+        });
+    }
+
+    /** @inheritDoc */
+    public async loadAsync(
+        path: string,
+        cache: boolean = false,
+    ): Promise<RawImageData> {
+
+        const selectedCache = cache
+            ? this._permanentCache
+            : this._tempCache;
+
+        const cached = selectedCache[path];
+
+        if (cached !== undefined) {
+            return cached;
+        }
+
+        const imageData = await this._loadImage(
+            path,
+            this._framework.renderer.preferredTextureFormat,
+        );
+
+        selectedCache[path] = imageData;
+
+        return imageData;
+    }
+
+    /** @inheritDoc */
+    public disposeOfTemporaryCache(): void {
+        for (const imageData of Object.values(this._tempCache)) {
+            imageData.dispose();
+        }
+
+        Object.keys(this._tempCache).forEach(
+            key => delete this._tempCache[key],
+        );
+    }
+}

package/src/api/loaders/_export.ts

@@ -0,0 +1,2 @@
+export * from "./IImageLoader.ts"
+export * from "./ImageLoader.ts"

package/src/api/material/IMaterial.ts

@@ -0,0 +1,41 @@
+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 { IVertexBuffer } from "../rendering/buffers/IVertexBuffer.ts";
+import type { IIndexBuffer } from "../rendering/buffers/IIndexBuffer.ts";
+
+/**
+ * The material interface.
+ */
+export interface IMaterial extends IDisposable {
+
+    /**
+     * The model matrix.
+     */
+    modelMatrix: mat4;
+
+    /**
+     * The geometry format required by the material.
+     */
+    readonly geometryFormat: GeometryFormat;
+
+    /**
+     * Called before rendering.
+     */
+    beforeRender(): void;
+
+    /**
+     * Renders the material.
+     * @param mesh - The mesh.
+     */
+    renderMesh(mesh: IMesh): void;
+
+    /**
+     * Renders the material.
+     * @param vertexBuffer - The vertex buffer.
+     * @param indexBuffer - The index buffer.
+     */
+    render(vertexBuffer: IVertexBuffer, indexBuffer: IIndexBuffer): void;
+
+}

package/src/api/material/IMaterialFactory.ts

@@ -0,0 +1,21 @@
+import {InspectTextureMipsMaterial} from "./InspectTextureMipsMaterial.ts";
+import {UnlitMaterial, UnlitMaterialDescriptor} from "./UnlitMaterial.ts";
+
+/**
+ * The material factory.
+ */
+export interface IMaterialFactory {
+
+    /**
+     * Creates a material for inspecting texture mips.
+     * @returns The Inspect Texture Mips Material.
+     */
+    createInspectTextureMipsMaterial(): InspectTextureMipsMaterial;
+
+    /**
+     * Creates an unlit material.
+     * @param config The optional additional configuration options for material, such as rendering options.
+     * @returns The Unlit Material.
+     */
+    createUnlitMaterial(config?: UnlitMaterialDescriptor): UnlitMaterial;
+}

package/src/api/material/InspectTextureMipsMaterial.ts

@@ -0,0 +1,113 @@
+import type { IMesh } from "../meshes/IMesh.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";
+import {mat4} from "gl-matrix";
+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";
+
+/**
+ * Material for inspecting texture mips.
+ */
+export class InspectTextureMipsMaterial {
+
+    private readonly _framework: IFramework;
+    private _mipLevel = [0];
+    private _pipeline: IInspectTextureMipsRenderPipeline;
+    private _projectionViewBuffer: IUniformBuffer;
+    private _fragmentDataBuffer: IUniformBuffer;
+    private _modelBuffer: IUniformBuffer;
+    private _previousModelMatrix = mat4.create();
+
+    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._fragmentDataBuffer = framework.bufferFactory.createUniformBuffer(this._mipLevel, usage);
+        this._pipeline = framework.renderPipelineFactory.createInspectTextureMipsRenderPipeline(
+            this._projectionViewBuffer,
+            this._modelBuffer,
+            this._fragmentDataBuffer,
+        );
+    }
+
+    /**
+     * The mip level to inspect.
+     */
+    public mipLevel: number = 0;
+
+    /**
+     * The texture to inspect.
+     */
+    public get texture(): ITexture2D {
+        return this._pipeline.spriteTexture;
+    }
+
+    /**
+     * The texture to inspect.
+     */
+    public set texture(value: ITexture2D) {
+        this._pipeline.spriteTexture = value;
+    }
+
+    /**
+     * The texture sampler.
+     */
+    public get textureSampler(): ISampler | undefined {
+        return this._pipeline.textureSampler;
+    }
+
+    /**
+     * The texture sampler.
+     */
+    public set textureSampler(value: ISampler | undefined) {
+        this._pipeline.textureSampler = value;
+    }
+
+    /**
+     * The model matrix.
+     */
+    public modelMatrix: mat4 = mat4.create();
+
+    /**
+     * The geometry format.
+     */
+    public readonly geometryFormat = GeometryFormat.POS3_COLOR4_TEXTURECOORDS2;
+
+    /** @inheritDoc */
+    public beforeRender(): void {
+        if (this._mipLevel[0] != this.mipLevel) {
+            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!);
+    }
+
+    /** @inheritDoc */
+    public render(vertexBuffer: IVertexBuffer, indexBuffer: IIndexBuffer): void {
+        this._pipeline.render(vertexBuffer, indexBuffer);
+    }
+
+    /** @inheritDoc */
+    public dispose(): void {
+        this._pipeline.dispose();
+        this._projectionViewBuffer.dispose();
+        this._modelBuffer.dispose();
+        this._fragmentDataBuffer.dispose();
+    }
+}

package/src/api/material/MaterialFactory.ts

@@ -0,0 +1,27 @@
+import {InspectTextureMipsMaterial} from "./InspectTextureMipsMaterial.ts";
+import type { IFramework } from "../IFramework.ts";
+import type { IMaterialFactory } from "./IMaterialFactory.ts";
+import {UnlitMaterial, UnlitMaterialDescriptor} from "./UnlitMaterial.ts";
+
+/**
+ * The material factory.
+ */
+export class MaterialFactory implements IMaterialFactory {
+
+    /**
+     * The constructor.
+     * @param _framework The framework.
+     */
+    public constructor(private readonly _framework: IFramework) {
+    }
+
+    /** @inheritDoc */
+    public createInspectTextureMipsMaterial(): InspectTextureMipsMaterial {
+        return new InspectTextureMipsMaterial(this._framework);
+    }
+
+    /** @inheritDoc */
+    public createUnlitMaterial(descriptor? : UnlitMaterialDescriptor): UnlitMaterial {
+        return new UnlitMaterial(this._framework, descriptor );
+    }
+}

package/src/api/material/UnlitMaterial.ts

@@ -0,0 +1,143 @@
+
+import type { IMesh } from "../meshes/IMesh.ts";
+import type { ITexture2D } from "../rendering/texture/ITexture2D.ts";
+import type { ISampler } from "../rendering/sampler/ISampler.ts";
+import {mat4} from "gl-matrix";
+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 { IUnlitRenderPipeline } from "../rendering/render-pipelines/IUnlitRenderPipeline.ts";
+import type { IPrimitiveState } from "../rendering/primitive/IPrimitiveState.ts";
+
+/** The additional material config options */
+export class UnlitMaterialDescriptor {
+
+    /** The primitive state. */
+    public primitiveState?: IPrimitiveState;
+
+    /** The projection view buffer to use */
+    public projectionViewBuffer?: IUniformBuffer;
+}
+
+
+/**
+ * Unlit material.
+ */
+export class UnlitMaterial {
+
+    private readonly _framework: IFramework;
+    private _color = Color.white();
+    private _materialData = [1,1,1,1];
+    private _pipeline: IUnlitRenderPipeline;
+    private _projectionViewBuffer: IUniformBuffer;
+    /** False when the projection view buffer came from the descriptor. The caller owns that one. */
+    private readonly _ownsProjectionViewBuffer: boolean;
+    private _materialBuffer: IUniformBuffer;
+    private _modelBuffer: IUniformBuffer;
+    private _previousModelMatrix = mat4.create();
+
+    /**
+     * The constructor.
+     * @param framework The framework.
+     * @param config The optional material descriptor. A projection view buffer passed here is shared and is not disposed by this material.
+     */
+    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._materialBuffer = framework.bufferFactory.createUniformBuffer(this._materialData, usage);
+        this._pipeline = framework.renderPipelineFactory.createUnlitRenderPipeline(
+            this._projectionViewBuffer,
+            this._modelBuffer,
+            this._materialBuffer,
+            config?.primitiveState
+        );
+    }
+
+    /**
+     * The diffuse color.
+     */
+    public diffuseColor: Color = Color.white();
+
+    /**
+     * The texture to inspect.
+     */
+    public get diffuseTexture(): ITexture2D {
+        return this._pipeline.diffuseTexture;
+    }
+
+    /**
+     * The texture to inspect.
+     */
+    public set diffuseTexture(value: ITexture2D) {
+        this._pipeline.diffuseTexture = value;
+    }
+
+    /**
+     * The texture sampler.
+     */
+    public get diffuseTextureSampler(): ISampler | undefined {
+        return this._pipeline.diffuseTextureSampler;
+    }
+
+    /**
+     * The texture sampler.
+     */
+    public set diffuseTextureSampler(value: ISampler | undefined) {
+        this._pipeline.diffuseTextureSampler = value;
+    }
+
+    /**
+     * The model matrix.
+     */
+    public modelMatrix: mat4 = mat4.create();
+
+    /**
+     * The geometry format.
+     */
+    public readonly geometryFormat = GeometryFormat.POS3_COLOR4_TEXTURECOORDS2;
+
+    /** @inheritDoc */
+    public beforeRender(): void {
+        if (!this._color.equals(this.diffuseColor)) {
+            this._color.set(this.diffuseColor);
+            this._materialData[0] = this._color.r;
+            this._materialData[1] = this._color.g;
+            this._materialData[2] = this._color.b;
+            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!);
+    }
+
+    /** @inheritDoc */
+    public render(vertexBuffer: IVertexBuffer, indexBuffer: IIndexBuffer): void {
+        this._pipeline.render(vertexBuffer, indexBuffer);
+    }
+
+    /** @inheritDoc */
+    public dispose(): void {
+        this._pipeline.dispose();
+        if (this._ownsProjectionViewBuffer) {
+            this._projectionViewBuffer.dispose();
+        }
+        this._modelBuffer.dispose();
+        this._materialBuffer.dispose();
+    }
+}

package/src/api/material/_export.ts

@@ -0,0 +1,5 @@
+export * from "./IMaterial.ts"
+export * from "./IMaterialFactory.ts"
+export * from "./InspectTextureMipsMaterial.ts"
+export * from "./MaterialFactory.ts"
+export * from "./UnlitMaterial.ts"

package/src/api/meshes/IMesh.ts

@@ -0,0 +1,20 @@
+import type { IVertexBuffer } from "../rendering/buffers/IVertexBuffer.ts";
+import type { IDisposable } from "../core/IDisposable.ts";
+import type { IIndexBuffer } from "../rendering/buffers/IIndexBuffer.ts";
+
+/**
+ * The mesh interface.
+ */
+export interface IMesh extends IDisposable {
+
+    /**
+     * The positions buffer.
+     */
+    readonly vertexBuffer?: IVertexBuffer;
+
+    /**
+     * The indices buffer.
+     */
+    readonly indexBuffer?: IIndexBuffer;
+
+}

package/src/api/meshes/IMeshFactory.ts

@@ -0,0 +1,28 @@
+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";
+
+/**
+ * The mesh factory.
+ */
+export interface IMeshFactory {
+
+    /**
+     * Creates a mesh.
+     * @param geometry - The geometry.
+     * @param geometryFormat - The geometry format.
+     * @returns The mesh.
+     */
+    create(geometry: IGeometry, geometryFormat: GeometryFormat): IMesh;
+
+    /**
+     * Creates the quad mesh.
+     * @param isUpdatable - Should mesh be updated after creation.
+     * @param scale - The scale factor for geometry. If null it is set to (1,1).
+     * @returns The quad mesh.
+     */
+    createQuadMesh(isUpdatable: boolean, scale?: vec2): QuadMesh;
+}
+