From db2108171cc42175e8661184b1bb6558c8612ab5 Mon Sep 17 00:00:00 2001
From: MihailRis <mexaruc@gmail.com>
Date: Sun, 21 Jan 2024 23:35:41 +0300
Subject: [PATCH] inventory render optimized

---
 src/constants.h                |   2 +
 src/frontend/BlocksPreview.cpp | 112 +++++++----
 src/frontend/BlocksPreview.h   |  24 +--
 src/frontend/InventoryView.cpp |  29 +--
 src/frontend/InventoryView.h   |   3 +-
 src/frontend/LevelFrontend.cpp |  12 +-
 src/frontend/LevelFrontend.h   |   5 +-
 src/frontend/hud.cpp           | 340 ++++++++++++++++-----------------
 src/graphics/Framebuffer.cpp   |   6 +-
 src/graphics/Framebuffer.h     |   2 +-
 src/window/Window.cpp          |   4 +
 src/window/Window.h            |   1 +
 12 files changed, 285 insertions(+), 255 deletions(-)

diff --git a/src/constants.h b/src/constants.h
index dd5e56e0..f9cc1d4b 100644
--- a/src/constants.h
+++ b/src/constants.h
@@ -17,6 +17,8 @@ const int CHUNK_D = 16;
 const uint VOXEL_USER_BITS = 8;
 constexpr uint VOXEL_USER_BITS_OFFSET = sizeof(blockstate_t)*8-VOXEL_USER_BITS;
 
+const int ITEM_ICON_SIZE = 48;
+
 /* Chunk volume (count of voxels per Chunk) */
 constexpr int CHUNK_VOL = (CHUNK_W * CHUNK_H * CHUNK_D);
 
diff --git a/src/frontend/BlocksPreview.cpp b/src/frontend/BlocksPreview.cpp
index 846afc4a..723cdc10 100644
--- a/src/frontend/BlocksPreview.cpp
+++ b/src/frontend/BlocksPreview.cpp
@@ -8,47 +8,23 @@
 #include "../graphics/Texture.h"
 #include "../graphics/Atlas.h"
 #include "../graphics/Batch3D.h"
+#include "../graphics/Framebuffer.h"
+#include "../graphics/GfxContext.h"
+#include "../window/Window.h"
 #include "../window/Camera.h"
 #include "../voxels/Block.h"
+#include "../content/Content.h"
+#include "../constants.h"
 #include "ContentGfxCache.h"
 
