Fixed bundle bugs.

ts/game/Game.ts

@@ -1,39 +1,74 @@
+import { Scene } from "../scene/Scene";
+
+type Time = {
+  delta:number;
+  current:number;
+  last:number;
+}
+
+export class Game {
+  public time:Time;
+  private scene:Scene|null;
 
-export abstract class Game {
   constructor() {
-    
+    this.time = { delta: 0, current: 0, last: 0 };
+    this.scene = null;
+  }
+
+  public setScene(scene:Scene) { this.scene = scene; }
+
+  private timeUpdate() {
+    this.time.delta = epochGetDelta();
+    this.time.current = epochGetCurrent();
+    this.time.last = epochGetLast();
   }
 
   init() {
-    print("init");
+    this.timeUpdate();
   }
 
   update() {
-    print("update");
+    this.timeUpdate();
+
+    if(this.scene) this.scene.update();
   }
 
   dispose() {
-    print("Disposed");
+    if(this.scene) this.scene.dispose();
   }
 }
 
+// Main Game Instance
 let GAME_MAIN:Game|null = null;
 
+/**
+ * Set the main game instance.
+ * @param game Game to become the main game instance.
+ */
 export const gameSetMain = (game:Game) => {
-  print("setting", game);
   GAME_MAIN = game;
 }
 
+/**
+ * Method that is invoked by C when the game needs to intialize.
+ */
 const init = () => {
-  if(!GAME_MAIN) return;
-  GAME_MAIN.init();
+  print("init");
+  // if(!GAME_MAIN) return;
+  // GAME_MAIN.init();
 }
 
+/**
+ * Method that is invoked by C every single frame.
+ */
 const update = () => {
   if(!GAME_MAIN) return;
   GAME_MAIN.update();
 }
 
+/**
+ * Method that is invoked by C when the game needs to stop and clean up.
+ */
 const dispose = () => {
   if(!GAME_MAIN) return;
   GAME_MAIN.dispose();

ts/main.ts

@@ -1,7 +1,49 @@
 import { Game, gameSetMain } from "./game/Game";
+import { Scene } from "./scene/Scene";
+
+class TestScene extends Scene {
+  private quad:Primitive;
+  private camera:Camera;
+  private shader:Shader;
+  private texture:Texture;
+
+  init() {
+    this.quad = primitiveCreate();
+    quadInit(this.quad, 0,
+      -1, -1, 0, 0,
+      1, 1, 1, 1
+    );
+
+    this.shader = shaderCreate();
+    assetShaderLoad(this.shader,
+      "shaders/textured.vert",
+      "shaders/textured.frag"
+    );
+
+    this.camera = cameraCreate();
+    cameraLookAt(this.camera, 3,3,3, 0,0,0);
+    cameraPerspective(this.camera, 45, 16/9, 0.01, 1000);
+
+    this.texture = textureCreate();
+    assetTextureLoad(this.texture, "test_texture.png");
+  }
+
+  update() {
+    shaderUse(this.shader);
+    shaderUseCamera(this.shader, this.camera);
+    shaderUsePosition(this.shader, 0,0,0,  0,this.game.time.current,0);
+    primitiveDraw(this.quad, 0, -1);
+  }
+
+  dispose() {
+  }
+}
 
 class MainGame extends Game {
-  
+  constructor() {
+    super();
+    this.setScene(new TestScene(this));
+  }
 }
 
 gameSetMain(new MainGame());

ts/scene/Scene.ts

@@ -0,0 +1,13 @@
+import { Game } from "../game/Game";
+
+export abstract class Scene {
+  public readonly game:Game;
+
+  constructor(game:Game) {
+    this.game = game;
+  }
+
+  abstract init():void;
+  abstract update():void;
+  abstract dispose():void;
+}