One step closer to multiplayer

2024-03-03 15:11:52 +03:00
parent e0daa4d1b9
commit 91a4b16796
26 changed files with 213 additions and 219 deletions
@@ -34,9 +34,10 @@
 #include "graphics/Skybox.h"
 #include "graphics/ChunksRenderer.h"

-WorldRenderer::WorldRenderer(Engine* engine, LevelFrontend* frontend) 
+WorldRenderer::WorldRenderer(Engine* engine, LevelFrontend* frontend, Player* player) 
    : engine(engine), 
-      level(frontend->getLevel())
+      level(frontend->getLevel()),
+      player(player)
 {
    frustumCulling = std::make_unique<Frustum>();
    lineBatch = std::make_unique<LineBatch>();
@@ -174,7 +175,6 @@ void WorldRenderer::draw(const GfxContext& pctx, Camera* camera, bool hudVisible
        shader->uniform3f("u_cameraPos", camera->position);
        shader->uniform1i("u_cubemap", 1);
        {
-            auto player = level->player;
            auto inventory = player->getInventory();
            ItemStack& stack = inventory->getSlot(player->getChosenSlot());
            ItemDef* item = indices->getItemDef(stack.getItemId());
@@ -191,7 +191,7 @@ void WorldRenderer::draw(const GfxContext& pctx, Camera* camera, bool hudVisible
        skybox->bind();
        atlas->getTexture()->bind();

-        drawChunks(level->chunks, camera, shader);
+        drawChunks(level->chunks.get(), camera, shader);

        // Selected block
        if (PlayerController::selectedBlockId != -1 && hudVisible){
@@ -213,7 +213,7 @@ void WorldRenderer::draw(const GfxContext& pctx, Camera* camera, bool hudVisible
                const glm::vec3 center = pos + hitbox.center();
                const glm::vec3 size = hitbox.size();
                lineBatch->box(center, size + glm::vec3(0.02), glm::vec4(0.f, 0.f, 0.f, 0.5f));
-                if (level->player->debug) {
+                if (player->debug) {
                    lineBatch->line(point, point+norm*0.5f, glm::vec4(1.0f, 0.0f, 1.0f, 1.0f));
                }
            }
@@ -222,7 +222,7 @@ void WorldRenderer::draw(const GfxContext& pctx, Camera* camera, bool hudVisible
        skybox->unbind();
    }

-    if (hudVisible && level->player->debug) {
+    if (hudVisible && player->debug) {
        GfxContext ctx = pctx.sub();
        ctx.depthTest(true);

@@ -230,7 +230,7 @@ void WorldRenderer::draw(const GfxContext& pctx, Camera* camera, bool hudVisible

        if (settings.debug.showChunkBorders){
            linesShader->uniformMatrix("u_projview", camera->getProjView());
-            glm::vec3 coord = level->player->camera->position;
+            glm::vec3 coord = player->camera->position;
            if (coord.x < 0) coord.x--;
            if (coord.z < 0) coord.z--;
            int cx = floordiv((int)coord.x, CHUNK_W);
@@ -14,6 +14,7 @@
 #include "../graphics/GfxContext.h"

 class Level;
+class Player;
 class Camera;
 class Batch3D;
 class LineBatch;
@@ -29,6 +30,7 @@ class Skybox;
 class WorldRenderer {
    Engine* engine;
    Level* level;
+    Player* player;
    std::unique_ptr<Frustum> frustumCulling;
    std::unique_ptr<LineBatch> lineBatch;
    std::unique_ptr<ChunksRenderer> renderer;
@@ -37,7 +39,7 @@ class WorldRenderer {
    bool drawChunk(size_t index, Camera* camera, Shader* shader, bool culling);
    void drawChunks(Chunks* chunks, Camera* camera, Shader* shader);
 public:
-    WorldRenderer(Engine* engine, LevelFrontend* frontend);
+    WorldRenderer(Engine* engine, LevelFrontend* frontend, Player* player);
    ~WorldRenderer();

    void draw(const GfxContext& context, Camera* camera, bool hudVisible);
@@ -84,14 +84,14 @@ void ChunksRenderer::threadLoop(int index) {
 }

 void ChunksRenderer::process(std::shared_ptr<Chunk> chunk, BlocksRenderer& renderer) {
-    renderer.build(chunk.get(), level->chunksStorage);
+    renderer.build(chunk.get(), level->chunksStorage.get());
 }

 std::shared_ptr<Mesh> ChunksRenderer::render(std::shared_ptr<Chunk> chunk, bool important) {
 	chunk->setModified(false);

    if (important) {
-        Mesh* mesh = renderer->render(chunk.get(), level->chunksStorage);
+        Mesh* mesh = renderer->render(chunk.get(), level->chunksStorage.get());
        auto sptr = std::shared_ptr<Mesh>(mesh);
        meshes[glm::ivec2(chunk->x, chunk->z)] = sptr;
        return sptr;
@@ -40,6 +40,7 @@
 #include "gui/UINode.h"
 #include "gui/GUI.h"
 #include "ContentGfxCache.h"
+#include "menu/menu.h"
 #include "screens.h"
 #include "WorldRenderer.h"
 #include "BlocksPreview.h"
@@ -122,11 +123,10 @@ std::shared_ptr<UINode> Hud::createDebugPanel(Engine* engine) {
               L" visible: "+std::to_wstring(level->chunks->visible);
    }));
    panel->add(create_label([=](){
-        auto player = level->player;
        auto* indices = level->content->getIndices();
        auto def = indices->getBlockDef(player->selectedVoxel.id);
        std::wstringstream stream;
-        stream << std::hex << level->player->selectedVoxel.states;
+        stream << std::hex << player->selectedVoxel.states;
        if (def) {
            stream << L" (" << util::str2wstr_utf8(def->name) << L")";
        }
@@ -151,19 +151,19 @@ std::shared_ptr<UINode> Hud::createDebugPanel(Engine* engine) {
        // Coord input
        auto box = std::make_shared<TextBox>(L"");
        box->setTextSupplier([=]() {
-            Hitbox* hitbox = level->player->hitbox.get();
+            Hitbox* hitbox = player->hitbox.get();
            return util::to_wstring(hitbox->position[ax], 2);
        });
        box->setTextConsumer([=](std::wstring text) {
            try {
-                glm::vec3 position = level->player->hitbox->position;
+                glm::vec3 position = player->hitbox->position;
                position[ax] = std::stoi(text);
-                level->player->teleport(position);
+                player->teleport(position);
            } catch (std::invalid_argument& _){
            }
        });
        box->setOnEditStart([=](){
-            Hitbox* hitbox = level->player->hitbox.get();
+            Hitbox* hitbox = player->hitbox.get();
            box->setText(std::to_wstring(int(hitbox->position[ax])));
        });
        box->setSize(glm::vec2(230, 27));
@@ -212,7 +212,6 @@ std::shared_ptr<InventoryView> Hud::createContentAccess() {
    auto level = frontend->getLevel();
    auto content = level->content;
    auto indices = content->getIndices();
-    auto player = level->player;
    auto inventory = player->getInventory();
    
    int itemsCount = indices->countItemDefs();
@@ -239,8 +238,6 @@ std::shared_ptr<InventoryView> Hud::createContentAccess() {
 }

 std::shared_ptr<InventoryView> Hud::createHotbar() {
-    auto level = frontend->getLevel();
-    auto player = level->player;
    auto inventory = player->getInventory();

    SlotLayout slotLayout(-1, glm::vec2(), false, false, nullptr, nullptr);
@@ -254,10 +251,12 @@ std::shared_ptr<InventoryView> Hud::createHotbar() {
    return view;
 }

-Hud::Hud(Engine* engine, LevelFrontend* frontend) 
-    : assets(engine->getAssets()), 
+Hud::Hud(Engine* engine, LevelFrontend* frontend, Player* player) 
+    : engine(engine),
+      assets(engine->getAssets()), 
      gui(engine->getGUI()),
-      frontend(frontend)
+      frontend(frontend),
+      player(player)
 {
    auto menu = gui->getMenu();

@@ -335,7 +334,6 @@ void Hud::cleanup() {

 void Hud::update(bool visible) {
    auto level = frontend->getLevel();
-    auto player = level->player;
    auto menu = gui->getMenu();

    debugPanel->setVisible(player->debug && visible);
@@ -419,8 +417,6 @@ void Hud::update(bool visible) {
 * Show inventory on the screen and turn on inventory mode blocking movement
 */
 void Hud::openInventory() {
-    auto level = frontend->getLevel();
-    auto player = level->player;
    auto inventory = player->getInventory();

    inventoryOpen = true;
@@ -472,8 +468,6 @@ void Hud::openPermanent(UiDocument* doc) {

    auto invview = std::dynamic_pointer_cast<InventoryView>(root);
    if (invview) {
-        auto level = frontend->getLevel();
-        auto player = level->player;
        auto inventory = player->getInventory();
        invview->bind(inventory, frontend, interaction.get());
    }
@@ -548,9 +542,6 @@ void Hud::remove(std::shared_ptr<UINode> node) {
 }

 void Hud::draw(const GfxContext& ctx){
-    auto level = frontend->getLevel();
-    auto player = level->player;
-
    const Viewport& viewport = ctx.getViewport();
    const uint width = viewport.getWidth();
    const uint height = viewport.getHeight();
@@ -568,7 +559,7 @@ void Hud::draw(const GfxContext& ctx){
    hotbarView->setSelected(player->getChosenSlot());

    // Crosshair
-    if (!pause && Events::_cursor_locked && !level->player->debug) {
+    if (!pause && Events::_cursor_locked && !player->debug) {
        GfxContext chctx = ctx.sub();
        chctx.blendMode(blendmode::inversion);
        auto texture = assets->getTexture("gui/crosshair");
@@ -583,7 +574,7 @@ void Hud::draw(const GfxContext& ctx){
    }

    // Delta-time visualizer
-    if (level->player->debug) {
+    if (player->debug) {
        batch->texture(nullptr);
        const int dmwidth = 256;
        const float dmscale = 4000.0f;
@@ -648,6 +639,7 @@ void Hud::setPause(bool pause) {
    
    auto menu = gui->getMenu();
    if (pause) {
+        menus::create_pause_panel(engine, frontend->getLevel());
        menu->setPage("pause");
    } else {
        menu->reset();
@@ -656,6 +648,6 @@ void Hud::setPause(bool pause) {
    menu->setVisible(pause);
 }

-std::shared_ptr<Player> Hud::getPlayer() const {
-    return frontend->getLevel()->player;
+Player* Hud::getPlayer() const {
+    return player;
 }
@@ -65,6 +65,7 @@ public:
 };

 class Hud {
+    Engine* engine;
    Assets* assets;
 	std::unique_ptr<Camera> uicamera;

@@ -84,6 +85,7 @@ class Hud {
    std::shared_ptr<SlotView> grabbedItemView;
 	gui::GUI* gui;
 	LevelFrontend* frontend;
+    Player* player;

 	std::vector<HudElement> elements;

@@ -98,7 +100,7 @@ class Hud {

    void cleanup();
 public:
-	Hud(Engine* engine, LevelFrontend* frontend);
+	Hud(Engine* engine, LevelFrontend* frontend, Player* player);
 	~Hud();

 	void update(bool hudVisible);
@@ -118,7 +120,7 @@ public:
 	void remove(HudElement& element);
    void remove(std::shared_ptr<gui::UINode> node);

-    std::shared_ptr<Player> getPlayer() const;
+    Player* getPlayer() const;
 };

 #endif /* SRC_HUD_H_ */
@@ -19,4 +19,4 @@ namespace menus {
    void refresh_menus(Engine* engine);
 }

-#endif // FRONTEND_MENU_MENU_H_
+#endif // FRONTEND_MENU_MENU_H_
@@ -89,17 +89,15 @@ void MenuScreen::draw(float delta) {

 static bool backlight;

-LevelScreen::LevelScreen(Engine* engine, Level* level) : Screen(engine), level(level){
-    menus::create_pause_panel(engine, level);
-    
+LevelScreen::LevelScreen(Engine* engine, Level* level) : Screen(engine) {
    auto& settings = engine->getSettings();
    auto assets = engine->getAssets();

    controller = std::make_unique<LevelController>(settings, level);
    frontend = std::make_unique<LevelFrontend>(level, assets);
-    worldRenderer = std::make_unique<WorldRenderer>(engine, frontend.get());
-    hud = std::make_unique<Hud>(engine, frontend.get());
-    
+    worldRenderer = std::make_unique<WorldRenderer>(engine, frontend.get(), controller->getPlayer());
+    hud = std::make_unique<Hud>(engine, frontend.get(), controller->getPlayer());
+
    backlight = settings.graphics.backlight;

    animator = std::make_unique<TextureAnimator>();
@@ -121,8 +119,8 @@ LevelScreen::~LevelScreen() {
    std::cout << "-- writing world" << std::endl;
    scripting::on_frontend_close();
    controller->onWorldSave();
-    auto world = level->getWorld();
-    world->write(level.get());
+    auto world = controller->getLevel()->getWorld();
+    world->write(controller->getLevel());
    controller->onWorldQuit();
    engine->getPaths()->setWorldFolder(fs::path());
 }
@@ -136,10 +134,10 @@ void LevelScreen::updateHotkeys() {
        hudVisible = !hudVisible;
    }
    if (Events::jpressed(keycode::F3)) {
-        level->player->debug = !level->player->debug;
+        controller->getPlayer()->debug = !controller->getPlayer()->debug;
    }
    if (Events::jpressed(keycode::F5)) {
-        level->chunks->saveAndClear();
+        controller->getLevel()->chunks->saveAndClear();
    }
 }

@@ -163,14 +161,14 @@ void LevelScreen::update(float delta) {

    // TODO: subscribe for setting change
    EngineSettings& settings = engine->getSettings();
-    level->player->camera->setFov(glm::radians(settings.camera.fov));
+    controller->getPlayer()->camera->setFov(glm::radians(settings.camera.fov));
    if (settings.graphics.backlight != backlight) {
-        level->chunks->saveAndClear();
+        controller->getLevel()->chunks->saveAndClear();
        backlight = settings.graphics.backlight;
    }

    if (!hud->isPause()) {
-        level->world->updateTimers(delta);
+        controller->getLevel()->world->updateTimers(delta);
        animator->update(delta);
    }
    controller->update(delta, !inputLocked, hud->isPause());
@@ -178,7 +176,7 @@ void LevelScreen::update(float delta) {
 }

 void LevelScreen::draw(float delta) {
-    auto camera = level->player->currentCamera;
+    auto camera = controller->getPlayer()->currentCamera;

    Viewport viewport(Window::width, Window::height);
    GfxContext ctx(nullptr, viewport, batch.get());
@@ -187,12 +185,8 @@ void LevelScreen::draw(float delta) {

    if (hudVisible) {
        hud->draw(ctx);
-        if (level->player->debug) {
+        if (controller->getPlayer()->debug) {
            hud->drawDebug(1 / delta);
        }
    }
 }
-
-Level* LevelScreen::getLevel() const {
-    return level.get();
-}
@@ -38,7 +38,6 @@ public:
 };

 class LevelScreen : public Screen {
-    std::unique_ptr<Level> level;
    std::unique_ptr<LevelFrontend> frontend;
    std::unique_ptr<Hud> hud;
    std::unique_ptr<WorldRenderer> worldRenderer;
@@ -53,8 +52,6 @@ public:

    void update(float delta) override;
    void draw(float delta) override;
-
-    Level* getLevel() const;
 };

 #endif // FRONTEND_SCREENS_H_