ris-framework 0.1.0-dev.7 → 0.1.0

package/src/api/camera/OrthographicCamera.ts

@@ -0,0 +1,257 @@
+import type { IOrthographicCamera } from "./IOrthographicCamera.ts";
+import type { IFramework } from "../IFramework.ts";
+import {vec3, mat4} from "gl-matrix";
+import type { IUniformBuffer } from "../rendering/buffers/IUniformBuffer.ts";
+import {BufferUsage} from "../rendering/buffers/BufferUsage.ts";
+import {GameTime} from "../time/GameTime.ts";
+
+/**
+ * The Orthographic Camera.
+ */
+export class OrthographicCamera implements IOrthographicCamera {
+
+    static UP_VECTOR = vec3.fromValues(0, 1, 0);
+
+    private readonly _framework: IFramework;
+
+    /** @ts-ignore */
+    private readonly _zSpaceLength: number;
+
+    private _eye: vec3;
+    private _target: vec3;
+
+    private _left: number;
+    private _right: number;
+    private _top: number;
+    private _bottom: number;
+    private _near: number;
+    private _far: number;
+
+    protected _isDirty = true;
+
+    protected _projectionMatrix = mat4.create();
+    protected _viewMatrix = mat4.create();
+    protected _projectionViewMatrix = mat4.create();
+
+    public readonly position = vec3.create();
+    public readonly target = vec3.create();
+    public readonly direction = vec3.create();
+
+    private _projectionBuffer: IUniformBuffer = null!;
+    private _viewBuffer: IUniformBuffer = null!;
+    private _projectionViewBuffer: IUniformBuffer = null!;
+
+    /**
+     *
+     * @param framework
+     * @param left
+     * @param right
+     * @param top
+     * @param bottom
+     * @param near
+     * @param far
+     */
+    public constructor(
+        framework: IFramework,
+        left: number,
+        right: number,
+        top: number,
+        bottom: number,
+        near: number,
+        far: number
+    ) {
+        this._framework = framework;
+
+        this._left = left;
+        this._right = right;
+        this._top = top;
+        this._bottom = bottom;
+        this._near = near;
+        this._far = far;
+
+        this._eye = vec3.fromValues(0, 0, -1);
+        this._target = vec3.fromValues(0, 0, 0);
+
+        this._zSpaceLength = 2; // For WebGL2 it is 2, WebGPU it is 1.
+
+        this._updateMatrices();
+    }
+
+    /** @inheritDoc */
+    public get left(): number {
+        return this._left;
+    }
+
+    /** @inheritDoc */
+    public set left(value: number) {
+        if (this._left === value)
+            return;
+
+        this._left = value;
+        this._isDirty = true;
+    }
+
+    /** @inheritDoc */
+    public get right(): number {
+        return this._right;
+    }
+
+    /** @inheritDoc */
+    public set right(value: number) {
+        if (this._right === value)
+            return;
+
+        this._right = value;
+        this._isDirty = true;
+    }
+
+    /** @inheritDoc */
+    public get top(): number {
+        return this._top;
+    }
+
+    /** @inheritDoc */
+    public set top(value: number) {
+        if (this._top === value)
+            return;
+
+        this._top = value;
+        this._isDirty = true;
+    }
+
+    /** @inheritDoc */
+    public get bottom(): number {
+        return this._bottom;
+    }
+
+    /** @inheritDoc */
+    public set bottom(value: number) {
+        if (this._bottom === value)
+            return;
+
+        this._bottom = value;
+        this._isDirty = true;
+    }
+
+    /** @inheritDoc */
+    public get nearPlane(): number {
+        return this._near;
+    }
+
+    /** @inheritDoc */
+    public set nearPlane(value: number) {
+        if (this._near === value)
+            return;
+
+        this._near = value;
+        this._isDirty = true;
+    }
+
+    /** @inheritDoc */
+    public get farPlane(): number {
+        return this._far;
+    }
+
+    /** @inheritDoc */
+    public set farPlane(value: number) {
+        if (this._far === value)
+            return;
+
+        this._far = value;
+        this._isDirty = true;
+    }
+
+    /** @inheritDoc */
+    public get eye(): vec3 {
+        return this._eye;
+    }
+
+    /** @inheritDoc */
+    public set eye(value: vec3) {
+        if (this._eye === value)
+            return;
+        this._eye = value;
+        this._isDirty = true;
+    }
+
+    /** @inheritDoc */
+    public get projectionMatrix(): mat4 {
+        return this._projectionMatrix;
+    }
+
+    /** @inheritDoc */
+    public get projectionViewMatrix(): mat4 {
+        return this._projectionViewMatrix;
+    }
+
+    /** @inheritDoc */
+    public get viewMatrix(): mat4 {
+        return this._viewMatrix;
+    }
+
+    /** @inheritDoc */
+    public get projectionBuffer(): IUniformBuffer {
+        return this._projectionBuffer;
+    }
+
+    /** @inheritDoc */
+    public get projectionViewBuffer(): IUniformBuffer {
+        return this._projectionViewBuffer;
+    }
+
+    /** @inheritDoc */
+    public get viewBuffer(): IUniformBuffer {
+        return this._viewBuffer;
+    }
+
+    /**
+     * Updates the camera matrices.
+     */
+    protected _updateMatrices() {
+        mat4.lookAt(this._viewMatrix, this._eye, this._target, OrthographicCamera.UP_VECTOR);
+        mat4.orthoNO(this._projectionMatrix, this._left, this._right, this._bottom, this._top, this._near, this._far);
+        mat4.multiply(this._projectionViewMatrix, this._projectionMatrix, this._viewMatrix);
+    }
+
+    /** @inheritDoc */
+    public initialize(): void {
+
+        this._projectionBuffer = this._framework.bufferFactory.createUniformBuffer(
+            this._projectionMatrix, BufferUsage.UNIFORM, "OrthographicCamera.projectionBuffer"
+        );
+
+        this._viewBuffer = this._framework.bufferFactory.createUniformBuffer(
+            this._viewMatrix, BufferUsage.UNIFORM, "OrthographicCamera.viewBuffer"
+        );
+
+        this._projectionViewBuffer = this._framework.bufferFactory.createUniformBuffer(
+            this._projectionViewMatrix, BufferUsage.UNIFORM, "OrthographicCamera.projectionViewBuffer"
+        );
+    }
+
+    /** @inheritDoc */
+    public updateBuffers(): void {
+        this._updateMatrices();
+        this.projectionBuffer.update(this.projectionMatrix);
+        this.viewBuffer.update(this.viewMatrix);
+        this.projectionViewBuffer.update(this.projectionViewMatrix);
+    }
+
+    /** @inheritDoc */
+    public update(_: GameTime): void {
+
+        if (!this._isDirty)
+            return;
+
+        this.updateBuffers();
+        this._isDirty = false;
+    }
+
+    /** @inheritDoc */
+    public dispose(): void {
+
+        this.projectionBuffer.dispose();
+        this.projectionViewBuffer.dispose();
+        this.viewBuffer.dispose();
+    }
+}

