ris-framework 0.1.0-dev.4

package/src/core/rendering/primitive/enums.ts

@@ -0,0 +1,68 @@
+/**
+ * The culling mode.
+ */
+export enum CullMode
+{
+    /**
+    * The culling is disabled. Both front and back faces will be rendered.
+    */
+    NONE,
+
+    /**
+    * The back faces will be culled. Only front faces will be rendered.
+    */
+    BACK,
+
+    /**
+    * The front faces will be culled. Only back faces will be rendered.
+    */
+    FRONT
+}
+
+/**
+* The front face winding order.
+*/
+export enum FrontFace
+{
+    /**
+    * The clockwise winding order.
+    */
+    CW,
+
+    /**
+    * The counter-clockwise winding order.
+    */
+    CCW,
+}
+
+
+/**
+* The primitive topology.
+*/
+export enum PrimitiveTopology
+{
+    /**
+    * Each consecutive pair of two vertices defines a line primitive.
+    */
+    LINE_LIST,
+
+    /**
+    * Each vertex after the first defines a line primitive between it and the previous vertex.
+    */
+    LINE_STRIP,
+
+    /**
+    * Each vertex defines a point primitive.
+    */
+    POINT_LIST,
+
+    /**
+    * Each consecutive triplet of three vertices defines a triangle primitive.
+    */
+    TRIANGLE_LIST,
+
+    /**
+    * Each vertex after the first two defines a triangle primitive between it and the previous two vertices.
+    */
+    TRIANGLE_STRIP,
+}

package/src/core/rendering/render-pass/render-pass-interface.ts

@@ -0,0 +1,17 @@
+import type {IDisposable} from "ris-framework-api";
+
+/**
+ * Defines the interface for a render pass, which encapsulates the operations and state management required to execute a rendering sequence.
+ */
+export interface IRenderPass extends IDisposable {
+
+    /**
+     * Begins the render pass, setting up necessary state and resources for rendering. 
+     */
+    beginPass(): void;
+
+    /**
+     * Ends the render pass, finalizing any rendering operations and cleaning up resources as needed.
+     */
+    endPass(): void;    
+}

package/src/core/rendering/sampler/sampler-descriptor.ts

@@ -0,0 +1,33 @@
+import {MipMapSamplerFilter, SamplerAddressMode, SamplerFilter} from "ris-framework-api";
+
+export class SamplerDescriptor {
+    /**
+     * The minification filter.
+     */
+    public minFilter: SamplerFilter = SamplerFilter.NEAREST;
+
+    /**
+     * The magnification filter.
+     */
+    public magFilter: SamplerFilter = SamplerFilter.NEAREST;
+
+    /**
+     * The mipmap filter.
+     */
+    public mipMapFilter: MipMapSamplerFilter = MipMapSamplerFilter.NONE;
+
+    /**
+     * The address mode for the U coordinate.
+     */
+    public addressModeU: SamplerAddressMode = SamplerAddressMode.CLAMP_TO_EDGE;
+
+    /**
+     * The address mode for the V coordinate.
+     */
+    public addressModeV: SamplerAddressMode = SamplerAddressMode.CLAMP_TO_EDGE;
+
+    /**
+     * The address mode for the W coordinate.
+     */
+    public addressModeW: SamplerAddressMode = SamplerAddressMode.CLAMP_TO_EDGE;
+}

package/src/core/rendering/texture/texture.ts

