Backlight setting

src/files/settings_io.cpp

@@ -28,6 +28,7 @@ toml::Wrapper create_wrapper(EngineSettings& settings) {
 
 	toml::Section& graphics = wrapper.add("graphics");
 	graphics.add("fog-curve", &settings.graphics.fogCurve);
+	graphics.add("backlight", &settings.graphics.backlight);
 
 	toml::Section& debug = wrapper.add("debug");
 	debug.add("generator-test-mode", &settings.debug.generatorTestMode);

src/frontend/menu.cpp

@@ -246,7 +246,7 @@ Panel* create_settings_panel(Engine* engine, PagesControl* menu) {
         panel->add(trackbar);
     }
 
-    {
+    /* V-Sync checkbox */{
         Panel* checkpanel = new Panel(vec2(400, 32), vec4(5.0f), 1.0f);
         checkpanel->color(vec4(0.0f));
         checkpanel->orientation(Orientation::horizontal);
@@ -265,6 +265,25 @@ Panel* create_settings_panel(Engine* engine, PagesControl* menu) {
         panel->add(checkpanel);
     }
 
+    /* Backlight checkbox */{
+        Panel* checkpanel = new Panel(vec2(400, 32), vec4(5.0f), 1.0f);
+        checkpanel->color(vec4(0.0f));
+        checkpanel->orientation(Orientation::horizontal);
+
+        CheckBox* checkbox = new CheckBox();
+        checkbox->margin(vec4(0.0f, 0.0f, 5.0f, 0.0f));
+        checkbox->supplier([=]() {
+            return engine->getSettings().graphics.backlight != 0;
+        });
+        checkbox->consumer([=](bool checked) {
+            engine->getSettings().graphics.backlight = checked;
+        });
+        checkpanel->add(checkbox);
+        checkpanel->add(new Label(L"Backlight"));
+
+        panel->add(checkpanel);
+    }
+
     panel->add(gotoButton(L"Controls", "controls", menu));
     panel->add(backButton(menu));
     panel->refresh();

src/frontend/screens.cpp

@@ -87,12 +87,14 @@ void MenuScreen::draw(float delta) {
     batch->render();
 }
 
+static bool backlight;
 LevelScreen::LevelScreen(Engine* engine, Level* level) 
     : Screen(engine), 
       level(level) {
     cache = new ContentGfxCache(level->content, engine->getAssets());
     worldRenderer = new WorldRenderer(engine, level, cache);
     hud = new HudRenderer(engine, level, cache);
+    backlight = engine->getSettings().graphics.backlight;
 }
 
 LevelScreen::~LevelScreen() {
@@ -130,6 +132,10 @@ void LevelScreen::update(float delta) {
     if (!gui->isFocusCaught()) {
         updateHotkeys();
     }
+    if (settings.graphics.backlight != backlight) {
+        level->chunks->clear();
+        backlight = settings.graphics.backlight;
+    }
     level->updatePlayer(delta, !inputLocked, hud->isPause(), !inputLocked);
     level->update();
     

src/frontend/world_render.cpp

@@ -35,7 +35,7 @@ using std::shared_ptr;
 WorldRenderer::WorldRenderer(Engine* engine, Level* level, const ContentGfxCache* cache) 
 	: engine(engine), level(level) {
 	lineBatch = new LineBatch(4096);
-	renderer = new ChunksRenderer(level, cache);
+	renderer = new ChunksRenderer(level, cache, engine->getSettings());
 	frustumCulling = new Frustum();
 	level->events->listen(EVT_CHUNK_HIDDEN, [this](lvl_event_type type, Chunk* chunk) {
 		renderer->unload(chunk);

src/graphics/BlocksRenderer.cpp

@@ -21,13 +21,15 @@ using glm::vec4;
 
 BlocksRenderer::BlocksRenderer(size_t capacity,
 	const Content* content,
-	const ContentGfxCache* cache)
+	const ContentGfxCache* cache,
+	const EngineSettings& settings)
 	: content(content),
 	vertexOffset(0),
 	indexOffset(0),
 	indexSize(0),
 	capacity(capacity),
-	cache(cache) {
+	cache(cache),
+	settings(settings) {
 	vertexBuffer = new float[capacity];
 	indexBuffer = new int[capacity];
 	voxelsBuffer = new VoxelsVolume(CHUNK_W + 2, CHUNK_H, CHUNK_D + 2);
@@ -353,7 +355,7 @@ void BlocksRenderer::render(const voxel* voxels, int atlas_size) {
 Mesh* BlocksRenderer::render(const Chunk* chunk, int atlas_size, const ChunksStorage* chunks) {
 	this->chunk = chunk;
 	voxelsBuffer->setPosition(chunk->x * CHUNK_W - 1, 0, chunk->z * CHUNK_D - 1);
-	chunks->getVoxels(voxelsBuffer, true);
+	chunks->getVoxels(voxelsBuffer, settings.graphics.backlight);
 	overflow = false;
 	vertexOffset = 0;
 	indexOffset = indexSize = 0;

src/graphics/BlocksRenderer.h

@@ -6,6 +6,7 @@
 #include "UVRegion.h"
 #include "../typedefs.h"
 #include "../voxels/voxel.h"
+#include "../settings.h"
 
 class Content;
 class Mesh;
@@ -31,6 +32,7 @@ class BlocksRenderer {
 
 	const Block* const* blockDefsCache;
 	const ContentGfxCache* const cache;
+	const EngineSettings& settings;
 
 	void vertex(const glm::vec3& coord, float u, float v, const glm::vec4& light);
 	void index(int a, int b, int c, int d, int e, int f);
@@ -70,7 +72,7 @@ class BlocksRenderer {
 	glm::vec4 pickSoftLight(int x, int y, int z, const glm::ivec3& right, const glm::ivec3& up) const;
 	void render(const voxel* voxels, int atlas_size);
 public:
-	BlocksRenderer(size_t capacity, const Content* content, const ContentGfxCache* cache);
+	BlocksRenderer(size_t capacity, const Content* content, const ContentGfxCache* cache, const EngineSettings& settings);
 	virtual ~BlocksRenderer();
 
 	Mesh* render(const Chunk* chunk, int atlas_size, const ChunksStorage* chunks);

src/graphics/ChunksRenderer.cpp

@@ -11,9 +11,9 @@
 using glm::ivec2;
 using std::shared_ptr;
 
-ChunksRenderer::ChunksRenderer(Level* level, const ContentGfxCache* cache) : level(level) {
+ChunksRenderer::ChunksRenderer(Level* level, const ContentGfxCache* cache, const EngineSettings& settings) : level(level) {
 	const int MAX_FULL_CUBES = 3000;
-	renderer = new BlocksRenderer(9 * 6 * 6 * MAX_FULL_CUBES, level->content, cache);
+	renderer = new BlocksRenderer(9 * 6 * 6 * MAX_FULL_CUBES, level->content, cache, settings);
 }
 
 ChunksRenderer::~ChunksRenderer() {

src/graphics/ChunksRenderer.h

@@ -6,6 +6,7 @@
 #include <glm/glm.hpp>
 #include "../voxels/Block.h"
 #include "../voxels/ChunksStorage.h"
+#include "../settings.h"
 
 class Mesh;
 class Chunk;
@@ -18,7 +19,9 @@ class ChunksRenderer {
 	Level* level;
 	std::unordered_map<glm::ivec2, std::shared_ptr<Mesh>> meshes;
 public:
-	ChunksRenderer(Level* level, const ContentGfxCache* cache);
+	ChunksRenderer(Level* level, 
+				   const ContentGfxCache* cache, 
+				   const EngineSettings& settings);
 	virtual ~ChunksRenderer();
 
 	std::shared_ptr<Mesh> render(Chunk* chunk);

src/settings.h

@@ -38,6 +38,8 @@ struct GraphicsSettings {
 	/* Fog opacity is calculated as `pow(depth*k, fogCurve)` where k depends on chunksLoadDistance.
 	   Use values in range [1.0 - 2.0] where 1.0 is linear, 2.0 is quadratic */
 	float fogCurve = 1.6f;
+	/* Enable blocks backlight to prevent complete darkness */
+	bool backlight = true;
 };
 
 struct DebugSettings {