frontend/screens deleted

src/engine.cpp

@@ -12,7 +12,8 @@
 #include "files/files.h"
 #include "frontend/locale/langs.h"
 #include "frontend/menu.hpp"
-#include "frontend/screens.h"
+#include "frontend/screens/Screen.hpp"
+#include "frontend/screens/MenuScreen.hpp"
 #include "graphics/core/Batch2D.h"
 #include "graphics/core/GfxContext.h"
 #include "graphics/core/ImageData.h"

src/frontend/hud.cpp

@@ -43,7 +43,6 @@
 #include "InventoryView.h"
 #include "LevelFrontend.h"
 #include "menu.hpp"
-#include "screens.h"
 #include "UiDocument.h"
 
 #include <assert.h>

src/frontend/screens.h

@@ -1,63 +0,0 @@
-#ifndef FRONTEND_SCREENS_H_
-#define FRONTEND_SCREENS_H_
-
-#include <memory>
-#include "../settings.h"
-#include "../util/ObjectsKeeper.hpp"
-
-class Assets;
-class Level;
-class WorldRenderer;
-class Hud;
-class Engine;
-class Camera;
-class Batch2D;
-class LevelFrontend;
-class LevelController;
-class TextureAnimator;
-
-/// @brief Screen is a mainloop state
-class Screen : public util::ObjectsKeeper {
-protected:
-    Engine* engine;
-    std::unique_ptr<Batch2D> batch;
-public:
-    Screen(Engine* engine);
-    virtual ~Screen();
-    virtual void update(float delta) = 0;
-    virtual void draw(float delta) = 0;
-    virtual void onEngineShutdown() {};
-};
-
-class MenuScreen : public Screen {
-    std::unique_ptr<Camera> uicamera;
-public:
-    MenuScreen(Engine* engine);
-    ~MenuScreen();
-
-    void update(float delta) override;
-    void draw(float delta) override;
-};
-
-class LevelScreen : public Screen {
-    std::unique_ptr<LevelFrontend> frontend;
-    std::unique_ptr<Hud> hud;
-    std::unique_ptr<LevelController> controller;
-    std::unique_ptr<WorldRenderer> worldRenderer;
-    std::unique_ptr<TextureAnimator> animator;
-
-    bool hudVisible = true;
-    void updateHotkeys();
-public:
-    LevelScreen(Engine* engine, Level* level);
-    ~LevelScreen();
-
-    void update(float delta) override;
-    void draw(float delta) override;
-
-    void onEngineShutdown() override;
-
-    LevelController* getLevelController() const;
-};
-
-#endif // FRONTEND_SCREENS_H_

src/frontend/screens/LevelScreen.cpp

