feat(rendering): separate transparent blocks into discard and blend modes

CMakeLists.txt

@@ -123,6 +123,7 @@ add_executable(${PROJECT_NAME}
     src/gameplay/river_worm.cpp
     src/gameplay/river_path.cpp
     src/block.cpp
+    src/gameplay/vertex_data.cpp
 )
 
 if(CMAKE_BUILD_TYPE STREQUAL "Debug")

assets/data/block/air.toml

@@ -1,5 +1,7 @@
 id = 0
+is_blend = false
 is_cross_plane = false
+is_discard = true
 is_gas = true
 is_liquid = false
 is_passable = true

assets/data/block/dirt.toml

@@ -1,5 +1,7 @@
 id = 2
+is_blend = false
 is_cross_plane = false
+is_discard = false
 is_gas = false
 is_liquid = false
 is_passable = false

assets/data/block/grass.toml

@@ -1,5 +1,7 @@
 id = 9
+is_blend = false
 is_cross_plane = true
+is_discard = true
 is_gas = false
 is_liquid = false
 is_passable = true

assets/data/block/grass_block.toml

@@ -1,5 +1,7 @@
 id = 1
+is_blend = false
 is_cross_plane = false
+is_discard = false
 is_gas = false
 is_liquid = false
 is_passable = false

assets/data/block/leaf.toml

@@ -1,5 +1,7 @@
 id = 6
+is_blend = false
 is_cross_plane = false
+is_discard = true
 is_gas = false
 is_liquid = false
 is_passable = false

assets/data/block/log.toml

@@ -1,5 +1,7 @@
 id = 5
+is_blend = false
 is_cross_plane = false
+is_discard = false
 is_gas = false
 is_liquid = false
 is_passable = false

assets/data/block/sand.toml

@@ -1,5 +1,7 @@
 id = 4
+is_blend = false
 is_cross_plane = false
+is_discard = false
 is_gas = false
 is_liquid = false
 is_passable = false

assets/data/block/snowy_grass_block.toml

@@ -1,5 +1,7 @@
 id = 8
+is_blend = false
 is_cross_plane = false
+is_discard = false
 is_gas = false
 is_liquid = false
 is_passable = false

assets/data/block/stone.toml

@@ -1,5 +1,7 @@
 id = 3
+is_blend = false
 is_cross_plane = false
+is_discard = false
 is_gas = false
 is_liquid = false
 is_passable = false

assets/data/block/template.toml

@@ -5,3 +5,5 @@ is_gas = false
 is_passable = false
 is_cross_plane = false
 is_transparent = false
+is_discard = false
+is_blend = false

assets/data/block/water.toml

@@ -1,5 +1,7 @@
 id = 7
+is_blend = true
 is_cross_plane = false
+is_discard = false
 is_gas = false
 is_liquid = true
 is_passable = true

assets/shaders/block_f_shader.glsl

