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

package/src/api/sprites/ISpriteBatch.ts

@@ -0,0 +1,144 @@
+import type { ITexture2D } from "../rendering/texture/ITexture2D.ts";
+import {Rect} from "../data/Rect.ts";
+import {Color} from "../data/Color.ts";
+import {vec2, mat4} from "gl-matrix"
+import type { ISampler } from "../rendering/sampler/ISampler.ts";
+
+/**
+ * The sprite batch.
+ */
+export interface ISpriteBatch {
+
+    /**
+     * Initializes the sprite batch.
+     * This method is called internally by the framework.
+     */
+    initialize(): void;
+
+    /**
+     * Begins the sprite batch.
+     * @param projectionViewMatrix - The projection view matrix to use for rendering between Begin and End.
+     */
+    begin(projectionViewMatrix?: mat4, textureSampler?: ISampler): void;
+
+    /**
+     * Draws the un-textured rectangle.
+     * @param drawRect The rectangle.
+     * @param color The color.
+     * @param rotation The rotation of rectangle.
+     * @param rotationOrigin The rotation origin.
+     */
+    drawRect(drawRect: Rect, color: Color, rotation?: number, rotationOrigin?: vec2): void;
+
+    /**
+     * Draws a sprite.
+     * @param texture - The texture to draw.
+     * @param drawRect - The draw rectangle.
+     * @param color - The color.
+     * @param sourceRect - The source rectangle that selects part of the texture to draw.
+     * @param rotation - The rotation of a sprite in clockwise order.
+     * @param rotationOrigin - The origin for a rotation.
+     * @param layerDepth - The layer depth. By default, it is 0.
+     */
+    draw(texture: ITexture2D,
+         drawRect: Rect,
+         color: Color,
+         sourceRect?: Rect,
+         rotation?: number,
+         rotationOrigin?: vec2,
+         layerDepth?: number): void;
+
+
+    /**
+     * Draws a sprite.
+     * @param texture - The texture to draw.
+     * @param position - The position of a sprite.
+     * @param size - The size of a sprite.
+     */
+    // draw(texture: ITexture2D, position: vec2, size: vec2): void;
+
+    /**
+     * Draws a sprite.
+     * @param texture - The texture to draw.
+     * @param drawRect - The draw rectangle.
+     * @param color - The color.
+     */
+    // draw(texture: ITexture2D, drawRect: Rect, color: Color): void;
+
+    /**
+     * Draws a sprite.
+     * @param texture - The texture to draw.
+     * @param drawRect - The draw rectangle.
+     * @param sourceRect - The source rectangle that selects part of the texture to draw.
+     * @param color - The color.
+     */
+    //draw(texture: ITexture2D, drawRect: Rect, sourceRect: Rect, color: Color): void;
+
+    /**
+     * Draws a sprite.
+     * @param texture - The texture to draw.
+     * @param drawRect - The draw rectangle.
+     * @param sourceRect - The source rectangle that selects part of the texture to draw.
+     * @param color - The color.
+     * @param rotation - The rotation of a sprite in clockwise order.
+     */
+    // draw(texture: ITexture2D, drawRect: Rect, sourceRect: Rect, color: Color, rotation: number): void;
+
+    /**
+     * Draws the empty rectangle shape of a given color.
+     * @param drawRect - The draw rectangle.
+     * @param color - The color.
+     * @param origin - The origin of a sprite.
+     * @param rotation - The rotation of a sprite in clockwise order.
+     * @param rotationOrigin - The origin for a rotation.
+     If null by default, it is set to (0,0) or top left corner.
+     */
+    //  draw(drawRect: Rect, color: Color, origin: vec2, rotation: number, rotationOrigin?: number): void;
+
+    /**
+     * Draws a sprite.
+     * @param texture - The texture to draw.
+     * @param drawRect - The draw rectangle.
+     * @param sourceRect - The source rectangle that selects part of texture to draw.
+     * @param color - The color.
+     * @param origin - The origin of a sprite.
+     * @param rotation - The rotation of a sprite in clockwise order.
+     * @param rotationOrigin - The origin for a rotation.
+     * @param layerDepth - The layer depth. By default, it is 0.
+     */
+    //draw(texture: ITexture2D, drawRect: Rect, sourceRect: Rect, color: Color, origin: vec2, rotation: number, rotationOrigin: vec2, layerDepth: number): void;
+
+    /**
+     * Draws a sprite.
+     * @param texture - The texture to draw.
+     * @param position - The position.
+     * @param sourceRect - The source rectangle that selects part of texture to draw.
+     * @param color - The color.
+     * @param rotation - The rotation of a sprite in clockwise order.
+     * @param origin - The origin of a sprite.
+     * @param scale - The scale of a sprite.
+     * @param flipSpriteHorizontally - Flip sprite horizontally. By default, it is false.
+     * @param flipSpriteVertically - Flip sprite vertically. By default, it is false.
+     */
+    //draw(texture: ITexture2D, position: vec2, sourceRect: Rect, color: Color, rotation: number, origin: vec2, scale: vec2, flipSpriteHorizontally: boolean, flipSpriteVertically: boolean): void;
+
+    /**
+     * Draws a sprite.
+     * @param texture - The texture to draw.
+     * @param sourceRect - The source rectangle that selects part of texture to draw.
+     * @param position - The position of a sprite.
+     * @param size - The size of a sprite.
+     */
+
+    // draw(texture: ITexture2D, sourceRect: Rect, position: vec2, size: vec2): void;
+
+    /**
+     * Ends the sprite batch.
+     */
+    end(): void;
+
+    /**
+     * Called internally by framework on end of frame.
+     */
+    frameEnd(): void;
+}