@@ -1,195 +1,128 @@
-#include "screens.h"
+#include "LevelScreen.hpp"
-
+
-#include "../assets/Assets.h"
+#include "../hud.h"
-#include "../audio/audio.h"
+#include "../LevelFrontend.h"
-#include "../content/Content.h"
+#include "../../audio/audio.h"
-#include "../core_defs.h"
+#include "../../graphics/core/GfxContext.h"
-#include "../engine.h"
+#include "../../graphics/core/Viewport.h"
-#include "../graphics/core/Batch2D.h"
+#include "../../graphics/ui/GUI.h"
-#include "../graphics/core/GfxContext.h"
+#include "../../graphics/ui/elements/Menu.hpp"
-#include "../graphics/core/Shader.h"
+#include "../../graphics/render/WorldRenderer.h"
-#include "../graphics/core/TextureAnimation.h"
+#include "../../logic/LevelController.h"
-#include "../graphics/render/WorldRenderer.h"
+#include "../../logic/scripting/scripting_hud.h"
-#include "../graphics/ui/elements/Menu.hpp"
+#include "../../physics/Hitbox.h"
-#include "../graphics/ui/GUI.h"
+#include "../../voxels/Chunks.h"
-#include "../logic/ChunksController.h"
+#include "../../world/Level.h"
-#include "../logic/LevelController.h"
+#include "../../world/World.h"
-#include "../logic/scripting/scripting_hud.h"
+#include "../../window/Camera.h"
-#include "../logic/scripting/scripting.h"
+#include "../../window/Events.h"
-#include "../objects/Player.h"
+#include "../../engine.h"
-#include "../physics/Hitbox.h"
+
-#include "../util/stringutil.h"
+LevelScreen::LevelScreen(Engine* engine, Level* level) : Screen(engine) {
-#include "../voxels/Block.h"
+    auto& settings = engine->getSettings();
-#include "../voxels/Chunk.h"
+    auto assets = engine->getAssets();
-#include "../voxels/Chunks.h"
+    auto menu = engine->getGUI()->getMenu();
-#include "../window/Camera.h"
+    menu->reset();
-#include "../window/Events.h"
+
-#include "../window/input.h"
+    controller = std::make_unique<LevelController>(settings, level);
-#include "../world/Level.h"
+    frontend = std::make_unique<LevelFrontend>(controller.get(), assets);
-#include "../world/World.h"
+
-
+    worldRenderer = std::make_unique<WorldRenderer>(engine, frontend.get(), controller->getPlayer());
-#include "ContentGfxCache.h"
+    hud = std::make_unique<Hud>(engine, frontend.get(), controller->getPlayer());
-#include "hud.h"
+    
-#include "LevelFrontend.h"
+    keepAlive(settings.graphics.backlight.observe([=](bool flag) {
-#include "menu.hpp"
+        controller->getLevel()->chunks->saveAndClear();
-
+    }));
-#include <filesystem>
+    keepAlive(settings.camera.fov.observe([=](double value) {
-#include <glm/glm.hpp>
+        controller->getPlayer()->camera->setFov(glm::radians(value));
-#include <iomanip>
+    }));
-#include <iostream>
+
-#include <memory>
+    animator = std::make_unique<TextureAnimator>();
-#include <sstream>
+    animator->addAnimations(assets->getAnimations());
-#include <stdexcept>
+
-
+    auto content = level->content;
-Screen::Screen(Engine* engine) : engine(engine), batch(new Batch2D(1024)) {
+    for (auto& entry : content->getPacks()) {
-}
+        auto pack = entry.second.get();
-
+        const ContentPack& info = pack->getInfo();
-Screen::~Screen() {
+        fs::path scriptFile = info.folder/fs::path("scripts/hud.lua");
-}
+        if (fs::is_regular_file(scriptFile)) {
-
+            scripting::load_hud_script(pack->getEnvironment(), info.id, scriptFile);
-MenuScreen::MenuScreen(Engine* engine_) : Screen(engine_) {
+        }
-    auto menu = engine->getGUI()->getMenu();
+    }
-    menu->reset();
+    scripting::on_frontend_init(hud.get());
-    menu->setPage("main");
+}
-
+
-    uicamera.reset(new Camera(glm::vec3(), Window::height));
+LevelScreen::~LevelScreen() {
-    uicamera->perspective = false;
+    scripting::on_frontend_close();
-    uicamera->flipped = true;
+    controller->onWorldQuit();
-}
+    engine->getPaths()->setWorldFolder(fs::path());
-
+}
-MenuScreen::~MenuScreen() {
+
-}
+void LevelScreen::updateHotkeys() {
-
+    auto& settings = engine->getSettings();
-void MenuScreen::update(float delta) {
+    if (Events::jpressed(keycode::O)) {
-}
+        settings.graphics.frustumCulling = !settings.graphics.frustumCulling;
-
+    }
-void MenuScreen::draw(float delta) {
+    if (Events::jpressed(keycode::F1)) {
-    Window::clear();
+        hudVisible = !hudVisible;
-    Window::setBgColor(glm::vec3(0.2f));
+    }
-
+    if (Events::jpressed(keycode::F3)) {
-    uicamera->setFov(Window::height);
+        controller->getPlayer()->debug = !controller->getPlayer()->debug;
-    Shader* uishader = engine->getAssets()->getShader("ui");
+    }
-    uishader->use();
+    if (Events::jpressed(keycode::F5)) {
-    uishader->uniformMatrix("u_projview", uicamera->getProjView());
+        controller->getLevel()->chunks->saveAndClear();
-
+    }
-    uint width = Window::width;
+}
-    uint height = Window::height;
+
-
+void LevelScreen::update(float delta) {
-    batch->begin();
+    gui::GUI* gui = engine->getGUI();
-    batch->texture(engine->getAssets()->getTexture("gui/menubg"));
+    
-    batch->rect(
+    bool inputLocked = hud->isPause() || 
-        0, 0, 
+                       hud->isInventoryOpen() || 
-        width, height, 0, 0, 0, 
+                       gui->isFocusCaught();
-        UVRegion(0, 0, width/64, height/64), 
+    if (!gui->isFocusCaught()) {
-        false, false, glm::vec4(1.0f)
+        updateHotkeys();
-    );
+    }
-    batch->flush();
+
-}
+    auto player = controller->getPlayer();
-
+    auto camera = player->camera;
-LevelScreen::LevelScreen(Engine* engine, Level* level) : Screen(engine) {
+
-    auto& settings = engine->getSettings();
+    bool paused = hud->isPause();
-    auto assets = engine->getAssets();
+    audio::get_channel("regular")->setPaused(paused);
-    auto menu = engine->getGUI()->getMenu();
+    audio::get_channel("ambient")->setPaused(paused);
-    menu->reset();
+    audio::set_listener(
-
+        camera->position-camera->dir, 
-    controller = std::make_unique<LevelController>(settings, level);
+        player->hitbox->velocity,
-    frontend = std::make_unique<LevelFrontend>(controller.get(), assets);
+        camera->dir, 
-
+        camera->up
-    worldRenderer = std::make_unique<WorldRenderer>(engine, frontend.get(), controller->getPlayer());
+    );
-    hud = std::make_unique<Hud>(engine, frontend.get(), controller->getPlayer());
+
-    
+    if (!hud->isPause()) {
-    keepAlive(settings.graphics.backlight.observe([=](bool flag) {
+        controller->getLevel()->getWorld()->updateTimers(delta);
-        controller->getLevel()->chunks->saveAndClear();
+        animator->update(delta);
-    }));
+    }
-    keepAlive(settings.camera.fov.observe([=](double value) {
+    controller->update(delta, !inputLocked, hud->isPause());
-        controller->getPlayer()->camera->setFov(glm::radians(value));
+    hud->update(hudVisible);
-    }));
+}
-
+
-    animator = std::make_unique<TextureAnimator>();
+void LevelScreen::draw(float delta) {
-    animator->addAnimations(assets->getAnimations());
+    auto camera = controller->getPlayer()->currentCamera;
-
+
-    auto content = level->content;
+    Viewport viewport(Window::width, Window::height);
-    for (auto& entry : content->getPacks()) {
+    GfxContext ctx(nullptr, viewport, batch.get());
-        auto pack = entry.second.get();
+
-        const ContentPack& info = pack->getInfo();
+    worldRenderer->draw(ctx, camera.get(), hudVisible);
-        fs::path scriptFile = info.folder/fs::path("scripts/hud.lua");
+
-        if (fs::is_regular_file(scriptFile)) {
+    if (hudVisible) {
-            scripting::load_hud_script(pack->getEnvironment(), info.id, scriptFile);
+        hud->draw(ctx);
-        }
+    }
-    }
+}
-    scripting::on_frontend_init(hud.get());
+
-}
+void LevelScreen::onEngineShutdown() {
-
+    controller->saveWorld();
-LevelScreen::~LevelScreen() {
+}
-    scripting::on_frontend_close();
+
-    controller->onWorldQuit();
+LevelController* LevelScreen::getLevelController() const {
-    engine->getPaths()->setWorldFolder(fs::path());
+    return controller.get();
-}
+}
-
+
-void LevelScreen::updateHotkeys() {
-    auto& settings = engine->getSettings();
-    if (Events::jpressed(keycode::O)) {
-        settings.graphics.frustumCulling = !settings.graphics.frustumCulling;
-    }
-    if (Events::jpressed(keycode::F1)) {
-        hudVisible = !hudVisible;
-    }
-    if (Events::jpressed(keycode::F3)) {
-        controller->getPlayer()->debug = !controller->getPlayer()->debug;
-    }
-    if (Events::jpressed(keycode::F5)) {
-        controller->getLevel()->chunks->saveAndClear();
-    }
-}
-
-void LevelScreen::update(float delta) {
-    gui::GUI* gui = engine->getGUI();
-    
-    bool inputLocked = hud->isPause() || 
-                       hud->isInventoryOpen() || 
-                       gui->isFocusCaught();
-    if (!gui->isFocusCaught()) {
-        updateHotkeys();
-    }
-
-    auto player = controller->getPlayer();
-    auto camera = player->camera;
-
-    bool paused = hud->isPause();
-    audio::get_channel("regular")->setPaused(paused);
-    audio::get_channel("ambient")->setPaused(paused);
-    audio::set_listener(
-        camera->position-camera->dir, 
-        player->hitbox->velocity,
-        camera->dir, 
-        camera->up
-    );
-
-    if (!hud->isPause()) {
-        controller->getLevel()->getWorld()->updateTimers(delta);
-        animator->update(delta);
-    }
-    controller->update(delta, !inputLocked, hud->isPause());
-    hud->update(hudVisible);
-}
-
-void LevelScreen::draw(float delta) {
-    auto camera = controller->getPlayer()->currentCamera;
-
-    Viewport viewport(Window::width, Window::height);
-    GfxContext ctx(nullptr, viewport, batch.get());
-
-    worldRenderer->draw(ctx, camera.get(), hudVisible);
-
-    if (hudVisible) {
-        hud->draw(ctx);
-    }
-}
-
-void LevelScreen::onEngineShutdown() {
-    controller->saveWorld();
-}
-
-LevelController* LevelScreen::getLevelController() const {
-    return controller.get();
-}