@@ -0,0 +1,146 @@
+import {
+    type ITexture2D, type ITextureView,
+    State,
+    type TextureDescriptor,
+    type TextureFormat,
+    TextureUsage,
+    TextureViewDescriptor
+} from "ris-framework-api";
+import {vec2} from "gl-matrix";
+
+/**
+ * The ATexture2D class is an abstract base class that implements the ITexture2D interface. It provides common properties and a constructor for initializing a 2D texture, but it does not implement the actual texture creation and management logic, which must be provided by subclasses that extend this base class.
+ */
+export abstract class ATexture2D implements ITexture2D {
+
+    private static _nextId: number = 1;
+
+    protected _handle: any;
+    protected _state: State = State.CREATED;
+    protected _size = 0;
+    protected _generateMipMaps: boolean = false;
+    protected _mipLevels: number;
+    protected _data?: Uint8Array[];
+    protected _blockSize: vec2;
+
+    protected _disposedListeners: ((tex: ITexture2D) => void)[] = [];
+
+    /**
+     * The constructor for the ATexture2D class.
+     * @param descriptor - The texture descriptor.
+     */
+    protected constructor(
+        descriptor: TextureDescriptor,
+    ) {
+
+        if (!descriptor.textureFormat) {
+            throw new Error("Texture format is required.");
+        }
+
+        this.id = ATexture2D.generateId();
+        this.textureFormat = descriptor.textureFormat;
+        this.textureUsage = descriptor.textureUsage;
+        this.textureViewFormat = descriptor.textureFormat;
+        this.width = descriptor.width;
+        this.height = descriptor.height;
+        this._data = descriptor.data;
+        this._mipLevels = this._data?.length ?? 1;
+        this._generateMipMaps = descriptor.generateMipmaps && this._mipLevels <= 1;
+        this.label = descriptor.label;
+        this._blockSize = descriptor.blockSize ?? vec2.fromValues(1, 1);
+
+        if (this.width == 0 || this.height == 0) {
+            throw new Error("Width or height cannot be zero.");
+        }
+
+        // @ts-ignore
+        this.defaultTextureView = null;
+
+    }
+
+    /** @inheritDoc */
+    public addOnDisposedListener(event: (sender: ITexture2D) => void): void {
+        this._disposedListeners.push(event);
+    }
+
+    /** @inheritDoc */
+    public removeOnDisposedListener(event: (sender: ITexture2D) => void): void {
+
+        let index = this._disposedListeners.indexOf(event);
+        if (index > -1) {
+            this._disposedListeners = this._disposedListeners.splice(index, 1);
+        }
+    }
+
+    /** @inheritDoc */
+    public readonly id: number;
+
+    /** @inheritDoc */
+    public readonly defaultTextureView: ITextureView;
+
+    /** @inheritDoc */
+    public readonly textureUsage: TextureUsage;
+
+    /** @inheritDoc */
+    public readonly textureViewFormat: TextureFormat;
+
+    /** @inheritDoc */
+    public readonly textureFormat: TextureFormat;
+
+    /** @inheritDoc */
+    public get textureState(): State {
+        return this._state;
+    }
+
+    /** @inheritDoc */
+    public get handle(): any {
+        return this._handle;
+    }
+
+    /**
+     * Generates a unique ID for each texture instance.
+     * @returns A unique ID for the texture instance.
+     */
+    private static generateId(): number {
+        return ATexture2D._nextId++;
+    }
+
+    /**
+     * Initializes the texture.
+     */
+    abstract initialize(): void;
+
+    /** @inheritdoc */
+    public get state(): State {
+        return this._state;
+    }
+
+    /** @inheritdoc */
+    public readonly width: number;
+
+    /** @inheritdoc */
+    public readonly height: number;
+
+    /** @inheritDoc */
+    public get size(): number {
+        return this._size;
+    }
+
+    /** @inheritDoc */
+    public get mipLevels(): number {
+        return this._mipLevels;
+    }
+
+    /** @inheritdoc */
+    public readonly label: string | null;
+
+    /**
+     * Creates a texture view for the texture.
+     * @param descriptor The descriptor for the texture view.
+     * @returns The created texture view, which can be used for sampling the texture in shaders.
+     */
+    public abstract createView(descriptor?: TextureViewDescriptor): ITextureView;
+
+    /** @inheritDoc */
+    public abstract dispose(): void;
+}

package/src/core/rendering/vertex-attribute.ts