package/src/api/camera/PerspectiveCamera.ts

@@ -0,0 +1,206 @@
+import type { ICamera } from "./ICamera.ts";
+import {mat4, vec3} from "gl-matrix";
+import type { IFramework } from "../IFramework.ts";
+import {MathHelper} from "../utilities/MathHelper.ts";
+import {BufferUsage} from "../rendering/buffers/BufferUsage.ts";
+import type { IUniformBuffer } from "../rendering/buffers/IUniformBuffer.ts";
+import {GameTime} from "../time/GameTime.ts";
+
+/**
+ * The perspective camera.
+ */
+export class PerspectiveCamera implements ICamera {
+
+    protected readonly _framework: IFramework;
+    private readonly _tempVec3 = vec3.create();
+
+    private _projectionMatrix = mat4.create();
+    private _viewMatrix = mat4.create();
+    private _projectionViewMatrix = mat4.create();
+
+    private _direction = vec3.create();
+
+    private _positionBuffer: IUniformBuffer = null!;
+    private _projectionViewBuffer: IUniformBuffer = null!;
+    private _viewBuffer: IUniformBuffer = null!;
+    private _projectionBuffer: IUniformBuffer = null!;
+
+    /**
+     * The constructor.
+     * @param framework The framework.
+     * @param fov The field of view in radians.
+     * @param aspectRatio The aspect ratio.
+     * @param nearPlane The near plane.
+     * @param farPlane The far plane.
+     */
+    public constructor(
+        framework: IFramework,
+        fov: number,
+        aspectRatio: number,
+        nearPlane: number,
+        farPlane: number) {
+        this._framework = framework;
+        this.fieldOfView = fov;
+        this.aspectRatio = aspectRatio;
+        this.nearPlane = nearPlane;
+        this.farPlane = farPlane;
+
+        this._updateMatrices();
+    }
+
+    /**
+     * The projection matrix.
+     */
+    public get projectionMatrix(): mat4 {
+        return this._projectionMatrix;
+    }
+
+    /**
+     * The projection matrix.
+     */
+    public set projectionMatrix(value: mat4) {
+        this._projectionMatrix = value;
+    }
+
+    /**
+     * The view matrix.
+     */
+    public get viewMatrix(): mat4 {
+        return this._viewMatrix;
+    }
+
+    /**
+     * The view matrix.
+     */
+    public set viewMatrix(value: mat4) {
+        this._viewMatrix = value;
+    }
+
+    /**
+     * The projection view matrix.
+     */
+    public get projectionViewMatrix(): mat4 {
+        return this._projectionViewMatrix;
+    }
+
+    /**
+     * The projection view matrix.
+     */
+    public set projectionViewMatrix(value: mat4) {
+        this._projectionViewMatrix = value;
+    }
+
+    /** @inheritDoc */
+    public get projectionViewBuffer(): IUniformBuffer {
+        return this._projectionViewBuffer;
+    }
+
+    /** @inheritDoc */
+    public get projectionBuffer(): IUniformBuffer {
+        return this._projectionBuffer;
+    }
+
+    /** @inheritDoc */
+    public get viewBuffer(): IUniformBuffer {
+        return this._viewBuffer;
+    }
+
+    /** @inheritDoc */
+    public get positionBuffer(): IUniformBuffer {
+        return this._positionBuffer;
+    }
+
+    /**
+     * The eye position of the camera.
+     */
+    public eye = vec3.fromValues(0,0,3);
+
+    /**
+     * The target position of the camera.
+     */
+    public target = vec3.create();
+
+    /**
+     * The up vector of the camera.
+     */
+    public up = vec3.fromValues(0,1,0);
+
+    /** The direction of a camera. */
+    public get direction(): vec3 {
+        vec3.sub(this._direction, this.target, this.eye);
+        return this._direction;
+    }
+
+    /**
+     * The field of view of the camera.
+     */
+    public fieldOfView = MathHelper.toRadians(60);
+
+    /**
+     * The aspect ratio of the camera.
+     */
+    public aspectRatio = 1;
+
+    /**
+     * The near plane of the camera.
+     */
+    public nearPlane = 0.01;
+
+    /**
+     * The far plane of the camera.
+     */
+    public farPlane = 1000;
+
+    /** @inheritDoc */
+    public readonly coreCamera: ICamera | undefined = undefined;
+
+    /**
+     * Initialize the camera.
+     */
+    public initialize(): void {
+        const bufferUsage = BufferUsage.UNIFORM | BufferUsage.COPY_DST;
+        this._positionBuffer = this._framework.bufferFactory.createUniformBuffer(this.eye, bufferUsage);
+        this._projectionViewBuffer = this._framework.bufferFactory.createUniformBuffer(this.projectionViewMatrix, bufferUsage);
+        this._projectionBuffer = this._framework.bufferFactory.createUniformBuffer(this.projectionMatrix, bufferUsage);
+        this._viewBuffer = this._framework.bufferFactory.createUniformBuffer(this.viewMatrix, bufferUsage);
+    }
+
+    /**
+     * Updates the camera matrices.
+     */
+    protected _updateMatrices(): void {
+
+        // Right-handed
+        mat4.perspectiveNO(this._projectionMatrix, this.fieldOfView, this.aspectRatio, this.nearPlane, this.farPlane);
+
+        // mat4 does not have right-handed look at, therefore swap z for right-handed matrix.
+        this._tempVec3[0] = this.eye[0];
+        this._tempVec3[1] = this.eye[1];
+        this._tempVec3[2] = -this.eye[2];
+        mat4.lookAt(this.viewMatrix, this._tempVec3, this.target, this.up);
+        mat4.multiply(this.projectionViewMatrix, this.projectionMatrix, this.viewMatrix);
+    }
+
+    /** @inheritDoc */
+    public update(time: GameTime): void {
+        void time;
+        this._updateMatrices();
+        this.updateBuffers();
+    }
+
+    /** @inheritDoc */
+    public updateBuffers(): void {
+        this._positionBuffer.update(this.eye);
+        this._projectionBuffer.update(this.projectionMatrix);
+        this._viewBuffer.update(this.viewMatrix);
+        this._projectionViewBuffer.update(this.projectionViewMatrix);
+    }
+
+    /** @inheritDoc */
+    public dispose(): void {
+        this._viewBuffer.dispose();
+        this._projectionBuffer.dispose();
+        this._projectionViewBuffer.dispose();
+        this._positionBuffer.dispose();
+    }
+}