src/frontend/screens/LevelScreen.hpp

@@ -0,0 +1,37 @@
+#ifndef FRONTEND_SCREENS_LEVEL_SCREEN_HPP_
+#define FRONTEND_SCREENS_LEVEL_SCREEN_HPP_
+
+#include "Screen.hpp"
+
+#include <memory>
+
+class Engine;
+class LevelFrontend;
+class Hud;
+class LevelController;
+class WorldRenderer;
+class TextureAnimator;
+class Level;
+
+class LevelScreen : public Screen {
+    std::unique_ptr<LevelFrontend> frontend;
+    std::unique_ptr<Hud> hud;
+    std::unique_ptr<LevelController> controller;
+    std::unique_ptr<WorldRenderer> worldRenderer;
+    std::unique_ptr<TextureAnimator> animator;
+
+    bool hudVisible = true;
+    void updateHotkeys();
+public:
+    LevelScreen(Engine* engine, Level* level);
+    ~LevelScreen();
+
+    void update(float delta) override;
+    void draw(float delta) override;
+
+    void onEngineShutdown() override;
+
+    LevelController* getLevelController() const;
+};
+
+#endif // FRONTEND_SCREENS_LEVEL_SCREEN_HPP_

src/frontend/screens/MenuScreen.cpp

@@ -0,0 +1,48 @@
+#include "MenuScreen.hpp"
+
+#include "../../graphics/ui/GUI.h"
+#include "../../graphics/ui/elements/Menu.hpp"
+#include "../../graphics/core/Batch2D.h"
+#include "../../graphics/core/Shader.h"
+#include "../../window/Window.h"
+#include "../../window/Camera.h"
+#include "../../engine.h"
+
+MenuScreen::MenuScreen(Engine* engine_) : Screen(engine_) {
+    auto menu = engine->getGUI()->getMenu();
+    menu->reset();
+    menu->setPage("main");
+
+    uicamera.reset(new Camera(glm::vec3(), Window::height));
+    uicamera->perspective = false;
+    uicamera->flipped = true;
+}
+
+MenuScreen::~MenuScreen() {
+}
+
+void MenuScreen::update(float delta) {
+}
+
+void MenuScreen::draw(float delta) {
+    Window::clear();
+    Window::setBgColor(glm::vec3(0.2f));
+
+    uicamera->setFov(Window::height);
+    Shader* uishader = engine->getAssets()->getShader("ui");
+    uishader->use();
+    uishader->uniformMatrix("u_projview", uicamera->getProjView());
+
+    uint width = Window::width;
+    uint height = Window::height;
+
+    batch->begin();
+    batch->texture(engine->getAssets()->getTexture("gui/menubg"));
+    batch->rect(
+        0, 0, 
+        width, height, 0, 0, 0, 
+        UVRegion(0, 0, width/64, height/64), 
+        false, false, glm::vec4(1.0f)
+    );
+    batch->flush();
+}