@@ -0,0 +1,20 @@
+import {VertexFormat} from "../../VertexFormat.ts";
+
+export  class VertexAttribute  {
+   
+    /**
+     * The format of the vertex attribute.
+     */
+    format: VertexFormat = VertexFormat.FLOAT_32;
+
+    /**
+     * The offset, in bytes, of the vertex attribute from the start of the vertex.
+     */
+    offset: number = 0;
+
+    /**
+     * The shader location of the vertex attribute.
+     *  This is used to bind the vertex attribute to the correct location in the shader.
+     */
+    shaderLocation: number = 0;
+}

package/src/core/rendering/vertex-buffer-layout.ts

@@ -0,0 +1,84 @@
+import { VertexStepMode } from "ris-framework-api";
+import type {  VertexAttribute } from "./vertex-attribute";
+import {VertexFormat} from "../../VertexFormat.ts";
+
+/**
+ * Describes the layout of a vertex buffer, including the stride, step mode, and attributes.
+ */
+export class VertexBufferLayout {
+    /**
+     * Stride in bytes (size of one vertex)
+     */
+    arrayStride: number;
+
+    /**
+     * How to step through the buffer
+     */
+    stepMode: VertexStepMode;
+
+    /**
+     * Vertex attributes
+     */
+    attributes: VertexAttribute[] = [];
+
+    constructor(
+        arrayStride: number,
+        stepMode: VertexStepMode,
+        attributes: VertexAttribute[]
+    ) {
+        this.arrayStride = arrayStride;
+        this.stepMode = stepMode;
+        this.attributes = attributes;
+    }
+
+    // =========================
+    // Static helpers
+    // =========================
+
+    static createFloat3Float2Layout(): VertexBufferLayout {
+        const floatSize = 4;
+
+        return new VertexBufferLayout(
+            (3 + 2) * floatSize,
+            VertexStepMode.VERTEX,
+            [
+                {
+                    format: VertexFormat.FLOAT_32X3,
+                    offset: 0,
+                    shaderLocation: 0,
+                },
+                {
+                    format: VertexFormat.FLOAT_32X2,
+                    offset: 3 * floatSize,
+                    shaderLocation: 1,
+                },
+            ]
+        );
+    }
+
+    static createFloat3Float4Float2Layout(): VertexBufferLayout {
+        const floatSize = 4;
+
+        return new VertexBufferLayout(
+            (3 + 4 + 2) * floatSize,
+            VertexStepMode.VERTEX,
+            [
+                {
+                    format: VertexFormat.FLOAT_32X3,
+                    offset: 0,
+                    shaderLocation: 0,
+                },
+                {
+                    format: VertexFormat.FLOAT_32X4,
+                    offset: 3 * floatSize,
+                    shaderLocation: 1,
+                },
+                {
+                    format: VertexFormat.FLOAT_32X2,
+                    offset: (3 + 4) * floatSize,
+                    shaderLocation: 2,
+                },
+            ]
+        );
+    }
+}

package/src/core/shader/shader-loader.ts

@@ -0,0 +1,27 @@
+import {RenderingBackend, type ShaderStage} from "ris-framework-api";
+
+export class ShaderLoader {
+
+    /**
+     * Loads the shader source code from the given shader file path for the specified rendering backend and shader stages.
+     * @param shaderFilePath The shader file path.
+     * @param renderingBackend The rendering backend.
+     * @param stages The shader stages. For WebGL, only one shader stage is allowed. For WebGPU, multiple shader stages are allowed.
+     * @returns The shader source code.
+     */
+    public async load(shaderFilePath: string, renderingBackend: RenderingBackend, stages: ShaderStage[]): Promise<string> {
+
+        if(stages.length === 0) {
+            throw new Error("At least one shader stage must be specified.");
+        }
+
+        if(renderingBackend === RenderingBackend.WEB_GL) {
+            if(stages.length > 1) {
+                throw new Error("WebGL does not support multiple shader stages in a single file.");
+            }
+        }
+
+        const shaderSource = await fetch(shaderFilePath);
+        return await shaderSource.text();
+    }
+}

package/src/core/shader/shader-module-interface.ts

@@ -0,0 +1 @@
+

package/src/core/sprite-batch/SpriteBatch.ts

