Scene Interface!

* SceneManager class allows swapping between scenes easily.
* Scene interface to provide methods for the SceneManager to interact with scenes.
* GameInstance turned into GameScene (derived from Scene)

CMakeLists.txt

@@ -56,8 +56,8 @@ add_executable(zeus
         zeus/engine/helpers/ArrayTrans3D.h
         zeus/mesh/MeshChunk.cpp
         zeus/mesh/MeshChunk.h
-        zeus/game/GameInstance.cpp
-        zeus/game/GameInstance.h
+        zeus/game/GameScene.cpp
+        zeus/game/GameScene.h
         zeus/engine/graphics/Renderer.cpp
         zeus/engine/graphics/Renderer.h
         zeus/lua_api/LuaParser.cpp
@@ -78,6 +78,12 @@ add_executable(zeus
         zeus/lua_api/l_register_blockmodel.cpp
         zeus/lua_api/l_register_blockmodel.h
         zeus/lua_api/LuaApi.cpp
-        zeus/lua_api/LuaApi.h zeus/client/Client.cpp zeus/client/Client.h)
+        zeus/lua_api/LuaApi.h
+        zeus/client/Client.cpp
+        zeus/client/Client.h
+        zeus/client/SceneManager.cpp
+        zeus/client/SceneManager.h
+        zeus/client/Scene.h
+        zeus/client/ClientState.h)
 
 target_link_libraries(zeus ${OPENGL_gl_LIBRARY} glfw libGLEW.so pthread lua dl)

zeus/client/Client.cpp

@@ -3,6 +3,7 @@
 //
 
 #include "Client.h"
+#include "../game/GameScene.h"
 
 Client::Client() = default;
 
@@ -11,29 +12,35 @@ Client::Client(int width, int height) {
 }
 
 void Client::start() {
-    scene = new GameInstance();
-    scene->initialize(renderer);
+    state = new ClientState {
+            .renderer = renderer,
+            .fps = 0,
+            .deltaTime = 0
+    };
+
+    Scene* s = new GameScene(state);
+    sceneManager.setScene(s); //Main Menu Scene here eventually
 
     while (!renderer->getWindow()->getShouldClose()) loop();
 }
 
 void Client::loop() {
-    Timer t("Game Loop");
+    Timer t("Client Loop");
 
     double now = glfwGetTime();
-    double delta = now - timeElapsed;
+    state->deltaTime = now - timeElapsed;
     timeElapsed = now;
 
     glfwPollEvents();
 
-    scene->update(delta, fps);
-    scene->draw();
+    sceneManager.update();
 
-    fps = 1000 / (t.elapsedNs() / 1000000.0);
+    state->fps = 1000 / (t.elapsedNs() / 1000000.0);
 }
 
 void Client::cleanup() {
-    delete scene;
+    sceneManager.cleanupScene();
+    delete state;
     delete renderer;
 }
 

zeus/client/Client.h

@@ -5,8 +5,10 @@
 #ifndef ZEUS_CLIENT_H
 #define ZEUS_CLIENT_H
 
-#include "../game/GameInstance.h"
 #include "../engine/graphics/Renderer.h"
+#include "../engine/Timer.h"
+#include "SceneManager.h"
+#include "ClientState.h"
 
 class Client {
 public:
@@ -18,15 +20,15 @@ public:
     ~Client();
 
 private:
-    Renderer* renderer;
-    GameInstance* scene;
-
-    double fps = 0.0;
-
     void loop();
 
     void cleanup();
 
+    Renderer* renderer;
+
+    ClientState* state;
+    SceneManager sceneManager;
+
     double timeElapsed = 0.0f;
 };
 

zeus/client/ClientState.h

@@ -0,0 +1,19 @@
+//
+// Created by aurailus on 06/01/19.
+//
+
+#ifndef ZEUS_CLIENTSTATE_H
+#define ZEUS_CLIENTSTATE_H
+
+
+#include "../engine/graphics/Renderer.h"
+
+struct ClientState {
+    Renderer* renderer;
+
+    double fps;
+    double deltaTime;
+};
+
+
+#endif //ZEUS_CLIENTSTATE_H

zeus/client/Scene.h

@@ -0,0 +1,26 @@
+//
+// Created by aurailus on 06/01/19.
+//
+
+#ifndef ZEUS_SCENE_H
+#define ZEUS_SCENE_H
+
+#include "ClientState.h"
+
+class Scene {
+public:
+    explicit Scene(ClientState* state) {
+        this->state = state;
+    };
+
+    virtual void update() {};
+
+    virtual void draw() {};
+
+    virtual void cleanup() {};
+
+    ClientState* state;
+};
+
+
+#endif //ZEUS_SCENE_H

