new turn style

[blank.git] / src / world / chunk.cpp

diff --git a/src/world/chunk.cpp b/src/world/chunk.cpp
index baad4466cde01790851b5f8877e2350d4e8a53b5..ef9f578fa3e90dd9c90a1336925e086c1d0b3611 100644 (file)
--- a/src/world/chunk.cpp
+++ b/src/world/chunk.cpp
@@ -9,9 +9,9 @@
 #include "WorldCollision.hpp"
 #include "../app/Assets.hpp"
 #include "../graphics/BlockLighting.hpp"
+#include "../graphics/BlockMesh.hpp"
 #include "../graphics/Viewport.hpp"
 #include "../io/WorldSave.hpp"
-#include "../model/BlockModel.hpp"
 
 #include <algorithm>
 #include <limits>
@@ -36,19 +36,23 @@ Chunk::Chunk(const BlockTypeRegistry &types) noexcept
 , lighted(false)
 , position(0, 0, 0)
 , ref_count(0)
-, dirty_model(false)
+, dirty_mesh(false)
 , dirty_save(false) {
 
 }
 
 Chunk::Chunk(Chunk &&other) noexcept
 : types(other.types)
+, generated(other.generated)
+, lighted(other.lighted)
 , position(other.position)
-, dirty_model(other.dirty_model)
+, ref_count(other.ref_count)
+, dirty_mesh(other.dirty_mesh)
 , dirty_save(other.dirty_save) {
        std::copy(other.neighbor, other.neighbor + sizeof(neighbor), neighbor);
        std::copy(other.blocks, other.blocks + sizeof(blocks), blocks);
        std::copy(other.light, other.light + sizeof(light), light);
+       other.ref_count = 0;
 }
 
 Chunk &Chunk::operator =(Chunk &&other) noexcept {
@@ -56,8 +60,11 @@ Chunk &Chunk::operator =(Chunk &&other) noexcept {
        std::copy(other.neighbor, other.neighbor + sizeof(neighbor), neighbor);
        std::copy(other.blocks, other.blocks + sizeof(blocks), blocks);
        std::copy(other.light, other.light + sizeof(light), light);
+       generated = other.generated;
+       lighted = other.lighted;
        position = other.position;
-       dirty_model = other.dirty_save;
+       std::swap(ref_count, other.ref_count);
+       dirty_mesh = other.dirty_save;
        dirty_save = other.dirty_save;
        return *this;
 }
@@ -246,7 +253,7 @@ int Chunk::GetLight(int index) const noexcept {
        return light[index];
 }
 
-float Chunk::GetVertexLight(const Pos &pos, const BlockModel::Position &vtx, const EntityModel::Normal &norm) const noexcept {
+float Chunk::GetVertexLight(const Pos &pos, const BlockMesh::Position &vtx, const EntityMesh::Normal &norm) const noexcept {
        int index = ToIndex(pos);
        float light = GetLight(index);
 
@@ -364,7 +371,7 @@ bool Chunk::Intersection(
                for (int y = 0; y < height; ++y) {
                        for (int x = 0; x < width; ++x, ++idx) {
                                const BlockType &type = Type(idx);
-                               if (!type.visible) {
+                               if (!type.collision || !type.shape) {
                                        continue;
                                }
                                float cur_dist;
@@ -405,7 +412,7 @@ bool Chunk::Intersection(
                for (int y = 0; y < height; ++y) {
                        for (int x = 0; x < width; ++x, ++idx) {
                                const BlockType &type = Type(idx);
-                               if (!type.collision) {
+                               if (!type.collision || !type.shape) {
                                        continue;
                                }
                                if (type.shape->Intersects(Mchunk * ToTransform(Pos(x, y, z), idx), box, Mbox, penetration, normal)) {
@@ -421,47 +428,51 @@ bool Chunk::Intersection(
 
 namespace {
 
-BlockModel::Buffer buf;
+BlockMesh::Buffer buf;
 
 }
 
-void Chunk::Update(BlockModel &model) noexcept {
+void Chunk::Update(BlockMesh &model) noexcept {
        int vtx_count = 0, idx_count = 0;
        for (const auto &block : blocks) {
-               const Shape *shape = Type(block).shape;
-               vtx_count += shape->VertexCount();
-               idx_count += shape->VertexIndexCount();
+               const BlockType &type = Type(block);
+               if (type.visible && type.shape) {
+                       vtx_count += type.shape->VertexCount();
+                       idx_count += type.shape->IndexCount();
+               }
        }
        buf.Clear();
        buf.Reserve(vtx_count, idx_count);
 
-       int idx = 0;
-       BlockModel::Index vtx_counter = 0;
-       for (size_t z = 0; z < depth; ++z) {
-               for (size_t y = 0; y < height; ++y) {
-                       for (size_t x = 0; x < width; ++x, ++idx) {
-                               const BlockType &type = Type(BlockAt(idx));
-                               const Pos pos(x, y, z);
-
-                               if (!type.visible || Obstructed(pos).All()) continue;
-
-                               type.FillBlockModel(buf, ToTransform(pos, idx), vtx_counter);
-                               size_t vtx_begin = vtx_counter;
-                               vtx_counter += type.shape->VertexCount();
-
-                               for (size_t vtx = vtx_begin; vtx < vtx_counter; ++vtx) {
-                                       buf.lights.emplace_back(GetVertexLight(
-                                               pos,
-                                               buf.vertices[vtx],
-                                               type.shape->VertexNormal(vtx - vtx_begin, BlockAt(idx).Transform())
-                                       ));
+       if (idx_count > 0) {
+               int idx = 0;
+               BlockMesh::Index vtx_counter = 0;
+               for (size_t z = 0; z < depth; ++z) {
+                       for (size_t y = 0; y < height; ++y) {
+                               for (size_t x = 0; x < width; ++x, ++idx) {
+                                       const BlockType &type = Type(BlockAt(idx));
+                                       const Pos pos(x, y, z);
+
+                                       if (!type.visible || !type.shape || Obstructed(pos).All()) continue;
+
+                                       type.FillBlockMesh(buf, ToTransform(pos, idx), vtx_counter);
+                                       size_t vtx_begin = vtx_counter;
+                                       vtx_counter += type.shape->VertexCount();
+
+                                       for (size_t vtx = vtx_begin; vtx < vtx_counter; ++vtx) {
+                                               buf.lights.emplace_back(GetVertexLight(
+                                                       pos,
+                                                       buf.vertices[vtx],
+                                                       type.shape->VertexNormal(vtx - vtx_begin, BlockAt(idx).Transform())
+                                               ));
+                                       }
                                }
                        }
                }
        }
 
        model.Update(buf);
-       ClearModel();
+       ClearMesh();
 }
 
 Block::FaceSet Chunk::Obstructed(const Pos &pos) const noexcept {
@@ -625,9 +636,13 @@ bool ChunkLoader::LoadOne() {
                        for (iter.x = begin.x; iter.x < end.x; ++iter.x) {
                                if (index->IsBorder(iter)) continue;
                                Chunk *light_chunk = index->Get(iter);
-                               if (!light_chunk || light_chunk->Lighted()) continue;
+                               if (!light_chunk) continue;
                                if (index->HasAllSurrounding(iter)) {
-                                       light_chunk->ScanLights();
+                                       if (!light_chunk->Lighted()) {
+                                               light_chunk->ScanLights();
+                                       } else {
+                                               light_chunk->InvalidateMesh();
+                                       }
                                }
                        }
                }
@@ -660,7 +675,7 @@ int ChunkRenderer::MissingChunks() const noexcept {
        return index.MissingChunks();
 }
 
-void ChunkRenderer::LoadTextures(const AssetLoader &loader, const TextureIndex &tex_index) {
+void ChunkRenderer::LoadTextures(const AssetLoader &loader, const ResourceIndex &tex_index) {
        block_tex.Bind();
        loader.LoadTextures(tex_index, block_tex);
        block_tex.FilterNearest();
@@ -672,7 +687,7 @@ void ChunkRenderer::Update(int dt) {
                if (!index[i]->Lighted() && index.HasAllSurrounding(index[i]->Position())) {
                        index[i]->ScanLights();
                }
-               if (index[i]->ShouldUpdateModel()) {
+               if (index[i]->ShouldUpdateMesh()) {
                        index[i]->Update(models[i]);
                        ++updates;
                }
@@ -689,7 +704,7 @@ void ChunkRenderer::Render(Viewport &viewport) {
                glm::mat4 m(index[i]->Transform(index.Base()));
                glm::mat4 mvp(chunk_prog.GetVP() * m);
                if (!CullTest(Chunk::Bounds(), mvp)) {
-                       if (index[i]->ShouldUpdateModel()) {
+                       if (index[i]->ShouldUpdateMesh()) {
                                index[i]->Update(models[i]);
                        }
                        chunk_prog.SetM(m);
@@ -1023,7 +1038,7 @@ void ChunkStore::Clean() {
                        ++i;
                        free.splice(free.end(), loaded, chunk);
                        chunk->Unlink();
-                       chunk->InvalidateModel();
+                       chunk->InvalidateMesh();
                }
        }
 }