package/src/{core/sprite-batch → api/sprites}/SpriteBatch.ts

@@ -1,5 +1,5 @@
 import {type mat4, vec2, vec3} from "gl-matrix";
-import {SpriteBatchDrawable} from "./SpriteBatchDrawable";
+import {SpriteBatchDrawable} from "./SpriteBatchDrawable.ts";
 import {
     type IFramework,
     type ITexture2D,
@@ -7,7 +7,7 @@ import {
     type IOrthographicCamera,
     type IUniformBuffer,
     Color, Rect, type ISampler
-} from "ris-framework-api";
+} from "../index.ts";
 
 /**
  * The implementation of sprite batch.
@@ -59,10 +59,12 @@ export class SpriteBatch implements ISpriteBatch {
         let samplerKeyValue = this._spriteBatchDrawables.get(texture.id);
         if (!samplerKeyValue) {
             samplerKeyValue = new Map();
-            samplerKeyValue.set(sampler.id, drawable);
+            this._spriteBatchDrawables.set(texture.id, samplerKeyValue);
         }
 
-        this._spriteBatchDrawables.set(texture.id, samplerKeyValue);
+        // Always store it. A second sampler for the same texture must be cached too,
+        // otherwise a new drawable (and GPU buffers) is created on every switch.
+        samplerKeyValue.set(sampler.id, drawable);
     }
 
     private _validateTexture(texture?: ITexture2D) {
@@ -91,9 +93,10 @@ export class SpriteBatch implements ISpriteBatch {
 
                 this._setDrawable(texture, sampler, spriteBatchDrawable);
 
-                // When texture is disposed destroy this drawable.
+                // When texture is disposed destroy this drawable and forget it.
                 const disposeListener = () => {
                     spriteBatchDrawable?.dispose();
+                    this._spriteBatchDrawables.get(texture.id)?.delete(sampler.id);
                     texture.removeOnDisposedListener(disposeListener);
                 };
                 texture.addOnDisposedListener(disposeListener);

package/src/{core/sprite-batch → api/sprites}/SpriteBatchDrawable.ts

@@ -5,7 +5,7 @@ import type {
     IUniformBuffer,
     Color,
     IDisposable, ISampler
-} from "ris-framework-api";
+} from "../index.ts";
 import {SpriteBatchMesh} from "./SpriteBatchMesh.ts";
 import type {vec2, vec3} from "gl-matrix";
 
@@ -104,14 +104,14 @@ export class SpriteBatchDrawable implements IDisposable {
 
     /** Draws the mesh */
     public draw(): void {
-        // Nothing to draw.
-        if (this._toInstance <= 0 || this._fromInstance > this._toInstance) {
+        // Nothing new to draw.
+        if (this._toInstance <= 0 || this._fromInstance >= this._toInstance) {
             return;
         }
 
-        // Clamp instance to max batch size.
-        if (this._toInstance >= this._maxBatchSize) {
-            this._toInstance = this._maxBatchSize - 1;
+        // Clamp instance to max batch size. _toInstance is a count, so maxBatchSize itself is valid.
+        if (this._toInstance > this._maxBatchSize) {
+            this._toInstance = this._maxBatchSize;
         }
 
         // Draw mesh.

package/src/{core/sprite-batch → api/sprites}/SpriteBatchMesh.ts

@@ -1,5 +1,5 @@
 import type {vec2, vec3} from "gl-matrix";
-import {BufferUsage, type Color, type IFramework, Mesh} from "ris-framework-api";
+import {BufferUsage, type Color, type IFramework, Mesh} from "../index.ts";
 
 /**
  * The sprite batch mesh.
@@ -57,7 +57,7 @@ export class SpriteBatchMesh extends Mesh {
     public override initialize(): void {
         this._vertexBuffer = this._framework.bufferFactory.createVertexBuffer(
             this._vertexData!,
-            this.maxInstances * 4,
+            SpriteBatchMesh.TOTAL_FLOATS_PER_VERTEX * Float32Array.BYTES_PER_ELEMENT,
             BufferUsage.VERTEX | BufferUsage.COPY_DST,
             "SpriteBatchMesh.VertexBuffer");
 
@@ -78,8 +78,12 @@ export class SpriteBatchMesh extends Mesh {
         // Create new data.
         const newData = new Array(this._maxInstances * SpriteBatchMesh.TOTAL_FLOATS_IN_SPRITE); // 36 due to 9(xyz rgba uv) * 4 vertices.
 
-        // Copy to new data.
-        newData.push(this._vertexData)
+        // Copy the existing vertices into the start of the new data.
+        const oldData = this._vertexData ?? [];
+        const copyLength = Math.min(oldData.length, newData.length);
+        for (let i = 0; i < copyLength; i++) {
+            newData[i] = oldData[i];
+        }
 
         // Replace old data.
         this._vertexData = newData;

package/src/api/sprites/_export_sprites.ts

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

package/src/api/time/GameTime.ts

@@ -0,0 +1,30 @@
+/**
+ * The time information.
+ */
+export class GameTime {
+
+    /**
+     * Total elapsed time in milliseconds.
+     */
+    public elapsedTimeMs: number = 0;
+
+    /**
+     * Elapsed time in seconds.
+     */
+    public get elapsedTimeSec() {
+        return this.elapsedTimeMs / 1000;
+    }
+
+    /**
+     * Delta time in milliseconds.
+     * This is the time between the current frame and the last frame in milliseconds.
+     */
+    public deltaTimeMs: number = 0;
+
+    /**
+     * Delta time in seconds. This is the time between the current frame and the last frame in seconds.
+     */
+    public get deltaTimeSec() {
+        return this.deltaTimeMs / 1000;
+    }
+}

package/src/api/time/ITimeManager.ts

@@ -0,0 +1,22 @@
+import {GameTime} from "./GameTime.ts";
+
+/**
+ * The time manager interface.
+ */
+export interface ITimeManager {
+
+    /**
+     * Gets the time information.
+     */
+    readonly time: GameTime;
+
+    /**
+     * Called once before the first frame starts to prepare the time.
+     */
+    prepareStart(): void;
+
+    /**
+     * Should be called at the start of the frame.
+     */
+    frameStart(): void;
+}

package/src/api/time/TimeManager.ts

@@ -0,0 +1,33 @@
+import {GameTime} from "./GameTime.ts";
+
+/**
+ * The time manager.
+ */
+export class TimeManager {
+
+    private readonly _gameTime = new GameTime();
+    private _lastFrameTime = Date.now();
+
+    /** @inheritDoc */
+    public get time(): GameTime {
+        return this._gameTime;
+    }
+
+    /** @inheritDoc */
+    public prepareStart(): void {
+     this._gameTime.elapsedTimeMs = 0;
+     this._lastFrameTime = Date.now();
+    }
+
+    /** @inheritDoc */
+    public frameStart(): void {
+        const currentTime = Date.now();
+
+        const deltaTime = (currentTime - this._lastFrameTime);
+
+        this._gameTime.deltaTimeMs = deltaTime;
+        this._gameTime.elapsedTimeMs += deltaTime;
+
+        this._lastFrameTime = currentTime;
+    }
+}

package/src/api/time/_export_time.ts

@@ -0,0 +1,3 @@
+export * from "./GameTime.ts";
+export * from "./ITimeManager.ts";
+export * from "./TimeManager.ts";

package/src/api/utilities/AlignUtilities.ts

@@ -0,0 +1,39 @@
+/**
+ * The utilities for aligning values.
+ */
+
+export class AlignUtilities {
+
+    /**
+     * Aligns the value to the specified alignment.
+     * @param value - The value to align.
+     * @param alignment - The alignment.
+     * @returns The aligned value.
+     */
+    public static align(value: number, alignment: number): number {
+        return (value + alignment - 1) & ~(alignment - 1);
+    }
+
+    /**
+     * Creates a new aligned array or returns existing array if it's already aligned.
+     * @param array The array to align.
+     * @param alignment The alignment.
+     * @returns The new aligned array.
+     */
+    public static alignArray(array: ArrayLike<number>, alignment: number): ArrayLike<number> {
+        const len = this.align(array.length, alignment);
+        
+        if(len == array.length) {
+            return array;
+        }
+        
+        const newArray = new Array(len);
+        
+        // Copy array
+        for (let i = 0; i < array.length; i++) {
+            newArray[i] = array[i];
+        }
+        
+        return newArray;
+    }
+}

package/src/api/utilities/GeometryUtilities.ts

@@ -0,0 +1,20 @@
+import {GeometryFormat} from "../geometry/GeometryFormat.ts";
+
+/**
+ * The geometry utilities.
+ */
+export class GeometryUtilities {
+    /**
+     * Gets the stride of the geometry format.
+     * @param geometryFormat The geometry format.
+     * @returns The stride.
+     */
+    public static stride(geometryFormat: GeometryFormat): number {
+        switch (geometryFormat) {
+            case GeometryFormat.POS3_COLOR4_TEXTURECOORDS2:
+                return (3 + 4 + 2) * Float32Array.BYTES_PER_ELEMENT;
+            default:
+                throw new Error("Unknown geometryFormat");
+        }
+    }
+}

package/src/api/utilities/MathHelper.ts

@@ -0,0 +1,256 @@
+import {vec2} from "gl-matrix";
+
+/**
+ * The math helper class.
+ * Provides math functions and constants.
+ */
+export class MathHelper {
+
+    /**
+     * The value of half PI.
+     */
+    public static readonly HALF_PI = Math.PI * 0.5;
+
+    /**
+     * Convert degrees to radians.
+     * @param degrees - The degrees.
+     * @returns The radians.
+     */
+    public static toRadians(degrees: number): number {
+        return degrees * (Math.PI / 180);
+    }
+
+    /**
+     * Convert radians to degrees.
+     * @param radians - The radians.
+     * @returns The degrees.
+     */
+    public  static toDegrees(radians: number): number {
+        return radians * (180 / Math.PI);
+    }
+
+    /**
+     * Convert pitch to polar angle.
+     * Pitch is used in Aircraft coordinates to represent the up and down movement.
+     * Polar is used in spherical coordinates to represent the up and down movement.
+     * @param pitch - The pitch angle.
+     * @returns The polar angle.
+     */
+    public pitchToPolar(pitch: number): number {
+        void pitch;
+        throw new Error('Not implemented');
+    }
+
+    /**
+     * Convert azimuth to yaw.
+     *
+     * Azimuth is used in spherical coordinates to represent the left and right movement.
+     *
+     * Yam is used in Aircraft coordinates to represent the left and right movement.
+     * @param yaw - The yaw angle.
+     * @returns The azimuth angle.
+     */
+    public yawToAzimuth(yaw: number): number {
+        void yaw;
+        throw new Error('Not implemented');
+    }
+
+    /**
+     * Convert polar to pitch angle.
+     * Polar is used in spherical coordinates to represent the up and down movement.
+     * Pitch is used in Aircraft coordinates to represent the up and down movement.
+     * @param polar - The polar angle.
+     * @returns The pitch angle.
+     */
+    public polarToPitch(polar: number): number {
+        void polar;
+        throw new Error('Not implemented');
+    }
+
+    /**
+     * Convert azimuth to yaw angle.
+     *
+     * Yam is used in Aircraft coordinates to represent the left and right movement.
+     *
+     * Azimuth is used in spherical coordinates to represent the left and right movement.
+     * @param azimuth - The azimuth angle.
+     * @returns The yaw angle.
+     */
+    public azimuthToYaw(azimuth: number): number {
+        void azimuth;
+        throw new Error('Not implemented');
+    }
+
+    /**
+     * Create a smooth step for the given value.
+     * Value should be in range [0, 1].
+     * @param x - The x value.
+     * @returns The smoothed value.
+     */
+    public smoothStep(x: number): number {
+        void x;
+        throw new Error('Not implemented');
+    }
+
+    /**
+     * Map the value from one range to another.
+     * @param value - The value to map.
+     * @param fromMin - From minimum.
+     * @param fromMax - From maximum.
+     * @param toMin - To minimum.
+     * @param toMax - To maximum.
+     * @returns The mapped value.
+     */
+    public static map(value: number, fromMin: number, fromMax: number, toMin: number, toMax: number): number {
+        return (value - fromMin) / (fromMax - fromMin) * (toMax - toMin) + toMin;
+    }
+
+    /**
+     * Align the bytes to the given alignment.
+     * @param value - The value.
+     * @param alignment - The alignment.
+     * @returns The aligned bytes.
+     */
+    public alignBytes(value: number, alignment: number): number {
+        void value;
+        void alignment;
+        throw new Error('Not implemented');
+    }
+
+    /**
+     * Clamp the value between the given range.
+     * @param value - The value to clamp.
+     * @param lowerLimit - The lower value.
+     * @param upperLimit - The upper limit.
+     * @returns The clamped value.
+     */
+    public static clamp(value: number, lowerLimit: number, upperLimit: number): number {
+        if(value < lowerLimit){
+            return lowerLimit;
+        }
+        if(value > upperLimit){
+            return upperLimit;
+        }
+
+        return value;
+    }
+
+    /**
+     * Return the maximum value between the two values.
+     * @param a - The first value.
+     * @param b - The second value.
+     * @returns The maximum value.
+     */
+    public max(a: number, b: number): number {
+        void a;
+        void b;
+        throw new Error('Not implemented');
+    }
+
+    /**
+     * Return the minimum value between the two values.
+     * @param a - The first value.
+     * @param b - The second value.
+     * @returns The minimum value.
+     */
+    public min(a: number, b: number): number {
+        void a;
+        void b;
+        throw new Error('Not implemented');
+    }
+
+    /**
+     * Checks if circle intersects with another circle.
+     * @param p1 - The point origin of first circle.
+     * @param r1 - The radius of first circle.
+     * @param p2 - The point origin of second circle.
+     * @param r2 - The radius of second circle.
+     * @returns
+     */
+    public circleIntersectsCircle(p1: vec2, r1: number, p2: vec2, r2: number): boolean {
+        void p1;
+        void r1;
+        void p2;
+        void r2;
+        throw new Error('Not implemented');
+    }
+
+    /**
+     * The dot product of two vectors.
+     * @param v1 - The first vector.
+     * @param v2 - The second vector.
+     * @returns The dot product.
+     */
+    public dot(v1: vec2, v2: vec2): number {
+        void v1;
+        void v2;
+        throw new Error('Not implemented');
+    }
+
+    /**
+     * Reflect the vector off the normal.
+     * @param v - The vector to reflect.
+     * @param n - The normal vector.
+     * @returns The reflected vector.
+     */
+    public reflect(v: vec2, n: vec2): vec2 {
+        void v;
+        void n;
+        throw new Error('Not implemented');
+    }
+
+    /**
+     * Convert angle to vector.
+     * @param angle - The angle in radians.
+     * @returns The vector.
+     */
+    public angleToVector(angle: number): vec2 {
+        void angle;
+        throw new Error('Not implemented');
+    }
+
+    /**
+     * Creates a random float value between -1 and 1
+     * where values are more likely to be closer to 0.
+     * @returns The random value.
+     */
+    public randomBinomial(): number {
+        throw new Error('Not implemented');
+    }
+
+    /**
+     * Create a vector from an angle.
+     * @param angle - The angle.
+     * @returns The unit vector pointing in the direction of `angle`.
+     */
+    public vector2DFromAngle(angle: number): vec2 {
+        void angle;
+        throw new Error('Not implemented');
+    }
+
+    /**
+     * Raises a number to a power.
+     * @param baseValue - The base
+     * @param exponent - The exponent
+     * @returns baseValue raised to exponent
+     */
+    public pow(baseValue: number, exponent: number): number {
+        void baseValue;
+        void exponent;
+        throw new Error('Not implemented');
+    }
+
+    /**
+     * Rotates a point around a center by a given angle.
+     * @param point - The point.
+     * @param center - The center.
+     * @param angle - The angle
+     * @returns Rotated vector.
+     */
+    public rotatePoint(point: vec2, center: vec2, angle: number): vec2 {
+        void point;
+        void center;
+        void angle;
+        throw new Error('Not implemented');
+    }
+}

package/src/api/utilities/_export.ts

@@ -0,0 +1,3 @@
+export * from "./AlignUtilities.ts"
+export * from "./GeometryUtilities.ts"
+export * from "./MathHelper.ts"