[Renderer] external color

Author: MetsukiMio

include/openminecraft/renderer/common/wrap/om_renderer_voxel.hpp

@@ -378,16 +378,34 @@ class OMVoxelCompilerPool
     bool active = true;
 };
 
+class OMVoxelColorManager
+{
+  public:
+    virtual ~OMVoxelColorManager()
+    {
+    }
+
+    virtual auto getSkyColor() -> glm::vec3 = 0;
+    virtual auto getSkyDiscColor() -> glm::vec3 = 0;
+    virtual auto getSkyDiskRange() -> float = 0;
+    virtual auto getSkyDiskHeight() -> float = 0;
+    virtual auto getFogRange() -> glm::vec2 = 0;
+    virtual auto getBlockTint() -> glm::vec3 = 0;
+    virtual auto getSkyLightColor() -> glm::vec3 = 0;
+};
+
 class OMVoxelManager
 {
   public:
     OMVoxelManager(OMRenderer *renderer, OMRendererRenderTarget *, OMRendererTexture *, OMRendererTexture *,
                    std::shared_ptr<world::OMChunkManager<16>>, std::function<void()>, OMVoxelHandler *,
-                   std::function<uint32_t(uint32_t, uint64_t, uint64_t, uint64_t, int, int, int)>);
+                   std::function<uint32_t(uint32_t, uint64_t, uint64_t, uint64_t, int, int, int)>,
+                   OMVoxelColorManager *);
     ~OMVoxelManager();
 
     auto submit(OMRendererTask *, OMRendererTempTarget *) -> OMRendererTask *;
     auto update(basics::OMCamera &camera) -> void;
+    auto updateColor() -> void;
     void bindCameraBuffer(OMRendererBuffer *);
 
     OMRendererTempTarget *translucentTargetMS, *translucentTarget;
@@ -405,6 +423,7 @@ class OMVoxelManager
     OMRendererTexture *textureAtlas;
     OMRendererTexture *textureAtlasSecondary;
     OMRendererTempTarget *lightmap;
+    OMVoxelColorManager *colorManager;
 
   private:
     int samples = 4;

src/openminecraft-core/renderer/common/wrap/om_renderer_voxel_manager.cpp