-BlocksPreview::BlocksPreview(Assets* assets, const ContentGfxCache* cache)
-    : shader(assets->getShader("ui3d")), 
-      atlas(assets->getAtlas("blocks")), 
-      cache(cache) {
-    batch = std::make_unique<Batch3D>(1024);
-}
-
-BlocksPreview::~BlocksPreview() {
-}
-
-void BlocksPreview::begin(const Viewport* viewport) {
-    this->viewport = viewport;
-    shader->use();
-    shader->uniformMatrix("u_projview", 
-        glm::ortho(0.0f, float(viewport->getWidth()), 
-                   0.0f, float(viewport->getHeight()), 
-                    -100.0f, 100.0f) * 
-        glm::lookAt(glm::vec3(2, 2, 2), glm::vec3(0.0f), glm::vec3(0, 1, 0)));
-    atlas->getTexture()->bind();
-}
-
-/* Draw one block preview at given screen position */
-void BlocksPreview::draw(const Block* def, int x, int y, int size, glm::vec4 tint) {
-    uint width = viewport->getWidth();
-    uint height = viewport->getHeight();
-
-    y = height - y - 1 - 35 /* magic garbage */;
-    x += 2;
-
-    if (def->model == BlockModel::aabb) {
-        x += (1.0f - def->hitbox.size()).x * size * 0.5f;
-        y += (1.0f - def->hitbox.size()).y * size * 0.25f;
-    }
-
-    glm::vec3 offset (x/float(width) * 2, y/float(height) * 2, 0.0f);
-    shader->uniformMatrix("u_apply", glm::translate(glm::mat4(1.0f), offset));
-    
+ImageData* BlocksPreview::draw(
+    const ContentGfxCache* cache,
+    Framebuffer* fbo,
+    Batch3D* batch,
+    const Block* def, 
+    int size
+){
+    Window::clear();
     blockid_t id = def->rt.id;
     const UVRegion texfaces[6]{cache->getRegion(id, 0), cache->getRegion(id, 1),
                                cache->getRegion(id, 2), cache->getRegion(id, 3),
@@ -59,11 +35,11 @@ void BlocksPreview::draw(const Block* def, int x, int y, int size, glm::vec4 tin
             // something went wrong...
             break;
         case BlockModel::block:
-            batch->blockCube(glm::vec3(size * 0.63f), texfaces, tint, !def->rt.emissive);
+            batch->blockCube(glm::vec3(size * 0.63f), texfaces, glm::vec4(1.0f), !def->rt.emissive);
             break;
         case BlockModel::aabb:
             batch->blockCube(def->hitbox.size() * glm::vec3(size * 0.63f), 
-                             texfaces, tint, !def->rt.emissive);
+                             texfaces, glm::vec4(1.0f), !def->rt.emissive);
             break;
         case BlockModel::custom:
         case BlockModel::xsprite: {
@@ -73,10 +49,64 @@ void BlocksPreview::draw(const Block* def, int x, int y, int size, glm::vec4 tin
                           right, 
                           size*0.5f, size*0.6f, 
                           texfaces[0], 
-                          tint);
+                          glm::vec4(1.0f));
             break;
         }
     }
-    
     batch->flush();
+    return fbo->texture->readData();
+}
+
+std::unique_ptr<Atlas> BlocksPreview::build(
+    const ContentGfxCache* cache,
+    Assets* assets, 
+    const Content* content
+) {
+    auto indices = content->getIndices();
+    size_t count = indices->countBlockDefs();
+    size_t iconSize = ITEM_ICON_SIZE;
+
+    Shader* shader = assets->getShader("ui3d");
+    Atlas* atlas = assets->getAtlas("blocks");
+
+    Viewport viewport(iconSize, iconSize);
+    GfxContext pctx(nullptr, viewport, nullptr);
+    GfxContext ctx = pctx.sub();
+    ctx.cullFace(true);
+    ctx.depthTest(true);
+
+    Framebuffer fbo(iconSize, iconSize, true);
+    Batch3D batch(1024);
+    batch.begin();
+
+    shader->use();
+    shader->uniformMatrix("u_projview",
+
+    glm::ortho(0.0f, float(iconSize), 0.0f, float(iconSize), 
+                -100.0f, 100.0f) * 
+        glm::lookAt(glm::vec3(2, 2, 2), 
+                    glm::vec3(0.0f), 
+                    glm::vec3(0, 1, 0)));
+
+    AtlasBuilder builder;
+    Window::viewport(0, 0, iconSize, iconSize);
+    Window::setBgColor(glm::vec4(0.0f));
+    
+    fbo.bind();
+    for (size_t i = 0; i < count; i++) {
+        auto def = indices->getBlockDef(i);
+
+        glm::vec3 offset(0.1f, 0.5f, 0.1f);
+        if (def->model == BlockModel::aabb) {
+            offset.y += (1.0f - def->hitbox.size()).y * 0.5f;
+        }
+        atlas->getTexture()->bind();
+        shader->uniformMatrix("u_apply", glm::translate(glm::mat4(1.0f), offset));
+
+        builder.add(def->name, draw(cache, &fbo, &batch, def, iconSize));
+    }
+    fbo.unbind();
+
+    Window::viewport(0, 0, Window::width, Window::height);
+    return std::unique_ptr<Atlas>(builder.build(2));
 }
diff --git a/src/frontend/BlocksPreview.h b/src/frontend/BlocksPreview.h
index 0a1a03f3..5c4ab4c1 100644
--- a/src/frontend/BlocksPreview.h
+++ b/src/frontend/BlocksPreview.h
@@ -6,25 +6,27 @@
 #include <memory>
 
 class Assets;
-class Viewport;
-class Shader;
+class ImageData;
 class Atlas;
+class Framebuffer;
 class Batch3D;
 class Block;
+class Content;
 class ContentGfxCache;
 
 class BlocksPreview {
-    Shader* shader;
-    Atlas* atlas;
-    std::unique_ptr<Batch3D> batch;
-    const ContentGfxCache* const cache;
-    const Viewport* viewport;
 public:
-    BlocksPreview(Assets* assets, const ContentGfxCache* cache);
-    ~BlocksPreview();
+    static ImageData* draw(
+        const ContentGfxCache* cache,
+        Framebuffer* framebuffer,
+        Batch3D* batch,
+        const Block* block, 
+        int size);
 
-    void begin(const Viewport* viewport);
-    void draw(const Block* block, int x, int y, int size, glm::vec4 tint);
+    static std::unique_ptr<Atlas> build(
+        const ContentGfxCache* cache,
+        Assets* assets, 
+        const Content* content);
 };
 
 #endif // FRONTEND_BLOCKS_PREVIEW_H_