@@ -0,0 +1,216 @@
+import {type mat4, vec2, vec3} from "gl-matrix";
+import {SpriteBatchDrawable} from "./SpriteBatchDrawable";
+import {
+    type IFramework,
+    type ITexture2D,
+    type ISpriteBatch,
+    type IOrthographicCamera,
+    type IUniformBuffer,
+    Color, Rect, type ISampler
+} from "ris-framework-api";
+
+/**
+ * The implementation of sprite batch.
+ */
+export class SpriteBatch implements ISpriteBatch {
+    static MAX_BATCH_SIZE = 1000;
+    static ZERO_VECTOR = vec2.fromValues(0, 0);
+    static CENTER_VECTOR = vec2.fromValues(0.5, 0.5);
+
+    private readonly _tempPosition = vec3.create();
+    private readonly _tempSize = vec2.create();
+    private readonly _tempSourceRect = new Rect(0, 0, 0, 0);
+
+    /**
+     * The drawables where first key is texture id, second key is sampler id and value is drawable.
+     */
+    private readonly _spriteBatchDrawables: Map<number, Map<number, SpriteBatchDrawable>> = new Map();
+    private _currentTexture: ITexture2D | null = null;
+    private _currentSampler: ISampler | null = null;
+    private _currentSpriteBatchDrawable: SpriteBatchDrawable = null!;
+    private _defaultCamera: IOrthographicCamera = null!;
+
+    // It is set on Begin and reset back to the default camera on End.
+    private _currentProjectionViewBuffer: IUniformBuffer = null!;
+
+    /**
+     * The default texture to use for "texture less" draw calls.
+     * It is white so that color multiplication works correctly.
+     */
+    private _defaultWhiteTexture: ITexture2D = null!;
+
+    /**
+     * The constructor.
+     * @param _framework The framework.
+     */
+    public constructor(private readonly _framework: IFramework) {
+    }
+
+    private _tryGetDrawable(texture: ITexture2D, sampler: ISampler) {
+        const samplerKeyValue = this._spriteBatchDrawables.get(texture.id);
+        if (!samplerKeyValue) {
+            return null;
+        }
+
+        return samplerKeyValue.get(sampler.id);
+    }
+
+    private _setDrawable(texture: ITexture2D, sampler: ISampler, drawable: SpriteBatchDrawable): void {
+        let samplerKeyValue = this._spriteBatchDrawables.get(texture.id);
+        if (!samplerKeyValue) {
+            samplerKeyValue = new Map();
+            samplerKeyValue.set(sampler.id, drawable);
+        }
+
+        this._spriteBatchDrawables.set(texture.id, samplerKeyValue);
+    }
+
+    private _validateTexture(texture?: ITexture2D) {
+        if (!texture) {
+            throw new Error(`Texture cannot be empty.`);
+        }
+    }
+
+    private _checkIfNewDrawableShouldBeCreated(texture: ITexture2D, sampler: ISampler): void {
+        // If there was a texture change, we need to end the current sprite batch drawable and start a new one.
+        if (texture != this._currentTexture || sampler != this._currentSampler) {
+            // End will draw. This draws with a previously set sprite batch drawable.
+            this.end();
+
+            this._currentTexture = texture;
+
+            // Create a new sprite batch drawable if needed.
+            let spriteBatchDrawable = this._tryGetDrawable(texture, sampler);
+
+            if (!spriteBatchDrawable) {
+                spriteBatchDrawable = new SpriteBatchDrawable(
+                    this._framework, texture, sampler,
+                    this._currentProjectionViewBuffer,
+                    SpriteBatch.MAX_BATCH_SIZE);
+                spriteBatchDrawable.initialize();
+
+                this._setDrawable(texture, sampler, spriteBatchDrawable);
+
+                // When texture is disposed destroy this drawable.
+                const disposeListener = () => {
+                    spriteBatchDrawable?.dispose();
+                    texture.removeOnDisposedListener(disposeListener);
+                };
+                texture.addOnDisposedListener(disposeListener);
+            }
+
+            // Assign current.
+            this._currentSpriteBatchDrawable = spriteBatchDrawable;
+        }
+    }
+
+    /** @inheritDoc */
+    public initialize() {
+        this._defaultCamera = this._framework.cameraFactory.createDefaultOrthographicCamera();
+        this._currentProjectionViewBuffer = this._defaultCamera.projectionViewBuffer;
+        this._defaultWhiteTexture = this._framework.textureFactory.createEmpty(1, 1, Color.white());
+
+        this._framework.renderer.addOnResizedListener((_, size) => {
+            this._defaultCamera.right = size[0]
+            this._defaultCamera.bottom = size[1];
+            this._defaultCamera.updateBuffers();
+        });
+    }
+
+    /** @inheritDoc */
+    public begin(projectionViewMatrix: mat4 | undefined = undefined,
+                 sampler: ISampler | undefined = undefined) {
+        this.end();
+
+        this._currentSampler = sampler ?? this._framework.graphicsDevice.defaultTextureSampler;
+
+        if (projectionViewMatrix) {
+            this._currentProjectionViewBuffer.update(projectionViewMatrix);
+        }
+
+        for (const texSamplerDrawableKvp of this._spriteBatchDrawables) {
+            for (const samplerDrawableKvp of texSamplerDrawableKvp[1]) {
+                samplerDrawableKvp[1].reset();
+            }
+        }
+
+        // Clear current texture.
+        this._currentTexture = null;
+    }
+
+
+    /** @inheritDoc */
+
+    public drawRect(drawRect: Rect, color: Color, __: number = 0, _: vec2 | undefined = undefined) {
+        this._checkIfNewDrawableShouldBeCreated(this._defaultWhiteTexture, this._currentSampler!);
+
+        this._tempPosition[0] = drawRect.x;
+        this._tempPosition[1] = drawRect.y;
+        this._tempPosition[2] = 0;
+        this._tempSize[0] = drawRect.width;
+        this._tempSize[1] = drawRect.height;
+
+        this._currentSpriteBatchDrawable.writeSprite(
+            this._tempPosition, this._tempSize, color
+        );
+    }
+
+    /** @inheritDoc */
+    public draw(texture: ITexture2D,
+                drawRect: Rect,
+                color: Color,
+                sourceRect?: Rect,
+                // @ts-ignore
+                rotation: number = 0,
+                // @ts-ignore
+                rotationOrigin?: vec2,
+                layerDepth: number = 0): void {
+
+        this._validateTexture(texture);
+        this._checkIfNewDrawableShouldBeCreated(texture, this._currentSampler!);
+
+        // Safe to assign current texture.
+        this._currentTexture = texture;
+
+        if (!sourceRect) {
+            sourceRect = this._tempSourceRect;
+            sourceRect.x = 0;
+            sourceRect.y = 0;
+            sourceRect.width = texture.width;
+            sourceRect.height = texture.height;
+        }
+
+        const u0 = sourceRect.x / texture.width;
+        const v0 = sourceRect.y / texture.height;
+        const u1 = (sourceRect.x + sourceRect.width) / texture.width;
+        const v1 = (sourceRect.y + sourceRect.height) / texture.height;
+
+        this._tempPosition[0] = drawRect.x;
+        this._tempPosition[1] = drawRect.y;
+        this._tempPosition[2] = layerDepth;
+        this._tempSize[0] = drawRect.width;
+        this._tempSize[1] = drawRect.height;
+
+        this._currentSpriteBatchDrawable.writeSprite(
+            this._tempPosition, this._tempSize,
+            color,
+            u0, v0, u1, v1
+        );
+    }
+
+    /** @inheritDoc */
+    public end(): void {
+        if (this._currentTexture != null) {
+            this._currentSpriteBatchDrawable.draw();
+        }
+    }
+
+    /** @inheritDoc */
+    public frameEnd(): void {
+        for (const texSamplerDrawableKvp of this._spriteBatchDrawables) {
+            for (const samplerDrawableKvp of texSamplerDrawableKvp[1]) {
+                samplerDrawableKvp[1].frameEnd();
+            }
+        }
+    }
+}