package/src/api/camera/_export.ts

@@ -0,0 +1,7 @@
+export * from "./ICamera.ts";
+export * from "./IOrthographicCamera.ts";
+export * from "./ICameraFactory.ts";
+export * from "./OrbitCamera.ts"
+export * from "./OrthographicCamera.ts";
+export * from "./PerspectiveCamera.ts";
+export * from "./CameraFactory.ts"

package/src/api/content/ContentConfig.ts

@@ -0,0 +1,11 @@
+/**
+ * The configuration to provide when loading content with the content manager.
+ */
+export class ContentConfig {
+
+    /**
+     * Should data be kept in memory?
+     * This allows fast loading of content on repeated loads, for example, when texture needs to be reloaded.
+     */
+    public keepDataCached = false;
+}

package/src/{core → api}/content/ContentManager.ts

@@ -4,9 +4,9 @@ import {
     type IShaderModuleLoader,
     type ITexture2D,
     type IFramework, TextureDescriptor, TextureFormat, ContentConfig, TextureUsage
-} from "ris-framework-api";
+} from "../index.ts";
 import {Ktx2Factory} from "ris-ktx2";
-import type {IKtx2Texture} from "ris-ktx2-api";
+import type {IKtx2Texture} from "ris-ktx2";
 
 
 /**
@@ -20,6 +20,7 @@ export class ContentManager implements IContentManager {
 
     /**
      * The constructor.
+     * @param _framework The framework.
      * @param shaderModuleLoader The shader module loader.
      */
     public constructor(private readonly _framework: IFramework, public readonly shaderModuleLoader: IShaderModuleLoader) {
@@ -52,7 +53,7 @@ export class ContentManager implements IContentManager {
                                     ): Promise<ITexture2D> {
 
         if(path.endsWith(".ktx2")) {
-            const ktx2Texture = await this.loadKtx2Async(path);
+            const ktx2Texture = await this.loadKtx2Async(path, contentConfig);
             textureDescriptor = textureDescriptor ?? new TextureDescriptor();
             return this._framework.textureFactory.createFromKtx2(ktx2Texture, textureDescriptor);
         }

package/src/api/content/IContent.ts

@@ -0,0 +1,9 @@
+import type { IDisposable } from "../core/IDisposable.ts";
+
+/**
+ * The content interface.
+    Every piece of content should implement this interface.
+ */
+export interface IContent extends IDisposable {
+
+}

package/src/api/content/IContentManager.ts

@@ -0,0 +1,41 @@
+import type { IShaderModuleLoader } from "../shader/IShaderModuleLoader.ts";
+import type { IShaderModule } from "../shader/IShaderModule.ts";
+import type { ITexture2D } from "../rendering/texture/ITexture2D.ts";
+import {TextureDescriptor} from "../rendering/texture/TextureDescriptor.ts";
+import {ContentConfig} from "./ContentConfig.ts";
+import type { IKtx2Texture } from "ris-ktx2";
+
+/**
+ * The content manager.
+ */
+export interface IContentManager {
+
+    /**
+     * The shader module loader.
+     */
+    readonly shaderModuleLoader: IShaderModuleLoader;
+
+    /**
+     * Loads a KTX2 container.
+     * @param path - The path to the ktx2 asset.
+     * @param config - The content configuration.
+     * @returns The ktx2 texture.
+     */
+    loadKtx2Async(path: string, config?: ContentConfig): Promise<IKtx2Texture>;
+
+    /**
+     * Loads a shader module.
+     * @param shaderAssetId - The id of a shader asset.
+     * @returns The shader module.
+     */
+    loadShaderModule(shaderAssetId: string): IShaderModule;
+
+    /**
+     * Loads a texture2D.
+     * @param path - The file path to the texture.
+     * @param desc - The texture descriptor.
+     * @param contentConfig - The content config.
+     * @returns The Texture2D.
+     */
+    loadTexture2DAsync(path: string, desc?: TextureDescriptor, contentConfig?: ContentConfig): Promise<ITexture2D>;
+}

package/src/api/content/IContentModule.ts

@@ -0,0 +1,67 @@
+import type { IContent } from "./IContent.ts";
+
+/**
+ * The content module.
+ * This is the main interface for loading various types of content, such as textures, shaders, and audio.
+ */
+export interface IContentModule {
+
+    /**
+     * The type of content that should be loaded and returned.
+     */
+    readonly contentTypes: string[];
+
+    /**
+     * The content path.
+     * This is the path where the content is located.
+     * It can be a file path, a URL, or any other identifier that can be used to load the content.
+     */
+    contentPath?: string;
+
+    /**
+     * Use to notify the content manager that the content bundle has been loaded.
+     * The first parameter is the bundle name, and the second parameter is the loaded bundle object.
+     */
+    addOnBundleLoadedListener(event: (bundleName: string, bundle: any) => void): void;
+
+    /**
+     * Use to notify the content manager that the content bundle has been loaded.
+     * The first parameter is the bundle name, and the second parameter is the loaded bundle object.
+     */
+    removeOnBundleLoadedListener(event: (bundleName: string, bundle: any) => void): void;
+
+    /**
+     * Load the content with the specified ID.
+     *  The ID is a unique identifier for the content, and it is used to retrieve the content from the content manager.
+     * @param id - The unique identifier for the content.
+     * @param options - The optional options for loading the content.
+     */
+    load(id: string, options?: any): IContent;
+
+    /**
+     * Load the content with the specified ID.
+     *     The ID is a unique identifier for the content, and it is used to retrieve the content from the content manager.
+     * @param id - The unique identifier for the content.
+     * @param options - The optional options for loading the content.
+     */
+    loadAsync(id: string, options?: any): Promise<IContent>;
+
+    /**
+     * Load the content bundle with the specified name.
+     *     A content bundle is a collection of related content items that can be loaded together.
+     * @param bundleName - The bundle name.
+     * @param options - The optional options for loading the bundle.
+     * @returns True if the bundle was loaded successfully; otherwise, false.
+     */
+    loadBundle(bundleName: string, options?: any): void;
+
+    /**
+     * Load the content bundle with the specified name.
+     *     A content bundle is a collection of related content items that can be loaded together.
+     * @param bundleName - The bundle name.
+     * @param options - The optional options for loading the bundle.
+     * @returns True if the bundle was loaded successfully; otherwise, false.
+     */
+    loadBundleAsync(bundleName: string, options?: any): Promise<void>;
+
+}

package/src/{content → api/content}/ShaderModuleContent.ts

@@ -1,11 +1,11 @@
-import mainRenderTargetFlipYVS from "../../shaders/glsl/main_render_target_flip_y_vs.glsl?raw";
-import mainRenderTargetFlipYFS from "../../shaders/glsl/main_render_target_flip_y_fs.glsl?raw";
-import spriteVS from "../../shaders/glsl/sprite_vs.glsl?raw";
-import spriteFS from "../../shaders/glsl/sprite_fs.glsl?raw";
-import inspectTextureMipsVS from "../../shaders/glsl/inspect_texture_mips_vs.glsl?raw";
-import inspectTextureMipsFS from "../../shaders/glsl/inspect_texture_mips_fs.glsl?raw";
-import unlitMaterialVS from "../../shaders/glsl/unlit_material_vs.glsl?raw";
-import unlitMaterialFS from "../../shaders/glsl/unlit_material_fs.glsl?raw";
+import mainRenderTargetFlipYVS from "../../../shaders/glsl/main_render_target_flip_y_vs.glsl?raw";
+import mainRenderTargetFlipYFS from "../../../shaders/glsl/main_render_target_flip_y_fs.glsl?raw";
+import spriteVS from "../../../shaders/glsl/sprite_vs.glsl?raw";
+import spriteFS from "../../../shaders/glsl/sprite_fs.glsl?raw";
+import inspectTextureMipsVS from "../../../shaders/glsl/inspect_texture_mips_vs.glsl?raw";
+import inspectTextureMipsFS from "../../../shaders/glsl/inspect_texture_mips_fs.glsl?raw";
+import unlitMaterialVS from "../../../shaders/glsl/unlit_material_vs.glsl?raw";
+import unlitMaterialFS from "../../../shaders/glsl/unlit_material_fs.glsl?raw";
 
 /**
  * The api should look something like this for internal ones.

package/src/api/content/_export-content.ts

@@ -0,0 +1,4 @@
+export * from "./IContent.ts";
+export * from "./IContentManager.ts";
+export * from "./IContentModule.ts";
+export * from "./ContentConfig.ts";

package/src/api/core/IDisposable.ts

@@ -0,0 +1,10 @@
+/**
+ * Interface that should be called to correctly dispose of instance.
+ */
+export interface IDisposable {
+
+    /**
+     * Disposes the resource and release memory if resources allocated memory.
+     */
+    dispose() : void;
+}

package/src/api/core/_export-core.ts

@@ -0,0 +1 @@
+export * from "./IDisposable.ts";