diff --git a/src/frontend/InventoryView.cpp b/src/frontend/InventoryView.cpp
index e10f2032..93c2f0bc 100644
--- a/src/frontend/InventoryView.cpp
+++ b/src/frontend/InventoryView.cpp
@@ -153,31 +153,26 @@ void SlotView::draw(Batch2D* batch, Assets* assets) {
     
     batch->color = glm::vec4(1.0f);
 
-    Shader* uiShader = assets->getShader("ui");
     Viewport viewport(Window::width, Window::height);
     GfxContext ctx(nullptr, viewport, batch);
 
-    auto preview = frontend->getBlocksPreview();
+    auto previews = frontend->getBlocksAtlas();
     auto indices = content->getIndices();
 
     ItemDef* item = indices->getItemDef(stack.getItemId());
     switch (item->iconType) {
         case item_icon_type::none:
             break;
-        case item_icon_type::block: 
-            batch->render();
-            {    
-                GfxContext subctx = ctx.sub();
-                subctx.depthTest(true);
-                subctx.cullFace(true);
+        case item_icon_type::block: {
+            Block* cblock = content->requireBlock(item->icon);
+            batch->texture(previews->getTexture());
 
-                Block* cblock = content->requireBlock(item->icon);
-                preview->begin(&subctx.getViewport());
-                preview->draw(cblock, coord.x, coord.y, slotSize, tint);
-            }
-            uiShader->use();
-            batch->begin();
+            UVRegion region = previews->get(cblock->name);
+            batch->rect(
+                coord.x, coord.y, slotSize, slotSize, 
+                0, 0, 0, region, false, true, tint);
             break;
+        }
         case item_icon_type::sprite: {
             size_t index = item->icon.find(':');
             std::string name = item->icon.substr(index+1);
@@ -327,12 +322,6 @@ InventoryLayout* InventoryView::getLayout() const {
     return layout.get();
 }
 
-// performance disaster x2
-void InventoryView::draw(Batch2D* batch, Assets* assets) {
-    Container::draw(batch, assets);
-    Window::clearDepth();
-}
-
 void InventoryView::drawBackground(Batch2D* batch, Assets* assets) {
     glm::vec2 coord = calcCoord();
     batch->texture(nullptr);
diff --git a/src/frontend/InventoryView.h b/src/frontend/InventoryView.h
index 5c7df130..c8c4801d 100644
--- a/src/frontend/InventoryView.h
+++ b/src/frontend/InventoryView.h
@@ -126,7 +126,6 @@ public:
 
     void build();
 
-    virtual void draw(Batch2D* batch, Assets* assets) override;
     virtual void drawBackground(Batch2D* batch, Assets* assets) override;
 
     void setInventory(std::shared_ptr<Inventory> inventory);
@@ -138,7 +137,7 @@ public:
     void setSelected(int index);
 
     static const int SLOT_INTERVAL = 4;
-    static const int SLOT_SIZE = 48;
+    static const int SLOT_SIZE = ITEM_ICON_SIZE;
 };
 
 class InventoryInteraction {
diff --git a/src/frontend/LevelFrontend.cpp b/src/frontend/LevelFrontend.cpp
index 4b1c6542..9561dfb2 100644
--- a/src/frontend/LevelFrontend.cpp
+++ b/src/frontend/LevelFrontend.cpp
@@ -2,6 +2,7 @@
 
 #include "../world/Level.h"
 #include "../assets/Assets.h"
+#include "../graphics/Atlas.h"
 #include "BlocksPreview.h"
 #include "ContentGfxCache.h"
 
@@ -9,8 +10,7 @@ LevelFrontend::LevelFrontend(Level* level, Assets* assets)
 : level(level),
   assets(assets),
   contentCache(std::make_unique<ContentGfxCache>(level->content, assets)),
-  blocksPreview(std::make_unique<BlocksPreview>(assets, contentCache.get())) {
-
+  blocksAtlas(BlocksPreview::build(contentCache.get(), assets, level->content)) {
 }
 
 LevelFrontend::~LevelFrontend() {
@@ -24,10 +24,10 @@ Assets* LevelFrontend::getAssets() const {
     return assets;
 }
 
-BlocksPreview* LevelFrontend::getBlocksPreview() const {
-    return blocksPreview.get();
-}
-
 ContentGfxCache* LevelFrontend::getContentGfxCache() const {
     return contentCache.get();
 }
+
+Atlas* LevelFrontend::getBlocksAtlas() const {
+    return blocksAtlas.get();
+}
diff --git a/src/frontend/LevelFrontend.h b/src/frontend/LevelFrontend.h
index 095f5535..98a8a111 100644
--- a/src/frontend/LevelFrontend.h
+++ b/src/frontend/LevelFrontend.h
@@ -3,6 +3,7 @@
 
 #include <memory>
 
+class Atlas;
 class Level;
 class Assets;
 class BlocksPreview;
@@ -12,15 +13,15 @@ class LevelFrontend {
     Level* level;
     Assets* assets;
     std::unique_ptr<ContentGfxCache> contentCache;
-    std::unique_ptr<BlocksPreview> blocksPreview;
+    std::unique_ptr<Atlas> blocksAtlas;
 public:
     LevelFrontend(Level* level, Assets* assets);
     ~LevelFrontend();
 
     Level* getLevel() const;
     Assets* getAssets() const;
-    BlocksPreview* getBlocksPreview() const;
     ContentGfxCache* getContentGfxCache() const;
+    Atlas* getBlocksAtlas() const;
 };
 
 
diff --git a/src/frontend/hud.cpp b/src/frontend/hud.cpp
index ea82473e..4d0a5493 100644
--- a/src/frontend/hud.cpp
+++ b/src/frontend/hud.cpp
@@ -52,106 +52,106 @@ using glm::vec4;
 using namespace gui;
 
 inline std::shared_ptr<Label> create_label(gui::wstringsupplier supplier) {
-	auto label = std::make_shared<Label>(L"-");
-	label->textSupplier(supplier);
-	return label;
+    auto label = std::make_shared<Label>(L"-");
+    label->textSupplier(supplier);
+    return label;
 }
 
 void HudRenderer::createDebugPanel(Engine* engine) {
     auto level = frontend->getLevel();
 
     Panel* panel = new Panel(vec2(250, 200), vec4(5.0f), 1.0f);
-	debugPanel = std::shared_ptr<UINode>(panel);
-	panel->listenInterval(1.0f, [this]() {
-		fpsString = std::to_wstring(fpsMax)+L" / "+std::to_wstring(fpsMin);
-		fpsMin = fps;
-		fpsMax = fps;
-	});
-	panel->setCoord(vec2(10, 10));
-	panel->add(create_label([this](){ return L"fps: "+this->fpsString;}));
-	panel->add(create_label([this](){
-		return L"meshes: " + std::to_wstring(Mesh::meshesCount);
-	}));
-	panel->add(create_label([=](){
-		auto& settings = engine->getSettings();
-		bool culling = settings.graphics.frustumCulling;
-		return L"frustum-culling: "+std::wstring(culling ? L"on" : L"off");
-	}));
-	panel->add(create_label([=]() {
-		return L"chunks: "+std::to_wstring(level->chunks->chunksCount)+
-			   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;
-		if (def) {
-			stream << L" (" << util::str2wstr_utf8(def->name) << L")";
-		}
-		return L"block: "+std::to_wstring(player->selectedVoxel.id)+
-		       L" "+stream.str();
-	}));
-	panel->add(create_label([=](){
-		return L"seed: "+std::to_wstring(level->world->seed);
-	}));
+    debugPanel = std::shared_ptr<UINode>(panel);
+    panel->listenInterval(1.0f, [this]() {
+        fpsString = std::to_wstring(fpsMax)+L" / "+std::to_wstring(fpsMin);
+        fpsMin = fps;
+        fpsMax = fps;
+    });
+    panel->setCoord(vec2(10, 10));
+    panel->add(create_label([this](){ return L"fps: "+this->fpsString;}));
+    panel->add(create_label([this](){
+        return L"meshes: " + std::to_wstring(Mesh::meshesCount);
+    }));
+    panel->add(create_label([=](){
+        auto& settings = engine->getSettings();
+        bool culling = settings.graphics.frustumCulling;
+        return L"frustum-culling: "+std::wstring(culling ? L"on" : L"off");
+    }));
+    panel->add(create_label([=]() {
+        return L"chunks: "+std::to_wstring(level->chunks->chunksCount)+
+               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;
+        if (def) {
+            stream << L" (" << util::str2wstr_utf8(def->name) << L")";
+        }
+        return L"block: "+std::to_wstring(player->selectedVoxel.id)+
+               L" "+stream.str();
+    }));
+    panel->add(create_label([=](){
+        return L"seed: "+std::to_wstring(level->world->seed);
+    }));
 
-	for (int ax = 0; ax < 3; ax++){
-		Panel* sub = new Panel(vec2(10, 27), vec4(0.0f));
-		sub->orientation(Orientation::horizontal);
+    for (int ax = 0; ax < 3; ax++){
+        Panel* sub = new Panel(vec2(10, 27), vec4(0.0f));
+        sub->orientation(Orientation::horizontal);
 
-		std::wstring str = L"x: ";
-		str[0] += ax;
-		Label* label = new Label(str);
-		label->margin(vec4(2, 3, 2, 3));
-		sub->add(label);
-		sub->color(vec4(0.0f));
+        std::wstring str = L"x: ";
+        str[0] += ax;
+        Label* label = new Label(str);
+        label->margin(vec4(2, 3, 2, 3));
+        sub->add(label);
+        sub->color(vec4(0.0f));
 
-		// Coord input
-		TextBox* box = new TextBox(L"");
-		box->textSupplier([=]() {
-			Hitbox* hitbox = level->player->hitbox.get();
-			return util::to_wstring(hitbox->position[ax], 2);
-		});
-		box->textConsumer([=](std::wstring text) {
-			try {
-				vec3 position = level->player->hitbox->position;
-				position[ax] = std::stoi(text);
-				level->player->teleport(position);
-			} catch (std::invalid_argument& _){
-			}
-		});
-		box->setOnEditStart([=](){
-			Hitbox* hitbox = level->player->hitbox.get();
-			box->text(std::to_wstring(int(hitbox->position[ax])));
-		});
+        // Coord input
+        TextBox* box = new TextBox(L"");
+        box->textSupplier([=]() {
+            Hitbox* hitbox = level->player->hitbox.get();
+            return util::to_wstring(hitbox->position[ax], 2);
+        });
+        box->textConsumer([=](std::wstring text) {
+            try {
+                vec3 position = level->player->hitbox->position;
+                position[ax] = std::stoi(text);
+                level->player->teleport(position);
+            } catch (std::invalid_argument& _){
+            }
+        });
+        box->setOnEditStart([=](){
+            Hitbox* hitbox = level->player->hitbox.get();
+            box->text(std::to_wstring(int(hitbox->position[ax])));
+        });
 
-		sub->add(box);
-		panel->add(sub);
-	}
-	panel->add(create_label([=](){
-		int hour, minute, second;
-		timeutil::from_value(level->world->daytime, hour, minute, second);
+        sub->add(box);
+        panel->add(sub);
+    }
+    panel->add(create_label([=](){
+        int hour, minute, second;
+        timeutil::from_value(level->world->daytime, hour, minute, second);
 
-		std::wstring timeString = 
-					 util::lfill(std::to_wstring(hour), 2, L'0') + L":" +
-					 util::lfill(std::to_wstring(minute), 2, L'0');
-		return L"time: "+timeString;
-	}));
-	{
-		TrackBar* bar = new TrackBar(0.0f, 1.0f, 1.0f, 0.005f, 8);
-		bar->supplier([=]() {return level->world->daytime;});
-		bar->consumer([=](double val) {level->world->daytime = val;});
-		panel->add(bar);
-	}
-	{
-		TrackBar* bar = new TrackBar(0.0f, 1.0f, 0.0f, 0.005f, 8);
-		bar->supplier([=]() {return WorldRenderer::fog;});
-		bar->consumer([=](double val) {WorldRenderer::fog = val;});
-		panel->add(bar);
-	}
-	{
+        std::wstring timeString = 
+                     util::lfill(std::to_wstring(hour), 2, L'0') + L":" +
+                     util::lfill(std::to_wstring(minute), 2, L'0');
+        return L"time: "+timeString;
+    }));
+    {
+        TrackBar* bar = new TrackBar(0.0f, 1.0f, 1.0f, 0.005f, 8);
+        bar->supplier([=]() {return level->world->daytime;});
+        bar->consumer([=](double val) {level->world->daytime = val;});
+        panel->add(bar);
+    }
+    {
+        TrackBar* bar = new TrackBar(0.0f, 1.0f, 0.0f, 0.005f, 8);
+        bar->supplier([=]() {return WorldRenderer::fog;});
+        bar->consumer([=](double val) {WorldRenderer::fog = val;});
+        panel->add(bar);
+    }
+    {
         auto checkbox = new FullCheckBox(L"Show Chunk Borders", vec2(400, 32));
         checkbox->supplier([=]() {
             return engine->getSettings().debug.showChunkBorders;
@@ -160,8 +160,8 @@ void HudRenderer::createDebugPanel(Engine* engine) {
             engine->getSettings().debug.showChunkBorders = checked;
         });
         panel->add(checkbox);
-	}
-	panel->refresh();
+    }
+    panel->refresh();
 }
 
 std::shared_ptr<InventoryView> HudRenderer::createContentAccess() {
@@ -192,10 +192,10 @@ std::shared_ptr<InventoryView> HudRenderer::createContentAccess() {
 
     auto contentAccess = std::make_shared<InventoryView>(
         content, 
-		frontend, 
-		interaction.get(), 
-		accessInventory, 
-		std::move(layout)
+        frontend, 
+        interaction.get(), 
+        accessInventory, 
+        std::move(layout)
     );
     contentAccess->build();
     return contentAccess;
@@ -215,10 +215,10 @@ std::shared_ptr<InventoryView> HudRenderer::createHotbar() {
     layout->setOrigin(glm::vec2(layout->getSize().x/2, 0));
     auto view = std::make_shared<InventoryView>(
         content, 
-		frontend, 
-		interaction.get(), 
-		inventory, 
-		std::move(layout)
+        frontend, 
+        interaction.get(), 
+        inventory, 
+        std::move(layout)
     );
     view->build();
     view->setInteractive(false);
@@ -255,13 +255,13 @@ HudRenderer::HudRenderer(Engine* engine, LevelFrontend* frontend)
       gui(engine->getGUI()),
       frontend(frontend)
 {
-	auto menu = gui->getMenu();
+    auto menu = gui->getMenu();
 
     interaction = std::make_unique<InventoryInteraction>();
     grabbedItemView = std::make_shared<SlotView>(
         interaction->getGrabbedItem(), 
         frontend,
-		interaction.get(),
+        interaction.get(),
         frontend->getLevel()->content,
         SlotLayout(glm::vec2(), false, false, nullptr, nullptr)
     );
@@ -279,14 +279,14 @@ HudRenderer::HudRenderer(Engine* engine, LevelFrontend* frontend)
     hotbarView = createHotbar();
     inventoryView = createInventory();
 
-	uicamera = new Camera(vec3(), 1);
-	uicamera->perspective = false;
-	uicamera->flipped = true;
+    uicamera = new Camera(vec3(), 1);
+    uicamera->perspective = false;
+    uicamera->flipped = true;
 
     createDebugPanel(engine);
-	menu->reset();
-	
-	gui->add(debugPanel);
+    menu->reset();
+    
+    gui->add(debugPanel);
     gui->add(contentAccessPanel);
     gui->add(hotbarView);
     gui->add(inventoryView);
@@ -298,48 +298,48 @@ HudRenderer::~HudRenderer() {
     gui->remove(inventoryView);
     gui->remove(hotbarView);
     gui->remove(contentAccessPanel);
-	gui->remove(debugPanel);
-	delete uicamera;
+    gui->remove(debugPanel);
+    delete uicamera;
 }
 
 void HudRenderer::drawDebug(int fps){
-	this->fps = fps;
-	fpsMin = min(fps, fpsMin);
-	fpsMax = max(fps, fpsMax);
+    this->fps = fps;
+    fpsMin = min(fps, fpsMin);
+    fpsMax = max(fps, fpsMax);
 }
 
 void HudRenderer::update(bool visible) {
     auto level = frontend->getLevel();
     auto player = level->player;
-	auto menu = gui->getMenu();
+    auto menu = gui->getMenu();
 
     menu->visible(pause);
 
     if (!visible && inventoryOpen) {
         inventoryOpen = false;
     }
-	if (pause && menu->current().panel == nullptr) {
-		pause = false;
-	}
-	if (Events::jpressed(keycode::ESCAPE) && !gui->isFocusCaught()) {
-		if (pause) {
-			pause = false;
-			menu->reset();
-		} else if (inventoryOpen) {
-			inventoryOpen = false;
-		} else {
-			pause = true;
-			menu->set("pause");
-		}
-	}
-	if (visible && Events::jactive(BIND_HUD_INVENTORY)) {
-		if (!pause) {
-			inventoryOpen = !inventoryOpen;
-		}
-	}
-	if ((pause || inventoryOpen) == Events::_cursor_locked) {
-		Events::toggleCursor();
-	}
+    if (pause && menu->current().panel == nullptr) {
+        pause = false;
+    }
+    if (Events::jpressed(keycode::ESCAPE) && !gui->isFocusCaught()) {
+        if (pause) {
+            pause = false;
+            menu->reset();
+        } else if (inventoryOpen) {
+            inventoryOpen = false;
+        } else {
+            pause = true;
+            menu->set("pause");
+        }
+    }
+    if (visible && Events::jactive(BIND_HUD_INVENTORY)) {
+        if (!pause) {
+            inventoryOpen = !inventoryOpen;
+        }
+    }
+    if ((pause || inventoryOpen) == Events::_cursor_locked) {
+        Events::toggleCursor();
+    }
 
     glm::vec2 invSize = contentAccessPanel->size();
     inventoryView->visible(inventoryOpen);
@@ -365,10 +365,10 @@ void HudRenderer::update(bool visible) {
 }
 
 void HudRenderer::drawOverlay(const GfxContext& ctx) {
-	if (pause) {
-	    Shader* uishader = assets->getShader("ui");
-	    uishader->use();
-	    uishader->uniformMatrix("u_projview", uicamera->getProjView());
+    if (pause) {
+        Shader* uishader = assets->getShader("ui");
+        uishader->use();
+        uishader->uniformMatrix("u_projview", uicamera->getProjView());
 
         const Viewport& viewport = ctx.getViewport();
         const uint width = viewport.getWidth();
@@ -376,48 +376,48 @@ void HudRenderer::drawOverlay(const GfxContext& ctx) {
         auto batch = ctx.getBatch2D();
         batch->begin();
 
-		// draw fullscreen dark overlay
-		batch->texture(nullptr);
-		batch->color = vec4(0.0f, 0.0f, 0.0f, 0.5f);
-		batch->rect(0, 0, width, height);
+        // draw fullscreen dark overlay
+        batch->texture(nullptr);
+        batch->color = vec4(0.0f, 0.0f, 0.0f, 0.5f);
+        batch->rect(0, 0, width, height);
         batch->render();
-	}
+    }
 } 
 
 void HudRenderer::draw(const GfxContext& ctx){
     auto level = frontend->getLevel();
 
-	const Viewport& viewport = ctx.getViewport();
-	const uint width = viewport.getWidth();
-	const uint height = viewport.getHeight();
+    const Viewport& viewport = ctx.getViewport();
+    const uint width = viewport.getWidth();
+    const uint height = viewport.getHeight();
 
-	Player* player = level->player;
-	debugPanel->visible(player->debug);
+    Player* player = level->player;
+    debugPanel->visible(player->debug);
 
-	uicamera->setFov(height);
+    uicamera->setFov(height);
 
     auto batch = ctx.getBatch2D();
-	batch->begin();
+    batch->begin();
 
-	Shader* uishader = assets->getShader("ui");
-	uishader->use();
-	uishader->uniformMatrix("u_projview", uicamera->getProjView());
-	
-	// Draw selected item preview
+    Shader* uishader = assets->getShader("ui");
+    uishader->use();
+    uishader->uniformMatrix("u_projview", uicamera->getProjView());
+    
+    // Draw selected item preview
     hotbarView->setCoord(glm::vec2(width/2, height-65));
     hotbarView->setSelected(player->getChosenSlot());
 
-	// Crosshair
-	batch->begin();
-	if (!pause && Events::_cursor_locked && !level->player->debug) {
-		batch->lineWidth(2);
-		batch->line(width/2, height/2-6, width/2, height/2+6, 0.2f, 0.2f, 0.2f, 1.0f);
-		batch->line(width/2+6, height/2, width/2-6, height/2, 0.2f, 0.2f, 0.2f, 1.0f);
-		batch->line(width/2-5, height/2-5, width/2+5, height/2+5, 0.9f, 0.9f, 0.9f, 1.0f);
-		batch->line(width/2+5, height/2-5, width/2-5, height/2+5, 0.9f, 0.9f, 0.9f, 1.0f);
-	}
+    // Crosshair
+    batch->begin();
+    if (!pause && Events::_cursor_locked && !level->player->debug) {
+        batch->lineWidth(2);
+        batch->line(width/2, height/2-6, width/2, height/2+6, 0.2f, 0.2f, 0.2f, 1.0f);
+        batch->line(width/2+6, height/2, width/2-6, height/2, 0.2f, 0.2f, 0.2f, 1.0f);
+        batch->line(width/2-5, height/2-5, width/2+5, height/2+5, 0.9f, 0.9f, 0.9f, 1.0f);
+        batch->line(width/2+5, height/2-5, width/2-5, height/2+5, 0.9f, 0.9f, 0.9f, 1.0f);
+    }
 
-	if (inventoryOpen) {
+    if (inventoryOpen) {
         auto caLayout = contentAccess->getLayout();
         auto invLayout = inventoryView->getLayout();
         float caWidth = caLayout->getSize().x;
@@ -430,15 +430,15 @@ void HudRenderer::draw(const GfxContext& ctx){
             height/2-invSize.y/2
         ));
         contentAccessPanel->setCoord(glm::vec2(width-caWidth, 0));
-	}
+    }
     grabbedItemView->setCoord(glm::vec2(Events::cursor));
-	batch->render();
+    batch->render();
 }
 
 bool HudRenderer::isInventoryOpen() const {
-	return inventoryOpen;
+    return inventoryOpen;
 }
 
 bool HudRenderer::isPause() const {
-	return pause;
+    return pause;
 }
diff --git a/src/graphics/Framebuffer.cpp b/src/graphics/Framebuffer.cpp
index 77ae7462..d5f38398 100644
--- a/src/graphics/Framebuffer.cpp
+++ b/src/graphics/Framebuffer.cpp
@@ -3,13 +3,15 @@
 #include <GL/glew.h>
 #include "Texture.h"
 
-Framebuffer::Framebuffer(uint width, uint height) : width(width), height(height) {
+Framebuffer::Framebuffer(uint width, uint height, bool alpha) 
+    : width(width), height(height) {
 	glGenFramebuffers(1, &fbo);
 	bind();
 	GLuint tex;
 	glGenTextures(1, &tex);
 	glBindTexture(GL_TEXTURE_2D, tex);
-	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, nullptr);
+    GLuint format = alpha ? GL_RGBA : GL_RGB;
+	glTexImage2D(GL_TEXTURE_2D, 0, format, width, height, 0, format, GL_UNSIGNED_BYTE, nullptr);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
diff --git a/src/graphics/Framebuffer.h b/src/graphics/Framebuffer.h
index 0214d0c2..e6111244 100644
--- a/src/graphics/Framebuffer.h
+++ b/src/graphics/Framebuffer.h
@@ -12,7 +12,7 @@ public:
 	uint width;
 	uint height;
 	Texture* texture;
-	Framebuffer(uint width, uint height);
+	Framebuffer(uint width, uint height, bool alpha=false);
 	~Framebuffer();
 
 	void bind();
diff --git a/src/window/Window.cpp b/src/window/Window.cpp
index 05d4dd68..6a692902 100644
--- a/src/window/Window.cpp
+++ b/src/window/Window.cpp
@@ -179,6 +179,10 @@ void Window::setBgColor(glm::vec3 color) {
 	glClearColor(color.r, color.g, color.b, 1.0f);
 }
 
+void Window::setBgColor(glm::vec4 color) {
+	glClearColor(color.r, color.g, color.b, color.a);
+}
+
 void Window::viewport(int x, int y, int width, int height){
 	glViewport(x, y, width, height);
 }
diff --git a/src/window/Window.h b/src/window/Window.h
index 4fb7ed34..e9f925cd 100644
--- a/src/window/Window.h
+++ b/src/window/Window.h
@@ -48,6 +48,7 @@ public:
 	static void clear();
 	static void clearDepth();
 	static void setBgColor(glm::vec3 color);
+    static void setBgColor(glm::vec4 color);
 	static double time();
     static const char* getClipboardText();
 	static DisplaySettings* getSettings();