@@ -27,14 +27,16 @@ uint64_t cx = 0, cy = 0, cz = 0;
 OMVoxelManager::OMVoxelManager(OMRenderer *renderer, OMRendererRenderTarget *resolveTarget, OMRendererTexture *tex,
                                OMRendererTexture *texSec, std::shared_ptr<world::OMChunkManager<16>> man,
                                std::function<void()> rec, OMVoxelHandler *handler,
-                               std::function<uint32_t(uint32_t, uint64_t, uint64_t, uint64_t, int, int, int)> converter)
+                               std::function<uint32_t(uint32_t, uint64_t, uint64_t, uint64_t, int, int, int)> converter,
+                               OMVoxelColorManager *colorman)
     : logger("OMVoxelManager", this)
 {
     this->rec = rec;
     this->renderer = renderer;
     this->chunkManager = man;
     this->voxelHandler = handler;
     this->converter = converter;
+    this->colorManager = colorman;
 
     delete compiler.handler;
     compiler.handler = voxelHandler;
@@ -273,31 +275,9 @@ OMVoxelManager::OMVoxelManager(OMRenderer *renderer, OMRendererRenderTarget *res
     chunkoffs = renderer->allocateBuffer(UniformTexel, 3 * sizeof(float));
     debugoffs = renderer->allocateBuffer(VertexData, 12 * 2 * 3 * sizeof(float));
     skydisc = renderer->allocateBuffer(Uniform, sizeof(OMVoxelSkyDisc));
-    OMVoxelSkyDisc disc = {{0.470, 0.654, 1.0}, 256, {0.198, 0.371, 1.0}, -16};
-    skydisc->updateData(&disc);
     fogdata = renderer->allocateBuffer(Uniform, sizeof(float) * 5);
-    std::array<float, 5> d = {0.0005, 0.0006, 0.470, 0.654, 1.0};
-    fogdata->updateData(d.data());
 
     lightmapData = renderer->allocateBuffer(Uniform, sizeof(OMVoxelLightMap));
-    OMVoxelLightMap dayData = {
-        1.0, // SkyFactor
-        1.0, // BlockFactor
-        0.0, // NightVisionFactor
-        0.0, // DarknessScale
-        0.0, // BossOverlayWorldDarkeningFactor
-        1.0, // BrightnessFactor
-        0,
-        0,
-        {1.0, 0.8, 0.6}, // BlockLightTint
-        0,
-        {1.0, 1.0, 1.0}, // SkyLightColor
-        0,
-        {0.01, 0.01, 0.01}, // AmbientColor
-        0,
-        {0.7, 0.7, 0.7} // NightVisionColor
-    };
-    lightmapData->updateData(&dayData);
 
     textureAtlas = tex;
     textureAtlasSecondary = texSec;
@@ -362,6 +342,34 @@ void OMVoxelManager::unloadChunk(int i)
     voxelTranslucentComplexLayer->loadData(i, tcm);
 }
 
+auto OMVoxelManager::updateColor() -> void
+{
+    OMVoxelSkyDisc disc = {colorManager->getSkyDiscColor(), 256, colorManager->getSkyColor(), -16};
+    skydisc->updateData(&disc);
+    std::array<float, 5> d = {colorManager->getFogRange().x, colorManager->getFogRange().y, disc.diskCenterColor.r,
+                              disc.diskCenterColor.g, disc.diskCenterColor.b};
+    fogdata->updateData(d.data());
+
+    OMVoxelLightMap dayData = {
+        1.0, // SkyFactor
+        1.0, // BlockFactor
+        0.0, // NightVisionFactor
+        0.0, // DarknessScale
+        0.0, // BossOverlayWorldDarkeningFactor
+        1.0, // BrightnessFactor
+        0,
+        0,
+        colorManager->getBlockTint(), // BlockLightTint
+        0,
+        colorManager->getSkyLightColor(), // SkyLightColor
+        0,
+        {0.01, 0.01, 0.01}, // AmbientColor
+        0,
+        {0.7, 0.7, 0.7} // NightVisionColor
+    };
+    lightmapData->updateData(&dayData);
+}
+
 auto OMVoxelManager::update(basics::OMCamera &camera) -> void
 {
     auto cc = camera.getPosRaw();
@@ -384,6 +392,8 @@ auto OMVoxelManager::update(basics::OMCamera &camera) -> void
             pp4 - camera.getPosRaw(), pp6 - camera.getPosRaw(), pp4 - camera.getPosRaw(), pp7 - camera.getPosRaw(),
         }}.data());
 
+    updateColor();
+
     if (chunkManager->numChunks())
     {
         std::vector<glm::vec3> offs = {};

src/openminecraft/renderer/worldrenderer.cpp

@@ -29,6 +29,38 @@ using namespace openminecraft::renderer::common;
 
 namespace openminecraftshell::renderer
 {
+class OMWorldColorManager : public wrap::OMVoxelColorManager
+{
+    auto getSkyColor() -> glm::vec3 override
+    {
+        return {0.198, 0.371, 1.0};
+    }
+    auto getSkyDiscColor() -> glm::vec3 override
+    {
+        return {0.470, 0.654, 1.0};
+    }
+    auto getSkyDiskRange() -> float override
+    {
+        return 256.0f;
+    }
+    auto getSkyDiskHeight() -> float override
+    {
+        return -16.0f;
+    }
+    auto getFogRange() -> glm::vec2 override
+    {
+        return {0.0005, 0.0006};
+    }
+    auto getBlockTint() -> glm::vec3 override
+    {
+        return {1.0, 0.8, 0.6};
+    }
+    auto getSkyLightColor() -> glm::vec3 override
+    {
+        return {1.0, 1.0, 1.0};
+    }
+};
+static OMWorldColorManager *colorManager = new OMWorldColorManager;
 OMWorldRenderer::OMWorldRenderer(OMRenderer *renderer, std::shared_ptr<basics::OMCamera> camera,
                                  std::shared_ptr<OMChunkManager<16>> chunkManager)
     : OMRendererHandler(renderer), camera(std::move(camera)), logger("OMWorldRenderer", this), renderer(renderer)
@@ -80,7 +112,8 @@ OMWorldRenderer::OMWorldRenderer(OMRenderer *renderer, std::shared_ptr<basics::O
             uint64_t h = (cx * 16 + x) * 341873128712L + (cy * 16 + y) * 132897987541L + cz * 16 + z + 1L;
             h ^= h >> 16;
             return blockstateResolver->fetchModel(reg.block, reg.state, h);
-        });
+        },
+        colorManager);
 
     voxelManager->bindCameraBuffer(cameraBuffer);
 }