bg2e-js 2.3.2 → 2.3.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bg2e-js",
-  "version": "2.3.2",
+  "version": "2.3.4",
   "description": "a graphics engine for productivity applications",
   "main": "./dist/bg2e-js.js",
   "types": "./src/index.ts",

package/src/render/SceneAppController.ts

@@ -143,6 +143,9 @@ export default class SceneAppController extends AppController {
         this._debugRenderer?.beginFrame();
 
         await this.sceneRenderer?.frame(this.sceneRoot, delta);
+        if (this.sceneRenderer.postRedisplayFrames > 0) {
+            this.mainLoop.postRedisplay({ frames: this.sceneRenderer.postRedisplayFrames });
+        }
     }
 
     display(): void {

package/src/render/SceneRenderer.ts

@@ -25,6 +25,7 @@ export class FrameVisitor extends NodeVisitor {
     _delta: number;
     _modelMatrix: Mat4;
     _matrixStack: Mat4[];
+    _postRedisplayFrames: number = 0;
 
     constructor(renderQueue: RenderQueue) {
         super();
@@ -35,9 +36,17 @@ export class FrameVisitor extends NodeVisitor {
     }
 
     get delta(): number { return this._delta; }
-    set delta(d: number) { this._delta = d; }
 
     get modelMatrix(): Mat4 { return this._modelMatrix; }
+
+    get postRedisplayFrames() : number {
+        return this._postRedisplayFrames;
+    }
+
+    beginFrame(delta: number): void {
+        this._delta = delta;
+        this._postRedisplayFrames = 0;
+    }
     
     visit(node: Node): void {
         this._matrixStack.push(new Mat4(this._modelMatrix));
@@ -47,6 +56,8 @@ export class FrameVisitor extends NodeVisitor {
     didVisit(node: Node): void {
         this._modelMatrix = this._matrixStack[this._matrixStack.length - 1] || Mat4.MakeIdentity();
         this._matrixStack.pop();
+        this._postRedisplayFrames = Math.max(this._postRedisplayFrames, node.postRedisplayFrames);
+        node.postRedisplayFrames = 0;
     }
 }
 
@@ -156,6 +167,10 @@ export default class SceneRenderer {
         return this._renderQueue;
     }
 
+    get postRedisplayFrames() : number {
+        return this._frameVisitor ? this._frameVisitor.postRedisplayFrames : 0;
+    }
+
     async init({ shadowMapSize = new Vec(1024, 1024) }: { shadowMapSize?: Vec | number } = {}): Promise<void> {
         if (typeof(shadowMapSize) === "number") {
             shadowMapSize = new Vec(shadowMapSize, shadowMapSize);
@@ -253,7 +268,7 @@ export default class SceneRenderer {
         this._sceneRoot = sceneRoot;
 
         this._renderQueue?.newFrame();
-        this._frameVisitor.delta = delta;
+        this._frameVisitor.beginFrame(delta);
         this._frameVisitor.modelMatrix.identity();
 
         const mainCamera = Camera.GetMain(sceneRoot);

package/src/scene/Component.ts

@@ -4,6 +4,10 @@ import Drawable from "./Drawable";
 import LightComponent from "./LightComponent";
 import Node from "./Node";
 import Transform from "./Transform";
+import Bg2KeyboardEvent from "../app/Bg2KeyboardEvent";
+import Bg2MouseEvent from "../app/Bg2MouseEvent";
+import Bg2TouchEvent from "../app/Bg2TouchEvent";
+import Loader from "../db/Loader";
 
 // Type definitions
 type ComponentConstructor<T extends Component = Component> = new () => T;
@@ -41,7 +45,7 @@ export const createComponent = (typeId: string): Component | null => {
     return null;
 };
 
-export const deserializeComponent = async (sceneData: any, loader: any): Promise<Component | null> => {
+export const deserializeComponent = async (sceneData: any, loader: Loader): Promise<Component | null> => {
     const componentInstance = createComponent(sceneData.type);
     if (!componentInstance) {
         return null;
@@ -81,11 +85,11 @@ export default class Component {
         // Override in subclasses if needed
     }
 
-    addedToNode(node: any): void {
+    addedToNode(node: Node): void {
         // Override in subclasses if needed
     }
 
-    removedFromNode(node: any): void {
+    removedFromNode(node: Node): void {
         // Override in subclasses if needed
     }
 
@@ -159,15 +163,15 @@ export default class Component {
     // draw(renderQueue: any, modelMatrix: any): void {}
 
     // Event callbacks
-    keyDown(evt: any): void {}
-    keyUp(evt: any): void {}
-    mouseUp(evt: any): void {}
-    mouseDown(evt: any): void {}
-    mouseMove(evt: any): void {}
-    mouseOut(evt: any): void {}
-    mouseDrag(evt: any): void {}
-    mouseWheel(evt: any): void {}
-    touchStart(evt: any): void {}
-    touchMove(evt: any): void {}
-    touchEnd(evt: any): void {}
+    keyDown(evt: Bg2KeyboardEvent): void {}
+    keyUp(evt: Bg2KeyboardEvent): void {}
+    mouseUp(evt: Bg2MouseEvent): void {}
+    mouseDown(evt: Bg2MouseEvent): void {}
+    mouseMove(evt: Bg2MouseEvent): void {}
+    mouseOut(evt: Bg2MouseEvent): void {}
+    mouseDrag(evt: Bg2MouseEvent): void {}
+    mouseWheel(evt: Bg2MouseEvent): void {}
+    touchStart(evt: Bg2TouchEvent): void {}
+    touchMove(evt: Bg2TouchEvent): void {}
+    touchEnd(evt: Bg2TouchEvent): void {}
 }

package/src/scene/Node.ts

@@ -35,6 +35,8 @@ export default class Node {
     private _bindedRenderer?: Renderer;
     private _sceneChanged: boolean = false;
 
+    private _postRedisplayFrames: number = 0;
+
     constructor(name: string = "") {
         this._name = name;
         this._enabled = true;
@@ -217,6 +219,18 @@ export default class Node {
             }
         }
     }
+
+    // Used by components to require a redraw of the scene for a certain number of frames.
+    // This is needed, for example, when a component changes the material of a drawable,
+    // so the change is reflected inmediately in the screen, or when a component generates
+    // an animation that needs to be updated for a certain number of frames.
+    get postRedisplayFrames(): number {
+        return this._postRedisplayFrames;
+    }
+
+    set postRedisplayFrames(frames: number) {
+        this._postRedisplayFrames = frames;
+    }
     
     // Most usual components
     get transform(): Transform | undefined {