zeus/client/SceneManager.cpp

@@ -0,0 +1,31 @@
+//
+// Created by aurailus on 06/01/19.
+//
+
+#include "SceneManager.h"
+
+SceneManager::SceneManager() = default;
+
+void SceneManager::update() {
+    scene->update();
+    scene->draw();
+}
+
+void SceneManager::setScene(Scene* scene) {
+    if (this->scene != nullptr) cleanupScene();
+    this->scene = scene;
+}
+
+Scene* SceneManager::getScene() {
+    return scene;
+}
+
+void SceneManager::cleanupScene() {
+    scene->cleanup();
+    delete scene;
+    scene = nullptr;
+}
+
+SceneManager::~SceneManager() {
+    if (scene != nullptr) cleanupScene();
+}

zeus/client/SceneManager.h

@@ -0,0 +1,29 @@
+//
+// Created by aurailus on 06/01/19.
+//
+
+#ifndef ZEUS_SCENEMANAGER_H
+#define ZEUS_SCENEMANAGER_H
+
+
+#include "Scene.h"
+#include "ClientState.h"
+
+class SceneManager {
+public:
+    SceneManager();
+
+    void setScene(Scene* scene);
+    Scene* getScene();
+
+    void update();
+
+    void cleanupScene();
+
+    ~SceneManager();
+private:
+    Scene* scene;
+};
+
+
+#endif //ZEUS_SCENEMANAGER_H

zeus/game/GameScene.cpp

@@ -2,14 +2,11 @@
 // Created by aurailus on 17/12/18.
 //
 
-#include "GameInstance.h"
+#include "GameScene.h"
 #include "../lua_api/l_register_block.h"
 #include "../lua_api/l_register_blockmodel.h"
 
