add 'graphics.dense-render' setting

src/frontend/ContentGfxCache.cpp

@@ -6,53 +6,71 @@
 #include "assets/Assets.hpp"
 #include "content/Content.hpp"
 #include "content/ContentPack.hpp"
-#include "core_defs.hpp"
 #include "graphics/core/Atlas.hpp"
 #include "maths/UVRegion.hpp"
 #include "voxels/Block.hpp"
+#include "core_defs.hpp"
+#include "settings.hpp"
 
-ContentGfxCache::ContentGfxCache(const Content* content, const Assets& assets)
-    : content(content) {
-    auto indices = content->getIndices();
+
+ContentGfxCache::ContentGfxCache(
+    const Content& content,
+    const Assets& assets,
+    const GraphicsSettings& settings
+)
+    : content(content), assets(assets), settings(settings) {
+    refresh();
+}
+
+void ContentGfxCache::refresh(const Block& def, const Atlas& atlas) {
+    for (uint side = 0; side < 6; side++) {
+        std::string tex = def.textureFaces[side];
+        if (def.culling == CullingMode::OPTIONAL &&
+            !settings.denseRender.get() && atlas.has(tex + "_opaque")) {
+            tex = tex + "_opaque";
+        }
+        if (atlas.has(tex)) {
+            sideregions[def.rt.id * 6 + side] = atlas.get(tex);
+        } else if (atlas.has(TEXTURE_NOTFOUND)) {
+            sideregions[def.rt.id * 6 + side] = atlas.get(TEXTURE_NOTFOUND);
+        }
+    }
+    if (def.model == BlockModel::custom) {
+        auto model = assets.require<model::Model>(def.modelName);
+        // temporary dirty fix tbh
+        if (def.modelName.find(':') == std::string::npos) {
+            for (auto& mesh : model.meshes) {
+                size_t pos = mesh.texture.find(':');
+                if (pos == std::string::npos) {
+                    continue;
+                }
+                if (auto region = atlas.getIf(mesh.texture.substr(pos+1))) {
+                    for (auto& vertex : mesh.vertices) {
+                        vertex.uv = region->apply(vertex.uv);
+                    }
+                }
+            }
+        }
+        models[def.rt.id] = std::move(model);
+    }
+}
+
+void ContentGfxCache::refresh() {
+    auto indices = content.getIndices();
     sideregions = std::make_unique<UVRegion[]>(indices->blocks.count() * 6);
     const auto& atlas = assets.require<Atlas>("blocks");
 
     const auto& blocks = indices->blocks.getIterable();
     for (blockid_t i = 0; i < blocks.size(); i++) {
         auto def = blocks[i];
-        for (uint side = 0; side < 6; side++) {
-            const std::string& tex = def->textureFaces[side];
-            if (atlas.has(tex)) {
-                sideregions[i * 6 + side] = atlas.get(tex);
-            } else if (atlas.has(TEXTURE_NOTFOUND)) {
-                sideregions[i * 6 + side] = atlas.get(TEXTURE_NOTFOUND);
-            }
-        }
-        if (def->model == BlockModel::custom) {
-            auto model = assets.require<model::Model>(def->modelName);
-            // temporary dirty fix tbh
-            if (def->modelName.find(':') == std::string::npos) {
-                for (auto& mesh : model.meshes) {
-                    size_t pos = mesh.texture.find(':');
-                    if (pos == std::string::npos) {
-                        continue;
-                    }
-                    if (auto region = atlas.getIf(mesh.texture.substr(pos+1))) {
-                        for (auto& vertex : mesh.vertices) {
-                            vertex.uv = region->apply(vertex.uv);
-                        }
-                    }
-                }
-            }
-            models[def->rt.id] = std::move(model);
-        }
+        refresh(*def, atlas);
     }
 }
 
 ContentGfxCache::~ContentGfxCache() = default;
 
 const Content* ContentGfxCache::getContent() const {
-    return content;
+    return &content;
 }
 
 const model::Model& ContentGfxCache::getModel(blockid_t id) const {

src/frontend/ContentGfxCache.hpp

@@ -10,19 +10,29 @@
 
 class Content;
 class Assets;
+class Atlas;
+struct Block;
 struct UVRegion;
+struct GraphicsSettings;
 
 namespace model {
     struct Model;
 }
 
 class ContentGfxCache {
-    const Content* content;
+    const Content& content;
+    const Assets& assets;
+    const GraphicsSettings& settings;
+
     // array of block sides uv regions (6 per block)
     std::unique_ptr<UVRegion[]> sideregions;
     std::unordered_map<blockid_t, model::Model> models;
 public:
-    ContentGfxCache(const Content* content, const Assets& assets);
+    ContentGfxCache(
+        const Content& content,
+        const Assets& assets,
+        const GraphicsSettings& settings
+    );
     ~ContentGfxCache();
 
     inline const UVRegion& getRegion(blockid_t id, int side) const {
@@ -32,4 +42,8 @@ public:
     const model::Model& getModel(blockid_t id) const;
 
     const Content* getContent() const;
+
+    void refresh(const Block& block, const Atlas& atlas);
+
+    void refresh();
 };

src/frontend/LevelFrontend.cpp

@@ -14,12 +14,17 @@
 #include "world/Level.hpp"
 
 LevelFrontend::LevelFrontend(
-    Player* currentPlayer, LevelController* controller, Assets& assets
-) : level(*controller->getLevel()),
-    controller(controller),
-    assets(assets),
-    contentCache(std::make_unique<ContentGfxCache>(level.content, assets)) 
-{
+    Player* currentPlayer,
+    LevelController* controller,
+    Assets& assets,
+    const EngineSettings& settings
+)
+    : level(*controller->getLevel()),
+      controller(controller),
+      assets(assets),
+      contentCache(std::make_unique<ContentGfxCache>(
+          *level.content, assets, settings.graphics
+      )) {
     assets.store(
         BlocksPreview::build(
             *contentCache, assets, *level.content->getIndices()
@@ -98,6 +103,10 @@ const Assets& LevelFrontend::getAssets() const {
     return assets;
 }
 
+ContentGfxCache& LevelFrontend::getContentGfxCache() {
+    return *contentCache;
+}
+
 const ContentGfxCache& LevelFrontend::getContentGfxCache() const {
     return *contentCache;
 }

src/frontend/LevelFrontend.hpp

@@ -7,6 +7,7 @@ class Assets;
 class Player;
 class ContentGfxCache;
 class LevelController;
+struct EngineSettings;
 
 class LevelFrontend {
     Level& level;
@@ -14,12 +15,18 @@ class LevelFrontend {
     const Assets& assets;
     std::unique_ptr<ContentGfxCache> contentCache;
 public:
-    LevelFrontend(Player* currentPlayer, LevelController* controller, Assets& assets);
+    LevelFrontend(
+        Player* currentPlayer,
+        LevelController* controller,
+        Assets& assets,
+        const EngineSettings& settings
+    );
     ~LevelFrontend();
 
     Level& getLevel();
     const Level& getLevel() const;
     const Assets& getAssets() const;
     const ContentGfxCache& getContentGfxCache() const;
+    ContentGfxCache& getContentGfxCache();
     LevelController* getController() const;
 };

src/frontend/screens/LevelScreen.cpp

@@ -17,6 +17,7 @@
 #include "graphics/render/Decorator.hpp"
 #include "graphics/ui/elements/Menu.hpp"
 #include "graphics/ui/GUI.hpp"
+#include "frontend/ContentGfxCache.hpp"
 #include "logic/LevelController.hpp"
 #include "logic/scripting/scripting_hud.hpp"
 #include "util/stringutil.hpp"
@@ -42,7 +43,7 @@ LevelScreen::LevelScreen(Engine* engine, std::unique_ptr<Level> levelPtr)
 
     controller = std::make_unique<LevelController>(engine, std::move(levelPtr));
     frontend = std::make_unique<LevelFrontend>(
-        controller->getPlayer(), controller.get(), assets
+        controller->getPlayer(), controller.get(), assets, settings
     );
     worldRenderer = std::make_unique<WorldRenderer>(
         engine, *frontend, controller->getPlayer()
@@ -57,6 +58,11 @@ LevelScreen::LevelScreen(Engine* engine, std::unique_ptr<Level> levelPtr)
         controller->getLevel()->chunks->saveAndClear();
         worldRenderer->clear();
     }));
+    keepAlive(settings.graphics.denseRender.observe([=](bool) {
+        controller->getLevel()->chunks->saveAndClear();
+        worldRenderer->clear();
+        frontend->getContentGfxCache().refresh();
+    }));
     keepAlive(settings.camera.fov.observe([=](double value) {
         controller->getPlayer()->fpCamera->setFov(glm::radians(value));
     }));