@@ -8,7 +8,7 @@ layout (binding = 0) uniform sampler2DArray samp;
 
 void main(void) {
     color = texture(samp, vec3(tc, tex_layer));
-    if (color.a < 0.1) {
+    if (color.a < 0.45) {
         discard;
     }
     //color = varyingColor;

include/Cubed/gameplay/block.hpp

@@ -47,11 +47,16 @@ struct BlockData {
     bool is_passable = false;
     bool is_cross_plane = false;
     bool is_transparent = false;
+
+    bool is_discard = false;
+    bool is_blend = false;
+
     BlockData(BlockType b_id, std::string_view b_name, bool liquid,
-              bool passable, bool cross_plane, bool transparent, bool gas)
+              bool passable, bool cross_plane, bool transparent, bool gas,
+              bool discard, bool blend)
         : name(b_name), id(b_id), is_liquid(liquid), is_gas(gas),
           is_passable(passable), is_cross_plane(cross_plane),
-          is_transparent(transparent) {}
+          is_transparent(transparent), is_discard(discard), is_blend(blend) {}
 };
 
 class BlockManager {
@@ -69,6 +74,10 @@ public:
     static bool is_cross_plane(BlockType id);
     static bool is_transparent(BlockType id);
     static bool is_passable(BlockType id);
+
+    static bool is_discard(BlockType id);
+    static bool is_blend(BlockType id);
+
     static BlockType cross_plane_index(BlockType id);
 
 private:

include/Cubed/gameplay/chunk.hpp

@@ -4,7 +4,7 @@
 #include "Cubed/gameplay/block.hpp"
 #include "Cubed/gameplay/chunk_generator.hpp"
 #include "Cubed/gameplay/chunk_pos.hpp"
-#include "Cubed/primitive_data.hpp"
+#include "Cubed/gameplay/vertex_data.hpp"
 
 #include <atomic>
 #include <mutex>
@@ -17,13 +17,10 @@ private:
     static constexpr int SIZE_X = CHUNK_SIZE;
     static constexpr int SIZE_Y = WORLD_SIZE_Y;
     static constexpr int SIZE_Z = CHUNK_SIZE;
-
+    static constexpr int VERTEX_DATA_SUM = 4;
     std::atomic<bool> m_dirty{false};
     std::atomic<bool> m_need_upload{true};
     std::atomic<bool> m_is_on_gen_vertex_data{false};
-    std::atomic<size_t> m_normal_vertices_sum = 0;
-    std::atomic<size_t> m_cross_vertices_sum = 0;
-    std::atomic<size_t> m_transparent_vertices_sum = 0;
     std::atomic<BiomeType> m_biome = BiomeType::PLAIN;
     std::mutex m_vertexs_data_mutex;
 
@@ -34,12 +31,14 @@ private:
     HeightMapArray m_heightmap;
     // the index is a array of block id
     std::vector<BlockType> m_blocks;
-    GLuint m_normal_vbo = 0;
+
-    GLuint m_cross_plane_vbo = 0;
+    /*
-    GLuint m_transparent_normal_vbo = 0;
+    0 - normal
-    std::vector<Vertex> m_normal_vertices;
+    1 - cross_plane
-    std::vector<Vertex> m_cross_plane_vertices;
+    2 - normal_discard
-    std::vector<Vertex> m_transparent_normal_vertices;
+    3 - transparent and blend
+    */
+    std::vector<VertexData> m_vertex_data;
     float frequency = 0.01f;
     float height = 80;
     unsigned m_seed = 0;
@@ -47,9 +46,10 @@ private:
     BiomeConditions m_conditions;
 
     void clear_dirty();
-    void gen_normal_vertices(
+    void gen_vertices(
         const std::array<const std::vector<BlockType>*, 4>& neighbor_block);
-    void gen_cross_plane_vertices();
+    void gen_cross_plane_vertices(int world_x, int world_y, int world_z,
+                                  BlockType id);
 
 public:
     Chunk(World& world, ChunkPos chunk_pos);
@@ -107,8 +107,11 @@ public:
     GLuint get_cross_vbo() const;
     size_t get_cross_vertices_sum() const;
 
-    GLuint get_transparent_vbo() const;
+    GLuint get_normal_discard_vbo() const;
-    size_t get_transparent_vertices_sum() const;
+    size_t get_normal_discard_vertices_sum() const;
+
+    GLuint get_normal_blend_vbo() const;
+    size_t get_normal_blend_vertices_sum() const;
 
     bool is_dirty() const;
     void mark_dirty();

include/Cubed/gameplay/vertex_data.hpp

@@ -0,0 +1,24 @@
+#pragma once
+#include "Cubed/primitive_data.hpp"
+
+#include <atomic>
+#include <glad/glad.h>
+#include <vector>
+namespace Cubed {
+class World;
+struct VertexData {
+    std::vector<Vertex> m_vertices;
+    GLuint m_vbo = 0;
+    std::atomic<std::size_t> m_sum{0};
+    World& m_world;
+    VertexData(World& world);
+    ~VertexData();
+    VertexData(const VertexData&) = delete;
+    VertexData(VertexData&&) noexcept;
+    VertexData& operator=(const VertexData&) = delete;
+    VertexData& operator=(VertexData&&) noexcept;
+
+    void upload();
+    void update_sum();
+};
+} // namespace Cubed

include/Cubed/gameplay/world.hpp

@@ -19,8 +19,10 @@ struct ChunkRenderSnapshot {
     size_t normal_vertices_count;
     GLuint cross_vbo;
     size_t cross_vertices_count;
-    GLuint transparent_vbo;
+    GLuint normal_discard_vbo;
-    size_t transparent_vertices_count;
+    size_t normal_discard_vertices_count;
+    GLuint normal_blend_vbo;
+    size_t normal_blend_vertices_count;
     glm::vec3 center;
     glm::vec3 half_extents;
 };

src/block.cpp

@@ -90,6 +90,21 @@ bool BlockManager::is_passable(BlockType id) {
     return m_datas[id].is_passable;
 }
 
+bool BlockManager::is_discard(BlockType id) {
+    if (id >= sums()) {
+        Logger::error("Id {}, is Over The Max Id", id, sums() - 1);
+        return m_datas[0].is_discard;
+    }
+    return m_datas[id].is_discard;
+}
+bool BlockManager::is_blend(BlockType id) {
+    if (id >= sums()) {
+        Logger::error("Id {}, is Over The Max Id", id, sums() - 1);
+        return m_datas[0].is_blend;
+    }
+    return m_datas[id].is_blend;
+}
+
 void BlockManager::init() {
     fs::path data_path{block_data_dir};
 
@@ -125,8 +140,11 @@ void BlockManager::init() {
         auto is_cross_plane = safe_get_value(block, "is_cross_plane", false);
         auto is_transparent = safe_get_value(block, "is_transparent", false);
         auto is_gas = safe_get_value(block, "is_gas", false);
+        auto is_discard = safe_get_value(block, "is_discard", false);
+        auto is_blend = safe_get_value(block, "is_blend", false);
         m_datas.emplace_back(*id, *name, *is_liquid, *is_passable,
-                             *is_cross_plane, *is_transparent, *is_gas);
+                             *is_cross_plane, *is_transparent, *is_gas,
+                             *is_discard, *is_blend);
     }
     std::sort(
         m_datas.begin(), m_datas.end(),

src/gameplay/chunk.cpp

@@ -9,65 +9,36 @@
 namespace Cubed {
 
 Chunk::Chunk(World& world, ChunkPos chunk_pos)
-    : m_chunk_pos(chunk_pos), m_world(world) {}
+    : m_chunk_pos(chunk_pos), m_world(world) {
-
+    for (int i = 0; i < VERTEX_DATA_SUM; i++) {
-Chunk::~Chunk() {
+        m_vertex_data.emplace_back(m_world);
-    if (m_normal_vbo != 0) {
-        m_world.push_delete_vbo(m_normal_vbo);
-    }
-    if (m_cross_plane_vbo != 0) {
-        m_world.push_delete_vbo(m_cross_plane_vbo);
-    }
-    if (m_transparent_normal_vbo != 0) {
-        m_world.push_delete_vbo(m_transparent_normal_vbo);
     }
 }
 
+Chunk::~Chunk() {}
+
 Chunk::Chunk(Chunk&& other) noexcept
     : m_dirty(other.is_dirty()), m_need_upload(other.m_need_upload.load()),
       m_is_on_gen_vertex_data(other.m_is_on_gen_vertex_data.load()),
-      m_normal_vertices_sum(other.m_normal_vertices_sum.load()),
-      m_cross_vertices_sum(other.m_cross_vertices_sum.load()),
-      m_transparent_vertices_sum(other.m_transparent_vertices_sum.load()),
       m_biome(other.m_biome.load()), m_chunk_pos(std::move(other.m_chunk_pos)),
       m_world(other.m_world), m_heightmap(std::move(other.m_heightmap)),
-      m_blocks(std::move(other.m_blocks)), m_normal_vbo(other.m_normal_vbo),
+      m_blocks(std::move(other.m_blocks)),
-      m_cross_plane_vbo(other.m_cross_plane_vbo),
+      m_vertex_data(std::move(other.m_vertex_data)), m_seed(other.m_seed),
-      m_transparent_normal_vbo(other.m_transparent_normal_vbo),
+      m_conditions(other.m_conditions) {}
-      m_normal_vertices(std::move(other.m_normal_vertices)),
-      m_cross_plane_vertices(std::move(other.m_cross_plane_vertices)),
-      m_transparent_normal_vertices(
-          std::move(other.m_transparent_normal_vertices)),
-      m_seed(other.m_seed), m_conditions(other.m_conditions) {
-    other.m_normal_vbo = 0;
-    other.m_cross_plane_vbo = 0;
-    other.m_transparent_normal_vbo = 0;
-}
 
 Chunk& Chunk::operator=(Chunk&& other) noexcept {
     // Logger::info("other Chunk pos {} {} in Chunk& Chunk::operator=(Chunk&&
     // other) this {}", other.m_chunk_pos.x, other.m_chunk_pos.z,
     // static_cast<const void*>(&other));
-    m_normal_vbo = other.m_normal_vbo;
+
-    other.m_normal_vbo = 0;
-    m_cross_plane_vbo = other.m_cross_plane_vbo;
-    m_transparent_normal_vbo = other.m_transparent_normal_vbo;
-    other.m_transparent_normal_vbo = 0;
-    other.m_cross_plane_vbo = 0;
     m_chunk_pos = std::move(other.m_chunk_pos);
     m_heightmap = std::move(other.m_heightmap);
     m_blocks = std::move(other.m_blocks);
     m_dirty = other.is_dirty();
-    m_normal_vertices = std::move(other.m_normal_vertices);
+    m_vertex_data = std::move(other.m_vertex_data);
-    m_cross_plane_vertices = std::move(other.m_cross_plane_vertices);
-    m_transparent_normal_vertices =
-        std::move(other.m_transparent_normal_vertices);
     m_biome = other.m_biome.load();
     m_is_on_gen_vertex_data = other.m_is_on_gen_vertex_data.load();
     m_need_upload = other.m_need_upload.load();
-    m_normal_vertices_sum = other.m_normal_vertices_sum.load();
-    m_cross_vertices_sum = other.m_cross_vertices_sum.load();
-    m_transparent_vertices_sum = other.m_transparent_vertices_sum.load();
     m_seed = other.m_seed;
     m_conditions = other.m_conditions;
     return *this;
@@ -139,29 +110,41 @@ void Chunk::gen_vertex_data(
     }
     m_is_on_gen_vertex_data = true;
     std::lock_guard lk(m_vertexs_data_mutex);
-    gen_normal_vertices(neighbor_block);
+
-    gen_cross_plane_vertices();
+    for (auto& data : m_vertex_data) {
+        data.m_vertices.clear();
+    }
+
+    gen_vertices(neighbor_block);
+    for (auto& data : m_vertex_data) {
+        data.update_sum();
+    }
     m_need_upload = true;
     m_is_on_gen_vertex_data = false;
 }
 
-GLuint Chunk::get_normal_vbo() const { return m_normal_vbo; }
+GLuint Chunk::get_normal_vbo() const { return m_vertex_data[0].m_vbo; }
 
 size_t Chunk::get_normal_vertices_sum() const {
-    if (m_normal_vertices_sum == 0) {
+    if (m_vertex_data[0].m_sum == 0) {
         Logger::warn("m_normal_vertices_sum is 0");
     }
-    return m_normal_vertices_sum.load();
+    return m_vertex_data[0].m_sum.load();
 }
 
-GLuint Chunk::get_cross_vbo() const { return m_cross_plane_vbo; }
+GLuint Chunk::get_cross_vbo() const { return m_vertex_data[1].m_vbo; }
 size_t Chunk::get_cross_vertices_sum() const {
-    return m_cross_vertices_sum.load();
+    return m_vertex_data[1].m_sum.load();
 }
 
-GLuint Chunk::get_transparent_vbo() const { return m_transparent_normal_vbo; }
+GLuint Chunk::get_normal_discard_vbo() const { return m_vertex_data[2].m_vbo; }
-size_t Chunk::get_transparent_vertices_sum() const {
+size_t Chunk::get_normal_discard_vertices_sum() const {
-    return m_transparent_vertices_sum.load();
+    return m_vertex_data[2].m_sum.load();
+}
+
+GLuint Chunk::get_normal_blend_vbo() const { return m_vertex_data[3].m_vbo; }
+size_t Chunk::get_normal_blend_vertices_sum() const {
+    return m_vertex_data[3].m_sum.load();
 }
 
 void Chunk::gen_phase_one() {
@@ -235,33 +218,12 @@ void Chunk::upload_to_gpu() {
 
     ASSERT(is_need_upload());
 
-    if (m_normal_vbo == 0) {
+    std::lock_guard lk(m_vertexs_data_mutex);
-        glGenBuffers(1, &m_normal_vbo);
+
+    for (auto& data : m_vertex_data) {
+        data.upload();
     }
 
-    std::lock_guard lk(m_vertexs_data_mutex);
-    glBindBuffer(GL_ARRAY_BUFFER, m_normal_vbo);
-    glBufferData(GL_ARRAY_BUFFER, m_normal_vertices.size() * sizeof(Vertex),
-                 m_normal_vertices.data(), GL_DYNAMIC_DRAW);
-    glBindBuffer(GL_ARRAY_BUFFER, 0);
-    if (m_cross_plane_vertices.size() != 0) {
-        if (m_cross_plane_vbo == 0) {
-            glGenBuffers(1, &m_cross_plane_vbo);
-        }
-        glBindBuffer(GL_ARRAY_BUFFER, m_cross_plane_vbo);
-        glBufferData(GL_ARRAY_BUFFER,
-                     m_cross_plane_vertices.size() * sizeof(Vertex),
-                     m_cross_plane_vertices.data(), GL_DYNAMIC_DRAW);
-    }
-    if (m_transparent_normal_vertices.size() != 0) {
-        if (m_transparent_normal_vbo == 0) {
-            glGenBuffers(1, &m_transparent_normal_vbo);
-        }
-        glBindBuffer(GL_ARRAY_BUFFER, m_transparent_normal_vbo);
-        glBufferData(GL_ARRAY_BUFFER,
-                     m_transparent_normal_vertices.size() * sizeof(Vertex),
-                     m_transparent_normal_vertices.data(), GL_DYNAMIC_DRAW);
-    }
     // after fininshed it, can use
     clear_dirty();
     m_need_upload = false;
@@ -300,10 +262,8 @@ unsigned Chunk::seed() const {
 
 BiomeConditions& Chunk::conditions() { return m_conditions; }
 
-void Chunk::gen_normal_vertices(
+void Chunk::gen_vertices(
     const std::array<const std::vector<BlockType>*, 4>& neighbor_block) {
-    m_normal_vertices.clear();
-    m_transparent_normal_vertices.clear();
     static const glm::ivec3 DIR[6] = {{0, 0, 1},  {1, 0, 0}, {0, 0, -1},
                                       {-1, 0, 0}, {0, 1, 0}, {0, -1, 0}};
 
@@ -399,6 +359,10 @@ void Chunk::gen_normal_vertices(
                     if (neighbor_culled) {
                         continue;
                     }
+                    if (BlockManager::is_cross_plane(cur_id)) {
+                        gen_cross_plane_vertices(world_x, world_y, world_z,
+                                                 cur_id);
+                    }
                     for (int i = 0; i < 6; i++) {
                         Vertex vex = {
                             VERTICES_POS[face][i][0] + (float)world_x * 1.0f,
@@ -410,55 +374,50 @@ void Chunk::gen_normal_vertices(
 
                         };
                         if (BlockManager::is_transparent(cur_id)) {
-                            m_transparent_normal_vertices.emplace_back(vex);
+                            if (BlockManager::is_discard(cur_id)) {
+                                m_vertex_data[2].m_vertices.emplace_back(vex);
+                            } else if (BlockManager::is_blend(cur_id)) {
+                                m_vertex_data[3].m_vertices.emplace_back(vex);
                             } else {
-                            m_normal_vertices.emplace_back(vex);
+                                Logger::warn("Id {} is transparent but not "
+                                             "discard or blend",
+                                             cur_id);
+                                m_vertex_data[3].m_vertices.emplace_back(vex);
+                            }
+
+                        } else {
+                            m_vertex_data[0].m_vertices.emplace_back(vex);
                         }
                     }
                 }
             }
         }
     }
-    m_normal_vertices_sum = m_normal_vertices.size();
-    m_transparent_vertices_sum = m_transparent_normal_vertices.size();
 }
-void Chunk::gen_cross_plane_vertices() {
+void Chunk::gen_cross_plane_vertices(int world_x, int world_y, int world_z,
-
+                                     BlockType id) {
-    m_cross_plane_vertices.clear();
-
-    for (int x = 0; x < SIZE_X; x++) {
-        for (int y = 0; y < SIZE_Y; y++) {
-            for (int z = 0; z < SIZE_Z; z++) {
-                int world_x = x + m_chunk_pos.x * CHUNK_SIZE;
-                int world_z = z + m_chunk_pos.z * CHUNK_SIZE;
-                int world_y = y;
-                int id = m_blocks[index(x, y, z)];
 
     if (!BlockManager::is_cross_plane(id)) {
-                    continue;
+        Logger::warn("Block {} {} {} id {} is not cross plane", world_x,
+                     world_y, world_z, id);
+        return;
     }
     for (int face = 0; face < 2; face++) {
         for (int i = 0; i < 6; i++) {
-                        Vertex vex = {CROSS_VERTICES_POS[face][i][0] +
+            Vertex vex = {
-                                          (float)world_x * 1.0f,
+                CROSS_VERTICES_POS[face][i][0] + (float)world_x * 1.0f,
-                                      CROSS_VERTICES_POS[face][i][1] +
+                CROSS_VERTICES_POS[face][i][1] + (float)world_y * 1.0f,
-                                          (float)world_y * 1.0f,
+                CROSS_VERTICES_POS[face][i][2] + (float)world_z * 1.0f,
-                                      CROSS_VERTICES_POS[face][i][2] +
-                                          (float)world_z * 1.0f,
                 CROSS_TEX_COORDS[face][i][0],
                 CROSS_TEX_COORDS[face][i][1],
-                                      static_cast<float>(
+                static_cast<float>(BlockManager::cross_plane_index(id))
-                                          BlockManager::cross_plane_index(id))
 
             };
-                        m_cross_plane_vertices.emplace_back(vex);
+            m_vertex_data[1].m_vertices.emplace_back(vex);
         }
     }
-            }
-        }
-    }
-    m_cross_vertices_sum = m_cross_plane_vertices.size();
-    // Logger::info("Cross Sum {}", m_cross_vertices_sum.load());
 }
 
+// Logger::info("Cross Sum {}", m_cross_vertices_sum.load());
+
 } // namespace Cubed

src/gameplay/vertex_data.cpp

@@ -0,0 +1,39 @@
+#include "Cubed/gameplay/vertex_data.hpp"
+
+#include "Cubed/gameplay/world.hpp"
+
+namespace Cubed {
+VertexData::VertexData(World& world) : m_world(world) {}
+VertexData::~VertexData() {
+    if (m_vbo != 0) {
+        m_world.push_delete_vbo(m_vbo);
+    }
+}
+VertexData::VertexData(VertexData&& o) noexcept
+    : m_vertices(std::move(o.m_vertices)), m_vbo(o.m_vbo),
+      m_sum(o.m_sum.load()), m_world(o.m_world) {
+    o.m_vbo = 0;
+    o.m_sum = 0;
+}
+VertexData& VertexData::operator=(VertexData&& o) noexcept {
+    m_vbo = o.m_vbo;
+    o.m_vbo = 0;
+    m_sum = o.m_sum.load();
+    o.m_sum = 0;
+    m_vertices = std::move(o.m_vertices);
+    return *this;
+}
+void VertexData::upload() {
+    if (m_vertices.size() == 0) {
+        return;
+    }
+    if (m_vbo == 0) {
+        glGenBuffers(1, &m_vbo);
+    }
+    glBindBuffer(GL_ARRAY_BUFFER, m_vbo);
+    glBufferData(GL_ARRAY_BUFFER, m_vertices.size() * sizeof(Vertex),
+                 m_vertices.data(), GL_DYNAMIC_DRAW);
+    glBindBuffer(GL_ARRAY_BUFFER, 0);
+}
+void VertexData::update_sum() { m_sum = m_vertices.size(); }
+} // namespace Cubed

src/gameplay/world.cpp

@@ -319,46 +319,17 @@ void World::render(const glm::mat4& mvp_matrix,
             rendered_sum++;
         }
     }
-    glDepthMask(GL_FALSE);
+    // cross_plane and normal discard
-
-    struct SortableSnapshot {
-        const ChunkRenderSnapshot* snapshot;
-        float distance;
-    };
-
-    std::vector<SortableSnapshot> cross_list;
-    std::vector<SortableSnapshot> transparent_list;
 
     for (const auto& snapshot : m_render_snapshots) {
-
         if (!is_aabb_in_frustum(snapshot.center, snapshot.half_extents)) {
             continue;
         }
-
-        float dist = glm::distance(camera_pos, snapshot.center);
         glm::vec2 camera_pos_xz{camera_pos.x, camera_pos.z};
         if (snapshot.cross_vertices_count != 0) {
             glm::vec2 center_xz{snapshot.center.x, snapshot.center.z};
             float dist2d = glm::distance(camera_pos_xz, center_xz);
             if (dist2d <= CROSS_PLANE_DISTANCE * 16) {
-                cross_list.push_back({&snapshot, dist});
-            }
-        }
-        if (snapshot.transparent_vertices_count != 0) {
-            transparent_list.push_back({&snapshot, dist});
-        }
-    }
-    std::sort(transparent_list.begin(), transparent_list.end(),
-              [](const SortableSnapshot& a, const SortableSnapshot& b) {
-                  return a.distance > b.distance;
-              });
-    std::sort(cross_list.begin(), cross_list.end(),
-              [](const SortableSnapshot& a, const SortableSnapshot& b) {
-                  return a.distance > b.distance;
-              });
-
-    for (const auto& item : cross_list) {
-        const auto& snapshot = *item.snapshot;
                 glBindTexture(GL_TEXTURE_2D_ARRAY,
                               texture_manager.get_cross_plane_array());
                 glBindBuffer(GL_ARRAY_BUFFER, snapshot.cross_vbo);
@@ -376,11 +347,11 @@ void World::render(const glm::mat4& mvp_matrix,
                 glDrawArrays(GL_TRIANGLES, 0, snapshot.cross_vertices_count);
                 glBindBuffer(GL_ARRAY_BUFFER, 0);
             }
-
+        }
-    for (const auto& item : transparent_list) {
+        if (snapshot.normal_discard_vertices_count != 0) {
-        const auto& snapshot = *item.snapshot;
+            glBindTexture(GL_TEXTURE_2D_ARRAY,
-        glBindTexture(GL_TEXTURE_2D_ARRAY, texture_manager.get_texture_array());
+                          texture_manager.get_texture_array());
-        glBindBuffer(GL_ARRAY_BUFFER, snapshot.transparent_vbo);
+            glBindBuffer(GL_ARRAY_BUFFER, snapshot.normal_discard_vbo);
             glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex),
                                   (void*)0);
             glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex),
@@ -392,7 +363,55 @@ void World::render(const glm::mat4& mvp_matrix,
             glEnableVertexAttribArray(1);
             glEnableVertexAttribArray(2);
 
-        glDrawArrays(GL_TRIANGLES, 0, snapshot.transparent_vertices_count);
+            glDrawArrays(GL_TRIANGLES, 0,
+                         snapshot.normal_discard_vertices_count);
+            glBindBuffer(GL_ARRAY_BUFFER, 0);
+        }
+    }
+
+    // blend block
+
+    glDepthMask(GL_FALSE);
+
+    struct SortableSnapshot {
+        const ChunkRenderSnapshot* snapshot;
+        float distance;
+    };
+
+    std::vector<SortableSnapshot> blend_list;
+
+    for (const auto& snapshot : m_render_snapshots) {
+
+        if (!is_aabb_in_frustum(snapshot.center, snapshot.half_extents)) {
+            continue;
+        }
+
+        float dist = glm::distance(camera_pos, snapshot.center);
+        if (snapshot.normal_blend_vertices_count != 0) {
+            blend_list.push_back({&snapshot, dist});
+        }
+    }
+    std::sort(blend_list.begin(), blend_list.end(),
+              [](const SortableSnapshot& a, const SortableSnapshot& b) {
+                  return a.distance > b.distance;
+              });
+
+    for (const auto& item : blend_list) {
+        const auto& snapshot = *item.snapshot;
+        glBindTexture(GL_TEXTURE_2D_ARRAY, texture_manager.get_texture_array());
+        glBindBuffer(GL_ARRAY_BUFFER, snapshot.normal_blend_vbo);
+        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex),
+                              (void*)0);
+        glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex),
+                              (void*)offsetof(Vertex, s));
+        glVertexAttribPointer(2, 1, GL_FLOAT, GL_FALSE, sizeof(Vertex),
+                              (void*)offsetof(Vertex, layer));
+
+        glEnableVertexAttribArray(0);
+        glEnableVertexAttribArray(1);
+        glEnableVertexAttribArray(2);
+
+        glDrawArrays(GL_TRIANGLES, 0, snapshot.normal_blend_vertices_count);
         glBindBuffer(GL_ARRAY_BUFFER, 0);
     }
 
@@ -966,8 +985,10 @@ void World::update(float delta_time) {
                 m_render_snapshots.push_back(
                     {chunk.get_normal_vbo(), chunk.get_normal_vertices_sum(),
                      chunk.get_cross_vbo(), chunk.get_cross_vertices_sum(),
-                     chunk.get_transparent_vbo(),
+                     chunk.get_normal_discard_vbo(),
-                     chunk.get_transparent_vertices_sum(),
+                     chunk.get_normal_discard_vertices_sum(),
+                     chunk.get_normal_blend_vbo(),
+                     chunk.get_normal_blend_vertices_sum(),
                      glm::vec3(static_cast<float>(pos.x * CHUNK_SIZE) +
                                    static_cast<float>(CHUNK_SIZE / 2),
                                static_cast<float>(WORLD_SIZE_Y / 2),