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

package/src/api/meshes/Mesh.ts

@@ -0,0 +1,256 @@
+/**
+ * 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 {BufferUsage} from "../rendering/buffers/BufferUsage.ts";
+import type { IGeometry } from "../geometry/IGeometry.ts";
+import {GeometryFormat} from "../geometry/GeometryFormat.ts";
+import {MeshParameters} from "./MeshParameters.ts";
+import {GeometryUtilities} from "../utilities/GeometryUtilities.ts";
+
+/**
+ * The mesh.
+ */
+export class Mesh implements IMesh {
+
+    protected readonly _framework: IFramework;
+    protected _bufferUsage = BufferUsage.VERTEX;
+    protected _state = State.CREATED;
+    protected _vertexData?: number[];
+    protected _positions?: number[];
+    protected _indices?: number[];
+    protected _colors?: number[];
+    protected _textureCoords?: number[];
+    protected _normals?: number[];
+    protected _vertexBuffer?: IVertexBuffer;
+    protected _indexBuffer?: IIndexBuffer;
+
+    /**
+     * The constructor.
+     * @param framework The framework.
+     */
+    public constructor(framework: IFramework) {
+        this._framework = framework;
+    }
+
+    /**
+     * The state of a mesh.
+     */
+    public get state(): State {
+        return this._state;
+    }
+
+    /**
+     * The positions of a mesh.
+     */
+    public get positions(): number[] | undefined {
+        return this._positions;
+    }
+
+    /**
+     * The indices of a mesh.
+     */
+    public get indices(): number[] | undefined {
+        return this._indices;
+    }
+
+    /**
+     * The colors of a mesh.
+     */
+    public get colors(): number[] | undefined {
+        return this._colors;
+    }
+
+    /**
+     * UV texture coordinates of a mesh.
+     */
+    public get textureCoords(): number[] | undefined {
+        return this._textureCoords;
+    }
+
+    /**
+     * The normals of a mesh.
+     */
+    public get normals(): number[] | undefined {
+        return this._normals;
+    }
+
+    /**
+     * The vertex buffer.
+     */
+    public get vertexBuffer(): IVertexBuffer | undefined {
+        return this._vertexBuffer;
+    }
+
+    /**
+     * The index buffer.
+     */
+    public get indexBuffer(): IIndexBuffer | undefined {
+        return this._indexBuffer ;
+    }
+
+    /**
+     * Initializes the mesh.
+     */
+    public initialize(): void {
+        this.applyChanges();
+    }
+
+    private _fillColors(index: {vertexDataIndex: number, colorIndex: number}, colors: number[]): void {
+
+        if(!this._vertexData) {
+            throw new Error("Vertex data is not initialized");
+        }
+
+        let v = index.vertexDataIndex;
+        let c = 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 {
+            // Just prefill with white color
+            this._vertexData[v++] =1;
+            this._vertexData[v++] = 1;
+            this._vertexData[v++] = 1;
+            this._vertexData[v++] = 1;
+        }
+
+        index.vertexDataIndex = v;
+        index.colorIndex = c;
+    }
+
+    /**
+     * Apply changes to the mesh.
+     */
+    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`);
+        }
+
+        // - POSITIONS
+        const vertexCount = this._positions.length / 3;
+
+        // 3 for vertex, 4 for color and 2 for uvs.
+        const stride = (3 + 4 + 2) * Float32Array.BYTES_PER_ELEMENT;
+        this._vertexData = new Array((3 + 4 + 2) * vertexCount);
+
+        let vertexIndex = 0;
+        let positionsIndex = 0;
+        let colorIndex = 0;
+        let normalIndex = 0;
+        let uvsIndex = 0;
+
+        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)
+            {
+                const index = {vertexDataIndex: vertexIndex, colorIndex: colorIndex};
+                this._fillColors(index, this._colors);
+                vertexIndex = index.vertexDataIndex;
+                colorIndex = index.colorIndex;
+            }
+
+            if (this._textureCoords)
+            {
+                // Uvs.
+                this._vertexData[vertexIndex++] = this._textureCoords[uvsIndex++];
+                this._vertexData[vertexIndex++] = this._textureCoords[uvsIndex++];
+            }
+
+            if (this._normals)
+            {
+                this._vertexData[vertexIndex++] = this._normals[normalIndex++];
+                this._vertexData[vertexIndex++] = this._normals[normalIndex++];
+                this._vertexData[vertexIndex++] = this._normals[normalIndex++];
+            }
+        }
+
+        // Vertices
+        this._vertexBuffer?.dispose();
+        this._vertexBuffer = this._framework.bufferFactory.createVertexBuffer(
+                this._vertexData, stride, this._bufferUsage);
+
+        // Indices
+        this._indexBuffer?.dispose();
+        if (this._indices && this._indices.length > 0)
+        {
+            this._indexBuffer= this._framework.bufferFactory.createIndexBuffer(
+                this._indices);
+        }
+    }
+
+    /**
+     * 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.
+     */
+    public setGeometry(geometry: IGeometry, format: GeometryFormat): void {
+        if (geometry.vertexCount == 0)
+        {
+            const message =
+            "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);
+        }
+
+        const interleavedData = geometry.toInterleaved(format);
+        const stride = GeometryUtilities.stride(format);
+
+        // Vertices
+        this._vertexBuffer?.dispose();
+        this._vertexBuffer = this._framework.bufferFactory.createVertexBuffer(
+            interleavedData,
+            stride,
+            this._bufferUsage);
+
+        // Indices
+        this._indexBuffer?.dispose();
+        if (geometry.indices)
+        {
+            this._indexBuffer = this._framework.bufferFactory.createIndexBuffer(geometry.indices);
+        }
+    }
+
+    /**
+     * Sets the mesh from parameters.
+     * @param meshParameters - The parameters.
+     */
+    public setMesh(meshParameters: MeshParameters): void {
+        this._positions = meshParameters.positions;
+        this._indices = meshParameters.indices;
+        this._textureCoords = meshParameters.textureCoords;
+        this._colors = meshParameters.colors;
+        this.applyChanges();
+    }
+
+    /**
+     * Dispose of the mesh.
+     */
+    public dispose(): void {
+        this._vertexBuffer?.dispose();
+        this._vertexBuffer = undefined;
+        this._indexBuffer?.dispose();
+        this._indexBuffer = undefined;
+    }
+}

package/src/api/meshes/MeshFactory.ts

@@ -0,0 +1,36 @@
+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";
+
+/**
+ * The implementation of the mesh factory interface.
+ */
+export class MeshFactory implements IMeshFactory {
+
+    /**
+     * The constructor.
+     * @param _framework The framework.
+     */
+    public constructor(private readonly _framework: IFramework) {
+    }
+
+    /** @inheritDoc */
+    public create(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);
+        quadMesh.initialize();
+        return quadMesh;
+    }
+
+}

package/src/api/meshes/MeshParameters.ts

@@ -0,0 +1,25 @@
+/**
+ * Parameters for a mesh.
+ */
+export class MeshParameters {
+
+    /**
+     * The positions.
+     */
+    public positions: number[] = [];
+
+    /**
+     * The indices.
+     */
+    public indices?: number[];
+
+    /**
+     * The uv texture coordinates.
+     */
+    public textureCoords?: number[];
+
+    /**
+     * The colors of a mesh.
+     */
+    public colors?: number[];
+}

package/src/api/meshes/QuadMesh.ts

@@ -0,0 +1,104 @@
+import {Mesh} from "./Mesh.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";
+
+/**
+ * The mesh of a quad.
+ */
+export class QuadMesh extends Mesh {
+
+    private readonly ELEMENTS_IN_VERTEX = 9;
+    private readonly TEX_COORD_POS_S = 7;
+    private readonly TEX_COORD_POS_T = 8;
+
+    /**
+     * The constructor.
+     * @param framework The framework.
+     * @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);
+        if(_isUpdatable) {
+            this._bufferUsage = BufferUsage.VERTEX | BufferUsage.COPY_DST;
+        }
+
+        scale = scale || vec2.fromValues(1,1);
+
+        this._positions = [
+            // V0 - bottom left
+            -0.5 * scale[0], -0.5 * scale[1], 0.0,
+            // V1 - top left
+            -0.5 * scale[0], 0.5 * scale[1], 0.0,
+            // V2 - bottom right
+            0.5 * scale[0], -0.5 * scale[1], 0.0,
+            // V3 - top right
+            0.5 * scale[0], 0.5 * scale[1], 0.0
+        ];
+
+        this._colors = [
+            1,1,1,1,
+            1,1,1,1,
+            1,1,1,1,
+            1,1,1,1
+        ];
+
+        this._textureCoords = [
+
+            // V0 - bottom left
+            0, 1,
+            // V1 - top left
+            0, 0,
+            // V2 - bottom right
+            1, 1,
+            // V3 - top right
+            1, 0
+        ];
+
+        this._indices = [
+            0, 2, 3, // t1
+            3, 1, 0  // t2
+        ]
+    }
+
+    /** @inheritDoc*/
+    public initialize(): void {
+        // This will initialize buffers with data.
+        super.applyChanges();
+    }
+
+    /** @inheritDoc*/
+    public applyChanges(): void {
+        if (!this._isUpdatable)
+        {
+            throw new Error("This mesh is not updatable.");
+        }
+
+        this._vertexBuffer!.update(this._vertexData!);
+    }
+
+    /**
+     * Update the texture coordinates of quad mesh.
+     * ApplyChanges should be called after updating this mesh.
+     * @param coordBounds - The texture coordinates rectangle.
+     * Rectangle x and y define the top left position of texture coordinates.
+     * Rectangle x + width and y + height define the bottom right position of texture coordinates.
+     */
+    public updateTextureCoords(coordBounds: Rect): void {
+
+        // Order is bottom left, top left, bottom right, top right
+        this._vertexData![this.TEX_COORD_POS_S] = coordBounds.x;
+        this._vertexData![this.TEX_COORD_POS_T] = coordBounds.y + coordBounds.height;
+
+        this._vertexData![this.TEX_COORD_POS_S + this.ELEMENTS_IN_VERTEX] = coordBounds.x;
+        this._vertexData![this.TEX_COORD_POS_T + this.ELEMENTS_IN_VERTEX] = coordBounds.y;
+
+        this._vertexData![this.TEX_COORD_POS_S + this.ELEMENTS_IN_VERTEX * 2] = coordBounds.x + coordBounds.width;
+        this._vertexData![this.TEX_COORD_POS_T + this.ELEMENTS_IN_VERTEX * 2] = coordBounds.y + coordBounds.height;
+
+        this._vertexData![this.TEX_COORD_POS_S + this.ELEMENTS_IN_VERTEX * 3] = coordBounds.x + coordBounds.width;
+        this._vertexData![this.TEX_COORD_POS_T + this.ELEMENTS_IN_VERTEX * 3] = coordBounds.y;
+    }
+}

package/src/api/meshes/_export.ts

@@ -0,0 +1,6 @@
+export * from "./IMeshFactory.ts";
+export * from "./IMesh.ts"
+export * from "./Mesh.ts"
+export * from "./QuadMesh.ts";
+export * from "./MeshParameters.ts"
+export * from "./MeshFactory.ts";

package/src/api/rendering/IGPUInfo.ts

@@ -0,0 +1,42 @@
+import {RenderingBackend} from "./RenderingBackend.ts";
+import {TextureFormat} from "./texture/TextureFormat.ts";
+
+/**
+ * The GPU information. Contains the information about the GPU, such as the name, vendor, etc.
+ */
+export interface IGPUInfo {
+
+    /**
+     * The name of the GPU.
+     */
+    readonly name: string;
+
+    /**
+     * The vendor of the GPU.
+     */
+    readonly vendor: string;
+
+    /**
+     * The version of the GPU API.
+     */
+    readonly apiVersion: string;
+
+    /**
+     * The rendering backend used by the GPU. For example, DirectX 12, Vulkan, OpenGL, etc.
+     */
+    readonly api: RenderingBackend;
+
+    /**
+     * The underlying rendering backend used by the GPU.
+     * This is the actual rendering backend used by the GPU, which may be different from the API.
+     * For example, for WebGPU, the API is WebGPU, but the underlying backend can be DirectX 12, Vulkan, Metal, etc.
+     */
+    readonly underlyingBackend: RenderingBackend;
+
+    /**
+     * Gets the list of supported compressed texture formats by the GPU.
+     * This can be used to determine which compressed texture formats can be used for texture compression, which can improve performance and reduce memory usage.
+     */
+    readonly supportedCompressedTextureFormats: TextureFormat[];
+
+}

package/src/api/rendering/IGraphicsDevice.ts

@@ -0,0 +1,103 @@
+import type { IDisposable } from "../core/IDisposable.ts";
+import type { IGPUInfo } from "./IGPUInfo.ts";
+import type { IGraphicsDeviceFeatures } from "./IGraphicsDeviceFeatures.ts";
+import type { ISampler } from "./sampler/ISampler.ts";
+import type { IBlendState } from "./blending/IBlendState.ts";
+import type { IPrimitiveState } from "./primitive/IPrimitiveState.ts";
+import {RenderPassDescriptor} from "./renderpass/RenderPassDescriptor.ts";
+import type { IRenderPass } from "./renderpass/IRenderPass.ts";
+import {SwapChainDescriptor} from "./swapchain/SwapChainDescriptor.ts";
+import type { ISwapChain } from "./swapchain/ISwapChain.ts";
+import {SamplerDescriptor} from "./sampler/SamplerDescriptor.ts";
+import {PrimitiveStateDescriptor} from "./primitive/PrimitiveStateDescriptor.ts";
+
+/**
+ * The interface for a graphics device.
+ */
+export interface IGraphicsDevice extends IDisposable {
+
+    /**
+     * The info about the GPU.
+     */
+    readonly gpuInfo: IGPUInfo;
+
+    /**
+     * The features of the graphics device.
+     */
+    readonly features: IGraphicsDeviceFeatures;
+
+    /**
+     * Gets the default sampler for the graphics device.
+     */
+    readonly defaultTextureSampler: ISampler;
+
+    /**
+     * Gets the default blend state for the graphics device.
+     * All render pipelines will use this blend state by default.
+     */
+    readonly defaultBlendState: IBlendState;
+
+    /**
+     * Gets the default primitive state for the graphics device.
+     * All render pipelines will use this primitive state by default.
+     */
+    readonly defaultPrimitiveState: IPrimitiveState;
+
+    /**
+     * Initializes the graphics device.
+     */
+    initialize(): void;
+
+    /**
+     * Sets up the debug callback for the graphics device.
+     * This will enable the debug output if it is supported, and route debug messages to the device's debug callback.
+     */
+    setupDebugCallback(): void;
+
+    /**
+     * Called at the end of each frame to perform any necessary cleanup of resources that were used during the frame.
+     */
+    frameEnd(): void;
+
+    /**
+     * Create a sampler object.
+     * @param samplerDescriptor - The sampler descriptor.
+     * @returns The sampler.
+     */
+    createSampler(samplerDescriptor: SamplerDescriptor): ISampler;
+
+    /**
+     * Creates a primitive state for the graphics device.
+     * @param descriptor - The primitive state descriptor.
+     * @returns The created primitive state.
+     */
+    createPrimitiveState(descriptor: PrimitiveStateDescriptor): IPrimitiveState;
+
+    /**
+     * Creates a render pass for the graphics device.
+     * @param descriptor - The descriptor for creating a render pass.
+     * @returns The created  instance.
+     */
+    createRenderPass(descriptor: RenderPassDescriptor): IRenderPass;
+
+    /**
+     * // TODO: fix this for window.
+     * Creates a swap chain for the graphics device.
+     * The swap chain is used to present the rendered image to the screen.
+     * @returns The swap chain instance.
+     */
+    createSwapChain(window: any, swapChainDescription: SwapChainDescriptor): ISwapChain;
+
+    /**
+     * Pushes a debug group with the specified name onto the graphics device's debug stack.
+     * @param groupName - The name of the debug group.
+     */
+    pushDebugGroup(groupName: string): void;
+
+    /**
+     * Pops the current debug group from the graphics device's debug stack,
+     * ending the current debug group and returning to the previous one.
+     */
+    popDebugGroup(): void;
+
+}

package/src/api/rendering/IGraphicsDeviceFeatures.ts

@@ -0,0 +1,32 @@
+/**
+ * Represents the texture compression capabilities of a graphics device.
+ */
+export interface IGraphicsDeviceFeatures {
+
+/**
+ * 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 ETC2 / EAC texture compression (OpenGL/ES and Vulkan standard).
+ */
+  readonly supportsTextureCompressionETC2: boolean;
+
+/**
+ * Supports ASTC (Adaptive Scalable Texture Compression) — LDR and HDR profiles.
+ */
+  readonly supportsTextureCompressionASTC: boolean;
+
+/**
+ * Supports PVRTC (PowerVR Texture Compression) 1 and 2.
+ */
+  readonly supportsTextureCompressionPVRTC: boolean;
+
+}

package/src/api/rendering/IRenderer.ts

@@ -0,0 +1,84 @@
+import type { IGraphicsDevice } from "./IGraphicsDevice.ts";
+import {TextureFormat} from "./texture/TextureFormat.ts";
+import {Color} from "../data/Color.ts";
+import {RenderingBackend} from "./RenderingBackend.ts";
+import {vec2} from "gl-matrix";
+
+
+/**
+ * The interface for a renderer.
+ */
+export interface IRenderer {
+
+    /**
+     * The graphics device used by the renderer.
+     */
+    readonly graphicsDevice: IGraphicsDevice;
+
+    /**
+     * The surface preferred a texture format.
+     */
+    readonly preferredTextureFormat: TextureFormat;
+
+    /**
+     * The preferred depth stencil format.
+     */
+    readonly preferredDepthStencilFormat: TextureFormat;
+
+    /**
+     * The clear color of the renderer.
+     * Framebuffer will be cleared with this color at the beginning of the frame.
+     */
+    clearColor: Color;
+
+    /**
+     * The renderer type.
+     */
+    readonly backend: RenderingBackend;
+
+    /**
+     * The size of the back buffer.
+     * This is the size of the framebuffer that the renderer will render to by default, before rendering to
+     * the swap chain's back buffer.
+     * This can be different from the swap chain's back buffer size and can be used to render at a
+     * different resolution than the screen resolution.
+     * Setting this will have no effect if `backBufferMatchesSwapChain` is set to true.
+     */
+    backBufferSize: vec2;
+
+    /**
+     * The new size of the renderer.
+     */
+    addOnResizedListener(event: (sender: any, e: vec2) => void): void;
+
+    /**
+     * The new size of the renderer.
+     */
+    removeOnResizedListener(event: (sender: any, e: vec2) => void): void;
+    /**
+     * After initialization.
+     */
+    afterInitialize(): void;
+
+    /**
+     * The compute pass. Runs before the rendering pass.
+     */
+    beginComputePass(): void;
+
+    /**
+     * The end of compute pass. Ends run before the rendering pass.
+     */
+    endComputePass(): void;
+
+    /**
+     * Should be called at the beginning of the frame.
+     * Clears the buffer and prepares the renderer for rendering.
+     */
+    beginRenderPass(): void;
+
+    /**
+     * Should be called at the end of the frame.
+     * Ends the rendering and submits the frame to the screen.
+     */
+    endRenderPass(): void;
+}