-GameInstance::GameInstance() = default;
-
-void GameInstance::initialize(Renderer* renderer) {
-    this->renderer = renderer;
+GameScene::GameScene(ClientState* state) : Scene(state) {
 
     textureAtlas = new TextureAtlas("../tex");
     blockAtlas = new BlockAtlas(textureAtlas);
@@ -36,7 +33,7 @@ void GameInstance::initialize(Renderer* renderer) {
     }
 
     player = new Player();
-    player->create(world, renderer->getCamera());
+    player->create(world, state->renderer->getCamera());
     player->setPos(glm::vec3(16, 24, 0));
 
     world->genNewChunk(glm::vec3(0, 0, 0));
@@ -66,8 +63,8 @@ void GameInstance::initialize(Renderer* renderer) {
     delete crossVerts;
     delete crossInds;
 
-    float xx = renderer->getWindow()->getBufferWidth()/2;
-    float yy = renderer->getWindow()->getBufferHeight()/2;
+    float xx = state->renderer->getWindow()->getBufferWidth()/2;
+    float yy = state->renderer->getWindow()->getBufferHeight()/2;
 
     crosshair->setPosition(glm::vec3(xx, yy, 0));
     crosshair->setScale(22);
@@ -75,13 +72,15 @@ void GameInstance::initialize(Renderer* renderer) {
     guiEntities.push_back(crosshair);
 }
 
-void GameInstance::update(double deltaTime, double fps) {
-    renderer->update();
 
-    auto camera = renderer->getCamera();
-    auto window = renderer->getWindow();
+void GameScene::update() {
+    state->renderer->update(); //TODO: Look into moving this to SceneManager or Client?
 
-    player->update(window->getKeysArray(), deltaTime, window->getDeltaX(), window->getDeltaY());
+    auto camera = state->renderer->getCamera();
+    auto window = state->renderer->getWindow();
+
+    //TODO: Change the deltaTime property to double
+    player->update(window->getKeysArray(), (GLfloat)state->deltaTime, window->getDeltaX(), window->getDeltaY());
 
     glm::vec3 round = World::roundVec(*camera->getPosition());
     round.y -= 2;
@@ -97,7 +96,7 @@ void GameInstance::update(double deltaTime, double fps) {
         auto found = world->getBlock(*ray.getEnd());
         if (found > 0) {
             block = found;
-            if (renderer->getWindow()->mouseIsDown()) {
+            if (state->renderer->getWindow()->mouseIsDown()) {
                 world->setBlock(*ray.getEnd(), 0);
             }
             break;
@@ -109,28 +108,28 @@ void GameInstance::update(double deltaTime, double fps) {
         look = blockAtlas->getBlock(block)->getIdentifier();
     }
 
-    gui.update(player->getPos(), player->getVel(), player->getYaw(), player->getPitch(), on, look, fps);
+    gui.update(player->getPos(), player->getVel(), player->getYaw(), player->getPitch(), on, look, state->fps);
 
     world->update();
 }
 
-void GameInstance::draw() {
+void GameScene::draw() {
     Timer t("Drawing");
 
-    renderer->begin();
+    state->renderer->begin();
 
-    renderer->enableWorldShader();
+    state->renderer->enableWorldShader();
     textureAtlas->getTexture()->use();
 
     for (auto &chunk : *world->getMeshChunks()) {
-        renderer->draw(chunk.second);
+        state->renderer->draw(chunk.second);
     }
 
     for (auto &entity : entities) {
-        renderer->draw(entity);
+        state->renderer->draw(entity);
     }
 
-    renderer->enableGuiShader();
+    state->renderer->enableGuiShader();
 
     Texture* prevTexture = nullptr;
 
@@ -140,8 +139,8 @@ void GameInstance::draw() {
             gui->getTexture()->use();
         }
 
-        renderer->drawGui(gui);
+        state->renderer->drawGui(gui);
     }
 
-    renderer->end();
-}
+    state->renderer->end();
+}

zeus/game/GameScene.h

@@ -17,22 +17,18 @@
 #include "gui/DebugGui.h"
 #include "world/Player.h"
 #include "../engine/Ray.h"
+#include "../client/Scene.h"
 
-class GameInstance {
+class GameScene : public Scene {
 public:
-    GameInstance();
+    GameScene(ClientState* state);
 
-    void initialize(Renderer* renderer);
+    void update() override;
 
-    void update(double deltaTime, double fps);
-
-    void draw();
+    void draw() override;
 public:
     Player* player;
 
-    //The renderer contains the camera, window, and draw methods.
-    Renderer* renderer;
-
     //The World object represents the physical game region that is played in. It handles chunk updates and entities.
     World* world;
 

zeus/lua_api/LuaApi.cpp

@@ -4,7 +4,7 @@
 
 #include "LuaApi.h"
 
-LuaApi::LuaApi(GameInstance *game, LuaParser *parser) {
+LuaApi::LuaApi(GameScene *game, LuaParser *parser) {
     this->game = game;
     this->parser = parser;
 }

zeus/lua_api/LuaApi.h

@@ -6,14 +6,14 @@
 #define ZEUS_LUAAPI_H
 
 
-#include "../game/GameInstance.h"
+#include "../game/GameScene.h"
 #include "LuaParser.h"
 
 class LuaApi {
 public:
-    LuaApi(GameInstance* game, LuaParser* parser);
+    LuaApi(GameScene* game, LuaParser* parser);
 
-    GameInstance* game;
+    GameScene* game;
     LuaParser* parser;
 };
 

zeus/lua_api/l_register_block.cpp

@@ -38,6 +38,6 @@ void l_register_block::api(std::string identifier, sol::table data) {
     game->blockAtlas->registerBlock(def);
 }
 
-l_register_block::l_register_block(GameInstance *game, LuaParser *parser) : LuaApi(game, parser) {
+l_register_block::l_register_block(GameScene *game, LuaParser *parser) : LuaApi(game, parser) {
     parser->getModule()->set_function("register_block", &l_register_block::api, this);
 }

zeus/lua_api/l_register_block.h

@@ -9,7 +9,7 @@
 
 class l_register_block : LuaApi {
 public:
-    l_register_block(GameInstance* game, LuaParser* parser);
+    l_register_block(GameScene* game, LuaParser* parser);
 
 private:
     void api(std::string identifer, sol::table data);

zeus/lua_api/l_register_blockmodel.cpp

@@ -32,7 +32,7 @@ void l_register_blockmodel::api(std::string identifier, sol::table data) {
 //    }
 }
 
-l_register_blockmodel::l_register_blockmodel(GameInstance* game, LuaParser* parser) : LuaApi(game, parser) {
+l_register_blockmodel::l_register_blockmodel(GameScene* game, LuaParser* parser) : LuaApi(game, parser) {
 
     auto registered_blockmodels = parser->getState()->create_table();
     (*parser->getModule())["registered_blockmodels"] = registered_blockmodels;

zeus/lua_api/l_register_blockmodel.h

@@ -9,7 +9,7 @@
 
 class l_register_blockmodel : LuaApi {
 public:
-    l_register_blockmodel(GameInstance* game, LuaParser* parser);
+    l_register_blockmodel(GameScene* game, LuaParser* parser);
 
 private:
     void api(std::string identifer, sol::table data);