src/frontend/screens/MenuScreen.hpp

@@ -0,0 +1,22 @@
+#ifndef FRONTEND_SCREENS_MENU_SCREEN_HPP_
+#define FRONTEND_SCREENS_MENU_SCREEN_HPP_
+
+#include "Screen.hpp"
+
+#include <memory>
+
+class Camera;
+class Engine;
+
+class MenuScreen : public Screen {
+    std::unique_ptr<Camera> uicamera;
+public:
+    MenuScreen(Engine* engine);
+    ~MenuScreen();
+
+    void update(float delta) override;
+    void draw(float delta) override;
+};
+
+
+#endif // FRONTEND_SCREENS_MENU_SCREEN_HPP_

src/frontend/screens/Screen.cpp

@@ -0,0 +1,10 @@
+#include "Screen.hpp"
+
+#include "../../graphics/core/Batch2D.h"
+#include "../../engine.h"
+
+Screen::Screen(Engine* engine) : engine(engine), batch(new Batch2D(1024)) {
+}
+
+Screen::~Screen() {
+}

src/frontend/screens/Screen.hpp

@@ -0,0 +1,22 @@
+#ifndef FRONTEND_SCREENS_SCREEN_HPP_
+#define FRONTEND_SCREENS_SCREEN_HPP_
+
+#include "../../util/ObjectsKeeper.hpp"
+
+class Engine;
+class Batch2D;
+
+/// @brief Screen is a mainloop state
+class Screen : public util::ObjectsKeeper {
+protected:
+    Engine* engine;
+    std::unique_ptr<Batch2D> batch;
+public:
+    Screen(Engine* engine);
+    virtual ~Screen();
+    virtual void update(float delta) = 0;
+    virtual void draw(float delta) = 0;
+    virtual void onEngineShutdown() {};
+};
+
+#endif // FRONTEND_SCREENS_SCREEN_HPP_

src/logic/EngineController.cpp

@@ -6,7 +6,8 @@
 #include "../files/WorldFiles.h"
 #include "../files/WorldConverter.h"
 #include "../frontend/locale/langs.h"
-#include "../frontend/screens.h"
+#include "../frontend/screens/MenuScreen.hpp"
+#include "../frontend/screens/LevelScreen.hpp"
 #include "../frontend/menu.hpp"
 #include "../graphics/ui/elements/Label.hpp"
 #include "../graphics/ui/elements/Button.hpp"

src/logic/scripting/lua/libcore.cpp

@@ -4,7 +4,7 @@
 #include "../../../engine.h"
 #include "../../../files/engine_paths.h"
 #include "../../../frontend/menu.hpp"
-#include "../../../frontend/screens.h"
+#include "../../../frontend/screens/MenuScreen.hpp"
 #include "../../../logic/LevelController.h"
 #include "../../../logic/EngineController.hpp"
 #include "../../../window/Events.h"