update readme.md

Author: Nightre

README.md

@@ -1,3 +1,9 @@
+> [!WARNING]
+> **🚧 Major Refactoring in Progress 🚧**
+>
+> This project is currently undergoing a significant rewrite to improve its core architecture and introduce new features. As a result, the **current documentation and examples are outdated** and may not work with the `main` branch.
+>
+> We are working hard to update the documentation soon. Thank you for your patience!
 
 # Rapid.js
 

src/interface.ts

@@ -374,3 +374,8 @@ export type ParticleAttributeData<T extends ParticleAttributeTypes> = {
      */
     damping?: number,
 }
+
+
+export interface IGameOptions extends IRapidOptions {
+    
+}

src/render.ts

@@ -38,8 +38,6 @@ class Rapid {
     logicWidth!: number
     logicHeight!: number
 
-    camera: Camera
-
     private scaleEnable: boolean;
     private scaleRadio: ScaleRadio;
 
@@ -64,9 +62,6 @@ class Rapid {
         this.canvas = options.canvas
         this.textures = new TextureCache(this, options.antialias ?? false)
         this.maxTextureUnits = gl.getParameter(this.gl.MAX_TEXTURE_IMAGE_UNITS);
-
-        this.camera = new Camera(this)
-
         this.width = options.width || this.canvas.width
         this.height = options.height || this.canvas.height
 
@@ -292,7 +287,6 @@ class Rapid {
         this.clear()
         clear && this.matrixStack.clear()
         this.matrixStack.pushIdentity()
-        this.applyCameraTransform()
         this.currentRegion = undefined
         this.currentRegionName = undefined
 
@@ -328,13 +322,6 @@ class Rapid {
         this.tileMap.renderLayer(data, options instanceof TileSet ? { tileSet: options } : options)
     }
 
-    private applyCameraTransform() {
-        // const centerdPosition = new Vec2(this.logicWidth, this.logicHeight).divide(2)
-        // this.matrixStack.translate(centerdPosition)
-        this.camera.render()
-        this.matrixStack.setTransform(this.camera.transform.getTransform())
-    }
-
     /**
      * Renders a sprite with the specified options.
      * 

src/utils.ts

@@ -1,4 +1,5 @@
-import { IEntityTransformOptions, ITransformOptions } from "./interface";
+import { InputManager } from "./input";
+import { IEntityTransformOptions, IGameOptions, ITransformOptions } from "./interface";
 import { MatrixStack, Vec2 } from "./math";
 import Rapid from "./render";
 
@@ -7,7 +8,6 @@ export const isPlainObject = (obj: any) => {
     return Object.getPrototypeOf(obj) === Object.prototype;
 }
 
-
 export class Entity {
     position: Vec2;
     scale: Vec2;
@@ -17,12 +17,14 @@ export class Entity {
     readonly children: Entity[] = [];
     transform = new MatrixStack();
     rapid: Rapid;
+    game: Game
 
     tags: string[];
 
-    constructor(rapid: Rapid, options: IEntityTransformOptions = {}) {
+    constructor(game: Game, options: IEntityTransformOptions = {}) {
         this.transform.pushIdentity()
-        this.rapid = rapid;
+        this.game = game
+        this.rapid = game.render;
 
         this.tags = options.tags ?? []
         // Position
@@ -49,9 +51,25 @@ export class Entity {
         return this.parent ? this.parent.transform : this.rapid.matrixStack;
     }
 
-    update(deltaTime: number): void {
+    public update(deltaTime: number): void {
+        this.onUpdate(deltaTime);
+
+        for (const child of this.children) {
+            child.update(deltaTime);
+        }
+    }
+    onUpdate(deltaTime: number) { }
+
+    public render(): void {
+        this.updateTransform();
+
+        this.onRender();
 
+        for (const child of this.children) {
+            child.render();
+        }
     }
+    onRender() { }
 
     updateTransform(deep: boolean = false) {
         if (deep && this.parent) {
@@ -64,24 +82,8 @@ export class Entity {
         transform.translate(this.position);
         transform.rotate(this.rotation);
         transform.scale(this.scale);
-    }
 
-    render(): void {
-        this.updateTransform();
-    }
-
-    postRender(): void {
-        for (const child of this.children) {
-            child.render();
-            child.postRender();
-        }
-    }
-
-    postUpdate(deltaTime: number): void {
-        for (const child of this.children) {
-            child.update(deltaTime);
-            child.postUpdate(deltaTime);
-        }
+        this.rapid.matrixStack.setTransform(transform.getTransform())
     }
 
     addChild(child: Entity): void {
@@ -100,14 +102,6 @@ export class Entity {
         }
     }
 
-    root(dt: number) {
-        this.update(dt)
-        this.postUpdate(dt)
-
-        this.render()
-        this.postRender()
-    }
-
     findDescendant(predicate: (entity: Entity) => boolean, onlyFirst = true): Entity[] | Entity | null {
         const results: Entity[] = [];
         for (const child of this.children) {
@@ -136,25 +130,95 @@ export class Entity {
         };
         return this.findDescendant(predicate, onlyFirst);
     }
+
+    dispose() {
+        this.postDispose();
+        if (this.parent) {
+            this.parent.removeChild(this);
+        }
+    }
+
+    postDispose() {
+        this.children.forEach(child => {
+            child.dispose();
+        })
+    }
 }
 
 export class Camera extends Entity {
     override updateTransform() {
         const transform = this.transform;
-        const parentTransform = this.getParentTransform();
-        transform.setTransform(parentTransform.getTransform());
-
+        transform.identity()
+        
         const centerdPosition = new Vec2(
-            -this.rapid.logicWidth, 
+            -this.rapid.logicWidth,
             -this.rapid.logicHeight
         ).divide(2)
 
         transform.translate(centerdPosition);
         transform.translate(this.position);
-        
+
         transform.rotate(this.rotation);
         transform.scale(this.scale);
 
         transform.setTransform(transform.getInverse())
     }
+}
+
+export class Scene extends Entity {
+    create() {
+
+    }
+}
+
+export class Game {
+    render: Rapid;
+    mainScene: Scene | null = null;
+    input: InputManager;
+    private isRunning: boolean = false;
+    private lastTime: number = 0;
+
+    constructor(options: IGameOptions) {
+        this.render = new Rapid(options);
+        this.input = new InputManager(this.render);
+    }
+
+    switchScene(newScene: Scene): void {
+        if (this.mainScene) {
+            this.mainScene.dispose();
+        }
+        this.mainScene = newScene;
+        newScene.create();
+    }
+
+    start(): void {
+        if (!this.isRunning) {
+            this.isRunning = true;
+            this.lastTime = performance.now();
+            this.gameLoop();
+        }
+    }
+
+    stop(): void {
+        this.isRunning = false;
+    }
+
+    private gameLoop(): void {
+        if (!this.isRunning) return;
+
+        const currentTime = performance.now();
+        const deltaTime = (currentTime - this.lastTime) / 1000; // Convert to seconds
+        this.lastTime = currentTime;
+
+        this.render.startRender();
+
+        if (this.mainScene) {
+            this.mainScene.update(deltaTime)
+            this.mainScene.render()
+        }
+
+        this.render.endRender();
+
+        requestAnimationFrame(this.gameLoop.bind(this));
+    }
 }