12#include <glm/gtc/type_ptr.hpp>
16#include <unordered_set>
24 std::array<unsigned int, 2> ToMultipliers(
const std::vector<unsigned int>& v);
28 template<
class ChunkPtr>
30 std::unordered_map<
Position, std::shared_ptr<ChunkPtr>>& renderables,
32 std::atomic<bool>& dirty,
33 const int x,
const int z,
34 std::unordered_map<
Position, std::vector<Face>>&& new_faces
43 chunks = std::unordered_map<Position, std::shared_ptr<Chunk> >();
44 transparent_chunks = std::unordered_map<Position, std::shared_ptr<TransparentChunk> >();
49 entities = std::unordered_map<int, std::shared_ptr<Entity> >();
52 camera = std::make_shared<Camera>();
69 glBufferData(GL_UNIFORM_BUFFER,
sizeof(glm::mat4), NULL, GL_STATIC_DRAW);
70 glBindBuffer(GL_UNIFORM_BUFFER, 0);
79 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
80 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
81 float borderColor[] = { 1.0f, 1.0f, 1.0f, 1.0f };
82 glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, borderColor);
83 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST);
84 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
88 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, atlas->
GetWidth(), atlas->
GetHeight(), 0, GL_RGBA, GL_UNSIGNED_BYTE, atlas->
Get());
89 glGenerateMipmap(GL_TEXTURE_2D);
91 glBindTexture(GL_TEXTURE_2D, 0);
123 if (
camera->GetHasChangedOrientation() ||
camera->GetHasChangedPosition())
125 glm::mat4 view_matrix =
camera->GetViewMatrix();
126 if (
camera->GetHasChangedPosition())
131 it->second->MarkForSort();
135 camera->ResetHasChangedPosition();
136 camera->ResetHasChangedOrientation();
138 glBufferSubData(GL_UNIFORM_BUFFER, 0,
sizeof(glm::mat4), glm::value_ptr(view_matrix));
139 glBindBuffer(GL_UNIFORM_BUFFER, 0);
145 camera->SetProjection(proj);
157 it->second->Update();
158 it = it->second->GetNumFace() == 0 ?
chunks.erase(it) : std::next(it);
170 it->second->Update();
183 it->second->Update();
184 it = it->second->GetNumFace() == 0 ?
entities.erase(it) : std::next(it);
192 if (!chunk.has_value())
199 std::unordered_map<Position, std::vector<Face>> opaque_faces;
200 std::unordered_map<Position, std::vector<Face>> transparent_faces;
203 const std::vector<Position> neighbour_positions({
Position(0, -1, 0),
Position(0, 0, -1),
204 Position(-1, 0, 0),
Position(1, 0, 0),
Position(0, 0, 1),
Position(0, 1, 0) });
206 std::vector<const Blockstate*> neighbour_blockstates(6);
209 for (
int y = chunk->GetMinY(); y < chunk->GetHeight() + chunk->GetMinY(); ++y)
220 const Blockstate* this_block = chunk->GetBlock(pos);
221 if (this_block ==
nullptr || this_block->
IsAir())
227 for (
int i = 0; i < 6; ++i)
229 neighbour_blockstates[i] = chunk->GetBlock(pos + neighbour_positions[i]);
232 bool is_surrounded_by_opaque =
false;
234 for (
int i = 0; i < neighbour_positions.size(); ++i)
236 if (neighbour_blockstates[i] ==
nullptr ||
237 neighbour_blockstates[i]->IsTransparent())
244 if (i == neighbour_positions.size() - 1)
246 is_surrounded_by_opaque =
true;
250 if (is_surrounded_by_opaque)
263#if PROTOCOL_VERSION < 552
264 const Biome* current_biome = chunk->GetBiome(x, z);
266 const Biome* current_biome = chunk->GetBiome(x, y, z);
269 for (
int i = 0; i < current_faces.size(); ++i)
275 !neighbour_blockstates[
static_cast<int>(current_faces[i].cullface_direction)] ||
276 (neighbour_blockstates[
static_cast<int>(current_faces[i].cullface_direction)]->IsTransparent() &&
277 neighbour_blockstates[
static_cast<int>(current_faces[i].cullface_direction)]->GetName() != this_block->
GetName())
280 Face f = current_faces[i].face;
283 f.
GetMatrix()[12] +=
static_cast<float>(offset.
x) + 0.5f;
284 f.
GetMatrix()[13] +=
static_cast<float>(offset.
y) + 0.5f;
285 f.
GetMatrix()[14] +=
static_cast<float>(offset.
z) + 0.5f;
289 target[SectionOf(block_pos)].push_back(std::move(f));
305 if (it ==
entities.end() && faces.size() != 0)
307 entities[id] = std::make_shared<Entity>(faces);
310 else if (it !=
entities.end() && faces.size() == 0)
312 it->second->ClearFaces();
317 it->second->SetFaces(std::vector<Face>(faces.begin(), faces.end()));
333 for (
auto it =
chunks.begin(); it !=
chunks.end(); it++)
335 it->second->ClearFaces();
342 it->second->ClearFaces();
349 it->second->ClearFaces();
362 static_cast<float>(x_),
363 static_cast<float>(y_),
364 static_cast<float>(z_)
366 camera->SetRotation(pitch_, yaw_);
371 int* num_entities_,
int* num_rendered_entities_,
372 int* num_faces_,
int* num_rendered_faces_)
374 const std::array<glm::vec4, 6>& frustum_planes =
camera->GetFrustumPlanes();
377 std::unordered_set<Position> all_loaded_chunks;
382 for (
auto it =
chunks.begin(); it !=
chunks.end(); ++it)
384 all_loaded_chunks.insert(it->first);
385 num_faces += it->second->GetNumFace();
391 all_loaded_chunks.insert(it->first);
392 num_faces += it->second->GetNumFace();
395 const int num_chunks =
static_cast<int>(all_loaded_chunks.size());
398 std::vector<Position> chunks_to_render;
399 chunks_to_render.reserve(all_loaded_chunks.size());
400 std::unordered_map<Position, bool> inside_frustum;
402 for (
auto it = all_loaded_chunks.begin(); it != all_loaded_chunks.end(); ++it)
406 const float min_x =
static_cast<float>(
CHUNK_WIDTH * (*it).x);
407 const float max_x =
static_cast<float>(
CHUNK_WIDTH * ((*it).x + 1));
410 const float min_z =
static_cast<float>(
CHUNK_WIDTH * (*it).z);
411 const float max_z =
static_cast<float>(
CHUNK_WIDTH * ((*it).z + 1));
413 for (
int i = 0; i < 6; ++i)
415 const bool sign_x = frustum_planes[i].x > 0.0f;
416 const bool sign_y = frustum_planes[i].y > 0.0f;
417 const bool sign_z = frustum_planes[i].z > 0.0f;
419 const glm::vec4 p_vertex = glm::vec4(sign_x ? max_x : min_x, sign_y ? max_y : min_y, sign_z ? max_z : min_z, 1.0f);
421 if (glm::dot(frustum_planes[i], p_vertex) < 0.0f)
427 const glm::vec4 n_vertex = glm::vec4(sign_x ? min_x : max_x, sign_y ? min_y : max_y, sign_z ? min_z : max_z, 1.0f);
429 if (glm::dot(frustum_planes[i], n_vertex) < 0.0f)
438 chunks_to_render.push_back(*it);
443 std::sort(chunks_to_render.begin(), chunks_to_render.end(), [
this](
const Position& p1,
const Position& p2) {return this->DistanceToCamera(p1) > this->DistanceToCamera(p2); });
446 const int num_rendered_chunks =
static_cast<int>(chunks_to_render.size());
447 int num_rendered_faces = 0;
449 for (
int i = 0; i < num_rendered_chunks; ++i)
451 auto found_it =
chunks.find(chunks_to_render[i]);
452 if (found_it !=
chunks.end())
454 found_it->second->Render();
455 num_rendered_faces += found_it->second->GetNumFace();
462 Position(-1, 0, 0),
Position(1, 0, 0),
Position(0, 0, 1),
Position(0, 1, 0) });
464 const int num_entities =
static_cast<int>(
entities.size());
465 int num_rendered_entities = 0;
468 num_faces += e.second->GetNumFace();
472 static_cast<int>(floor(approx_pos.
x /
static_cast<double>(
CHUNK_WIDTH))),
474 static_cast<int>(floor(approx_pos.
z /
static_cast<double>(
CHUNK_WIDTH)))
477 for (
int i = 0; i < neighbouring_positions.size(); ++i)
479 if (inside_frustum[chunk_position + neighbouring_positions[i]])
482 num_rendered_entities += 1;
483 num_rendered_faces += e.second->GetNumFace();
490 const glm::vec3 cam_pos =
camera->GetPosition();
494 for (
int i = 0; i < num_rendered_chunks; ++i)
499 found_it->second->Sort(cam_pos);
500 found_it->second->Render();
501 num_rendered_faces += found_it->second->GetNumFace();
508 *num_chunks_ = num_chunks;
510 if (num_rendered_chunks_)
512 *num_rendered_chunks_ = num_rendered_chunks;
516 *num_faces_ = num_faces;
518 if (num_rendered_faces_)
520 *num_rendered_faces_ = num_rendered_faces;
524 *num_entities_ = num_entities;
526 if (num_rendered_entities_)
528 *num_rendered_entities_ = num_rendered_entities;
534 std::vector<unsigned int> texture_modifier(use_tintindex.size(), 0xFFFFFFFF);
535 for (
int i = 0; i < use_tintindex.size(); ++i)
542 if (use_tintindex[i])
551 if (use_tintindex[i])
561#if PROTOCOL_VERSION == 340
562 texture_modifier[i] = 0xFF000000 | (25 + 15 * blockstate->
GetId().second);
564 texture_modifier[i] = 0xFF000000 | (25 + 15 * std::stoi(blockstate->
GetVariableValue(
"power")));
577 return texture_modifier;
587 std::array<unsigned int, 2> ToMultipliers(
const std::vector<unsigned int>& v)
589 std::array<unsigned int, 2> out = { 0xFFFFFFFF, 0xFFFFFFFF };
590 for (
int i = 0; i < std::min(2, static_cast<int>(v.size())); ++i)
600 static_cast<int>(std::floor(block_pos.x /
static_cast<double>(
CHUNK_WIDTH))),
602 static_cast<int>(std::floor(block_pos.z /
static_cast<double>(
CHUNK_WIDTH)))
606 template<
class ChunkPtr>
608 std::unordered_map<
Position, std::shared_ptr<ChunkPtr>>& renderables,
610 std::atomic<bool>& dirty,
611 const int x,
const int z,
612 std::unordered_map<
Position, std::vector<Face>>&& new_faces
615 bool changed =
false;
616 std::lock_guard<std::mutex> lock(mutex);
618 for (
auto& [pos, renderable] : renderables)
620 if (pos.x == x && pos.z == z && new_faces.find(pos) == new_faces.end())
622 renderable->SetFaces({});
627 for (
auto& [pos, faces] : new_faces)
629 std::shared_ptr<ChunkPtr>& r = renderables[pos];
632 r = std::make_shared<ChunkPtr>();
634 r->SetFaces(std::move(faces));
const Renderer::Atlas * GetAtlas() const
static AssetsManager & getInstance()
unsigned int GetWaterColorMultiplier() const
unsigned int GetColorMultiplier(const int height, const bool is_grass) const
const std::string & GetName() const
BlockstateId GetId() const
unsigned char GetModelId(const Position &pos) const
TintType GetTintType() const
Vector3< double > GetHorizontalOffsetAtPos(const Position &pos) const
const std::string & GetVariableValue(const std::string &variable) const
Access the value of the variable.
const Model & GetModel(const unsigned short index) const
const std::vector< FaceDescriptor > & GetFaces() const
const unsigned char * Get(const int row=0, const int col=0, const int depth=0) const
const std::array< float, 16 > & GetMatrix() const
void SetTextureMultipliers(const std::array< unsigned int, 2 > &mult)
Transparency GetTransparencyData() const
std::shared_ptr< Camera > camera
void UpdateChunk(const int x_, const int z_, const std::optional< Botcraft::Chunk > &chunk)
const float DistanceToCamera(const Position &chunk) const
unsigned int atlas_texture
unsigned int view_uniform_buffer
std::mutex entities_mutex
std::mutex transparent_chunks_mutex
std::atomic< bool > transparent_chunks_dirty
std::atomic< bool > chunks_dirty
void SetPosOrientation(const double x_, const double y_, const double z_, const float yaw_, const float pitch_)
std::shared_ptr< Camera > GetCamera()
std::unordered_map< int, std::shared_ptr< Entity > > entities
std::atomic< bool > entities_faces_should_be_updated
std::unordered_map< Position, std::shared_ptr< TransparentChunk > > transparent_chunks
const std::vector< unsigned int > GetColorModifier(const int y, const Biome *biome, const Blockstate *blockstate, const std::vector< bool > &use_tintindex) const
std::unordered_map< Position, std::shared_ptr< Chunk > > chunks
void UpdateEntity(const int id, const std::vector< Face > &faces)
void SetCameraProjection(const glm::mat4 &proj)
void RenderFaces(int *num_chunks_=nullptr, int *num_rendered_chunks_=nullptr, int *num_entities_=nullptr, int *num_rendered_entities_=nullptr, int *num_faces_=nullptr, int *num_rendered_faces_=nullptr)
static constexpr unsigned int RENDERING_SECTION_HEIGHT
static constexpr int CHUNK_WIDTH