zhenyan121/Cubed
1
0
Fork 0
mirror of https://github.com/zhenyan121/Cubed.git synced 2026-06-18 00:27:02 +08:00
Code Issues Packages Projects Releases Wiki Activity

Compare commits

base: zhenyan121:main
Branches Tags
zhenyan121:main zhenyan121:feat/lighting-effects
..
compare: zhenyan121:623f991fcf16b09776ff351aa00f76afd65b3c48
Branches Tags
zhenyan121:feat/lighting-effects zhenyan121:main

1 Commits
main ... 623f991fcf

Author SHA1 Message Date
zhenyan121
623f991fcf feat(gameplay): add Ocean biome with water generation and heightmap adjustments 
- Introduce Ocean biome enum, builder, and detection logic.
- Add ocean water building to all existing biomes and modify heightmap thresholds for low mountainous areas.
- Skip cave and river generation in Ocean (and River) biomes; avoid carving water blocks.
- Comment out border blending call and update block fill logic.
 2026-06-11 21:58:48 +08:00
42 changed files with 276 additions and 483 deletions
Expand all files Collapse all files

35
CMakeLists.txt
View File

@@ -58,21 +58,6 @@ if (WIN32)
if(TARGET freetype)
add_library(Freetype::Freetype ALIAS freetype)
endif()
set(_BUILD_SHARED_LIBS_SAVED ${BUILD_SHARED_LIBS})
set(BUILD_SHARED_LIBS ON)
FetchContent_Declare(
onetbb
GIT_REPOSITORY https://github.com/uxlfoundation/oneTBB.git
GIT_TAG v2023.0.0
)
set(BUILD_TESTING OFF CACHE BOOL "Build tests" FORCE)
set(TBB_TEST OFF CACHE BOOL "Build TBB tests" FORCE)
FetchContent_MakeAvailable(onetbb)
set(BUILD_SHARED_LIBS ${_BUILD_SHARED_LIBS_SAVED})
unset(_BUILD_SHARED_LIBS_SAVED)
endif()
FetchContent_Declare(
@@ -98,6 +83,7 @@ FetchContent_MakeAvailable(tomlplusplus)
add_subdirectory(third_party/imgui)
set(INCLUDE_DIR ${PROJECT_SOURCE_DIR}/include)
add_executable(${PROJECT_NAME}
@@ -178,11 +164,10 @@ target_link_libraries(${PROJECT_NAME}
Freetype::Freetype
tomlplusplus::tomlplusplus
imgui
tbb
)
if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU" OR CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
# target_link_libraries(${PROJECT_NAME} PRIVATE tbb)
target_link_libraries(${PROJECT_NAME} PRIVATE tbb)
endif()
if (UNIX AND NOT APPLE)
@@ -202,19 +187,3 @@ if (UNIX AND NOT APPLE)
target_compile_options(${PROJECT_NAME} PRIVATE ${EGL_CFLAGS_OTHER} ${Wayland_CFLAGS_OTHER})
endif()
if (WIN32)
foreach(TBB_LIB IN ITEMS tbb tbbmalloc tbbmalloc_proxy)
if(TARGET ${TBB_LIB})
add_custom_command(
TARGET ${PROJECT_NAME} POST_BUILD
COMMAND ${CMAKE_COMMAND} -E copy_if_different
$<TARGET_FILE:${TBB_LIB}>
$<TARGET_FILE_DIR:${PROJECT_NAME}>
COMMENT "Copying ${TBB_LIB}.dll"
)
else()
message(STATUS "Target ${TBB_LIB} not found, skipping copy")
endif()
endforeach()
endif()

1
assets/data/block/air.toml
View File

@@ -5,6 +5,5 @@ is_discard = true
is_gas = true
is_liquid = false
is_passable = true
is_transitional = false
is_transparent = true
name = 'air'

1
assets/data/block/dirt.toml
View File

@@ -5,6 +5,5 @@ is_discard = false
is_gas = false
is_liquid = false
is_passable = false
is_transitional = true
is_transparent = false
name = 'dirt'

1
assets/data/block/grass.toml
View File

@@ -5,6 +5,5 @@ is_discard = true
is_gas = false
is_liquid = false
is_passable = true
is_transitional = false
is_transparent = true
name = 'grass'

1
assets/data/block/grass_block.toml
View File

@@ -5,6 +5,5 @@ is_discard = false
is_gas = false
is_liquid = false
is_passable = false
is_transitional = true
is_transparent = false
name = 'grass_block'

1
assets/data/block/leaf.toml
View File

@@ -5,6 +5,5 @@ is_discard = true
is_gas = false
is_liquid = false
is_passable = false
is_transitional = false
is_transparent = true
name = 'leaf'

1
assets/data/block/log.toml
View File

@@ -5,6 +5,5 @@ is_discard = false
is_gas = false
is_liquid = false
is_passable = false
is_transitional = false
is_transparent = false
name = 'log'

1
assets/data/block/sand.toml
View File

@@ -5,6 +5,5 @@ is_discard = false
is_gas = false
is_liquid = false
is_passable = false
is_transitional = true
is_transparent = false
name = 'sand'

1
assets/data/block/snowy_grass_block.toml
View File

@@ -5,6 +5,5 @@ is_discard = false
is_gas = false
is_liquid = false
is_passable = false
is_transitional = true
is_transparent = false
name = 'snowy_grass_block'

1
assets/data/block/stone.toml
View File

@@ -5,6 +5,5 @@ is_discard = false
is_gas = false
is_liquid = false
is_passable = false
is_transitional = true
is_transparent = false
name = 'stone'

1
assets/data/block/template.toml
View File

@@ -7,4 +7,3 @@ is_cross_plane = false
is_transparent = false
is_discard = false
is_blend = false
is_transitional = false

1
assets/data/block/water.toml
View File

@@ -5,6 +5,5 @@ is_discard = false
is_gas = false
is_liquid = true
is_passable = true
is_transitional = false
is_transparent = true
name = 'water'

2
include/Cubed/constants.hpp
View File

@@ -6,7 +6,7 @@ namespace Cubed {
constexpr int WORLD_SIZE_Y = 256;
constexpr int CHUNK_SIZE = 16;
constexpr int SEA_LEVEL = 63;
constexpr int SEA_LEVEL = 64;
constexpr int MAX_UI_NUM = 1;
constexpr int MAX_BLOCK_STATUS = 1;

9
include/Cubed/gameplay/block.hpp
View File

@@ -50,14 +50,13 @@ struct BlockData {
bool is_discard = false;
bool is_blend = false;
bool is_transitional = false;
BlockData(BlockType b_id, std::string_view b_name, bool liquid,
bool passable, bool cross_plane, bool transparent, bool gas,
bool discard, bool blend, bool transitional)
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_discard(discard), is_blend(blend),
is_transitional(transitional) {}
is_transparent(transparent), is_discard(discard), is_blend(blend) {}
};
class BlockManager {
@@ -78,7 +77,7 @@ public:
static bool is_discard(BlockType id);
static bool is_blend(BlockType id);
static bool is_transitional(BlockType id);
static BlockType cross_plane_index(BlockType id);
private:

2
include/Cubed/gameplay/builders/biome_builder.hpp
View File

@@ -9,10 +9,10 @@ public:
virtual ChunkGenerator& get_chunk_generator() = 0;
virtual void build_biome() = 0;
virtual void build_vegetation() = 0;
void ocean_water_build();
protected:
void build_bottom();
void place_grass();
void ocean_water_build();
};
} // namespace Cubed

9
include/Cubed/gameplay/cave_carver.hpp
View File

@@ -1,14 +1,10 @@
#pragma once
#include "Cubed/gameplay/cave_path.hpp"
#include <tbb/concurrent_hash_map.h>
namespace Cubed {
class CaveCarver {
using CaveHashMap = tbb::concurrent_hash_map<unsigned, CavePath>;
public:
CaveCarver();
CaveHashMap& paths();
std::unordered_map<unsigned, CavePath>& paths();
void init(unsigned world_seed);
void reload(unsigned world_seed);
void add_path(const glm::vec3& pos, unsigned chunk_seed);
@@ -19,8 +15,9 @@ public:
float& cave_probability();
private:
CaveHashMap m_paths;
std::unordered_map<unsigned, CavePath> m_paths;
unsigned m_seed = 0;
int m_sum = 0;
Random m_random;
float m_cave_probability = 0.035f;
};

11
include/Cubed/gameplay/cave_path.hpp
View File

@@ -5,16 +5,12 @@
#include "Cubed/tools/cubed_random.hpp"
#include <glm/glm.hpp>
#include <tbb/concurrent_hash_map.h>
#include <unordered_set>
namespace Cubed {
class CavePath {
using ChunkPosSet =
tbb::concurrent_hash_map<ChunkPos, bool, ChunkPos::TBBHash>;
public:
CavePath(unsigned int chunk_seed, unsigned world_seed,
const glm::vec3& start_pos);
CavePath(unsigned int world_seed, int path_id, const glm::vec3& start_pos);
const std::vector<PathPoint>& points() const;
void clear_chunk(const ChunkPos& pos);
bool is_finished() const;
@@ -38,6 +34,7 @@ private:
static inline int m_step_min = 10;
static inline int m_step_max = 400;
int m_path_id = 0;
unsigned int m_seed = 0;
float m_yaw = 0.0f;
float m_pitch = 0.0f;
@@ -47,7 +44,7 @@ private:
Random m_random;
std::vector<PathPoint> m_points;
ChunkPosSet m_pending_chunks;
std::unordered_set<ChunkPos, ChunkPos::Hash> m_pending_chunks;
void collect_path_points();
void precompute_chunk_coverage();
};

8
include/Cubed/gameplay/chunk.hpp
View File

@@ -14,8 +14,6 @@ class World;
// if want to use, do init_chunk(), gen_vertex_data() and
class Chunk {
private:
using OptionalBlockVectorArray =
std::array<std::optional<std::vector<BlockType>>, 4>;
static constexpr int SIZE_X = CHUNK_SIZE;
static constexpr int SIZE_Y = WORLD_SIZE_Y;
static constexpr int SIZE_Z = CHUNK_SIZE;
@@ -48,7 +46,8 @@ private:
BiomeConditions m_conditions;
void clear_dirty();
void gen_vertices(const OptionalBlockVectorArray& neighbor_block);
void gen_vertices(
const std::array<const std::vector<BlockType>*, 4>& neighbor_block);
void gen_cross_plane_vertices(int world_x, int world_y, int world_z,
BlockType id);
@@ -98,7 +97,8 @@ public:
// 1 : (-1, 0)
// 2 : (0, 1)
// 3 : (0, -1)
void gen_vertex_data(const OptionalBlockVectorArray& neighbor_block);
void gen_vertex_data(
const std::array<const std::vector<BlockType>*, 4>& neighbor_block);
void upload_to_gpu();
GLuint get_normal_vao() const;

5
include/Cubed/gameplay/chunk_generator.hpp
View File

@@ -4,7 +4,6 @@
#include "Cubed/gameplay/biome.hpp"
#include "Cubed/gameplay/block.hpp"
#include "Cubed/gameplay/builders/biome_builder.hpp"
#include "Cubed/gameplay/path_point.hpp"
#include "Cubed/tools/cubed_random.hpp"
#include <atomic>
@@ -46,7 +45,6 @@ public:
Chunk& chunk();
Random& random();
const std::array<BiomeType, 8>& neighbor_biome() const;
void ocean_build();
void generate_cave();
void generate_river();
@@ -62,9 +60,6 @@ private:
unsigned m_chunk_seed = 0;
void make_biome_builder();
void
carve_worm(const std::vector<PathPoint>& points, const ChunkPos& chunk_pos,
std::function<void(int /*x*/, int /*y*/, int /*z*/)> on_hit);
};
} // namespace Cubed

9
include/Cubed/gameplay/chunk_pos.hpp
View File

@@ -16,14 +16,7 @@ struct ChunkPos {
return h1 ^ (h2 + 0x9e3779b9 + (h1 << 6) + (h1 >> 2));
}
};
struct TBBHash {
std::size_t hash(const ChunkPos& p) const {
return ChunkPos::Hash{}(p);
}
bool equal(const ChunkPos& a, const ChunkPos& b) const {
return a == b;
}
};
ChunkPos operator+(const ChunkPos& pos) const {
return ChunkPos{x + pos.x, z + pos.z};
}

13
include/Cubed/gameplay/river.path.hpp
View File

@@ -5,16 +5,13 @@
#include "Cubed/tools/cubed_random.hpp"
#include <glm/glm.hpp>
#include <tbb/concurrent_hash_map.h>
#include <unordered_set>
namespace Cubed {
class RiverPath {
using ChunkPosSet =
tbb::concurrent_hash_map<ChunkPos, bool, ChunkPos::TBBHash>;
public:
RiverPath(unsigned int chunk_seed, unsigned world_seed,
const glm::vec3& start_pos);
RiverPath(unsigned int world_seed, int path_id, const glm::vec3& start_pos);
const std::vector<PathPoint>& points() const;
void clear_chunk(const ChunkPos& pos);
bool is_finished() const;
@@ -35,12 +32,12 @@ private:
static inline float m_radius_y_max = 8.0f;
static inline float m_delta_angle_min = -3.0f;
static inline float m_delta_angle_max = 3.0f;
static inline int m_step_min = 200;
static inline int m_step_min = 150;
static inline int m_step_max = 400;
int m_path_id = 0;
unsigned int m_seed = 0;
float m_yaw = 0.0f;
float m_initial_yaw = 0.0f;
float m_pitch = 0.0f;
int m_step = 0;
float m_step_len = 1.0f;
@@ -48,7 +45,7 @@ private:
Random m_random;
std::vector<PathPoint> m_points;
ChunkPosSet m_pending_chunks;
std::unordered_set<ChunkPos, ChunkPos::Hash> m_pending_chunks;
void collect_path_points();
void precompute_chunk_coverage();
};

9
include/Cubed/gameplay/river_worm.hpp
View File

@@ -4,15 +4,13 @@
#include "Cubed/tools/cubed_random.hpp"
#include <glm/glm.hpp>
#include <tbb/concurrent_hash_map.h>
#include <unordered_map>
namespace Cubed {
class RiverWorm {
using RiverHashMap = tbb::concurrent_hash_map<unsigned, RiverPath>;
public:
RiverWorm();
RiverHashMap& paths();
std::unordered_map<unsigned, RiverPath>& paths();
void init(unsigned world_seed);
void reload(unsigned world_seed);
void add_path(const glm::vec3& pos, unsigned chunk_seed);
@@ -23,8 +21,9 @@ public:
float& river_probability();
private:
RiverHashMap m_paths;
std::unordered_map<unsigned, RiverPath> m_paths;
unsigned m_seed = 0;
int m_sum = 0;
Random m_random;
float m_probability = 0.01f;
};

12
include/Cubed/gameplay/world.hpp
View File

@@ -31,10 +31,8 @@ class Player;
class TextureManager;
class World {
private:
using OptionalBlockVectorArray =
std::array<std::optional<std::vector<BlockType>>, 4>;
using ChunkPtrUpdateList = std::vector<std::pair<ChunkPos, Chunk*>>;
using ChunkPairVector = std::vector<std::pair<ChunkPos, Chunk>>;
using ChunkUpdateList = std::vector<std::pair<ChunkPos, Chunk>>;
using ConstChunkMap =
std::unordered_map<ChunkPos, const Chunk*, ChunkPos::Hash>;
using ChunkPosSet = std::unordered_set<ChunkPos, ChunkPos::Hash>;
@@ -72,16 +70,14 @@ private:
void gen_chunks_internal();
void sync_player_pos(glm::vec3& player_pos);
void
compute_required_chunks(ChunkPosSet& required_chunks,
ChunkPairVector& temp_neighbor,
std::vector<ChunkPos>& need_gen_temp_chunks_pos);
void compute_required_chunks(ChunkPosSet& required_chunks,
ChunkHashMap& temp_neighbor);
void sync_and_collect_missing_chunks(std::vector<ChunkPos>&,
const ChunkPosSet&);
void
build_neighbor_context_for_new_chunks(ConstChunkMap& new_chunks_neighbor,
ChunkPtrUpdateList& affected_neighbor,
const ChunkPairVector& new_chunks);
const ChunkUpdateList& new_chunks);
void build_neighbor_context_for_affected_neighbors(ChunkPtrUpdateList&,
ConstChunkMap&);

18
include/Cubed/tools/cubed_hash.hpp
View File

@@ -7,17 +7,7 @@ namespace HASH {
inline std::size_t str(std::string_view value) {
return std::hash<std::string_view>{}(value);
}
inline uint32_t combine_32(uint32_t seed, uint32_t v) {
seed ^= v + 0x9e3779b9 + (seed << 6) + (seed >> 2);
return seed;
}
inline uint32_t chunk_seed_hash(int32_t a, int32_t b, uint32_t fixed_seed) {
uint32_t seed =
combine_32(combine_32(fixed_seed, (uint32_t)a), (uint32_t)b);
return seed;
}
/*
inline uint32_t chunk_seed_hash(int32_t a, int32_t b, uint32_t fixed_seed) {
inline uint32_t mix_hash(int32_t a, int32_t b, uint32_t fixed_seed) {
uint32_t h = fixed_seed;
h ^= (uint32_t)a * 0xcc9e2d51u;
@@ -37,8 +27,10 @@ inline uint32_t chunk_seed_hash(int32_t a, int32_t b, uint32_t fixed_seed) {
return h;
}
*/
inline uint32_t combine_32(uint32_t seed, uint32_t v) {
seed ^= v + 0x9e3779b9 + (seed << 6) + (seed >> 2);
return seed;
}
} // namespace HASH
} // namespace Cubed

2
include/Cubed/tools/math_tools.hpp
View File

@@ -11,7 +11,7 @@ void extract_frustum_planes(const glm::mat4& mvp_matrix,
float smootherstep(float edge0, float edge1, float x);
bool is_aabb_in_frustum(const glm::vec3& center, const glm::vec3& half_extents,
const std::vector<glm::vec4>& planes);
float deterministic_random(int x, int z, uint64_t seed);
} // namespace Math
} // namespace Cubed

11
src/block.cpp
View File

@@ -104,13 +104,7 @@ bool BlockManager::is_blend(BlockType id) {
}
return m_datas[id].is_blend;
}
bool BlockManager::is_transitional(BlockType id) {
if (id >= sums()) {
Logger::error("Id {}, is Over The Max Id", id, sums() - 1);
return m_datas[0].is_transitional;
}
return m_datas[id].is_transitional;
}
void BlockManager::init() {
fs::path data_path{block_data_dir};
@@ -148,10 +142,9 @@ void BlockManager::init() {
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);
auto is_transitional = safe_get_value(block, "is_transitional", false);
m_datas.emplace_back(*id, *name, *is_liquid, *is_passable,
*is_cross_plane, *is_transparent, *is_gas,
*is_discard, *is_blend, *is_transitional);
*is_discard, *is_blend);
}
std::sort(
m_datas.begin(), m_datas.end(),

1
src/gameplay/builders/desert_builder.cpp
View File

@@ -27,6 +27,7 @@ void DesertBuilder::build_blocks() {
}
}
}
ocean_water_build();
}
void DesertBuilder::build_vegetation() {}

1
src/gameplay/builders/forest_builder.cpp
View File

@@ -32,6 +32,7 @@ void ForestBuilder::build_blocks() {
m_blocks[Chunk::index(x, height, z)] = 1;
}
}
ocean_water_build();
}
void ForestBuilder::build_vegetation() {

1
src/gameplay/builders/mountain_builder.cpp
View File

@@ -23,6 +23,7 @@ void MountainBuilder::build_blocks() {
}
}
}
ocean_water_build();
}
void MountainBuilder::build_vegetation() {}

1
src/gameplay/builders/ocean_builder.cpp
View File

@@ -23,6 +23,7 @@ void OceanBuilder::build_blocks() {
}
}
}
ocean_water_build();
}
void OceanBuilder::build_vegetation() {}

1
src/gameplay/builders/plain_builder.cpp
View File

@@ -27,6 +27,7 @@ void PlainBuilder::build_blocks() {
m_blocks[Chunk::index(x, height, z)] = 1;
}
}
ocean_water_build();
}
void PlainBuilder::build_vegetation() { place_grass(); }

1
src/gameplay/builders/snowy_plain_builder.cpp
View File

@@ -27,6 +27,7 @@ void SnowyPlainBuilder::build_blocks() {
m_blocks[Chunk::index(x, height, z)] = 8;
}
}
ocean_water_build();
}
void SnowyPlainBuilder::build_vegetation() {}

28
src/gameplay/cave_carver.cpp
View File

@@ -5,10 +5,11 @@
namespace Cubed {
CaveCarver::CaveCarver() {}
CaveCarver::CaveHashMap& CaveCarver::paths() { return m_paths; }
std::unordered_map<unsigned, CavePath>& CaveCarver::paths() { return m_paths; }
void CaveCarver::init(unsigned world_seed) {
m_seed = world_seed;
m_sum = 0;
m_random.init(m_seed);
}
@@ -19,18 +20,16 @@ void CaveCarver::reload(unsigned world_seed) {
}
void CaveCarver::add_path(const glm::vec3& pos, unsigned chunk_seed) {
m_paths.emplace(chunk_seed, CavePath{chunk_seed, m_seed, pos});
m_paths.emplace(chunk_seed, CavePath{m_seed, m_sum, pos});
m_sum++;
}
void CaveCarver::try_to_add_path(const ChunkPos& chunk_pos,
unsigned chunk_seed) {
{
CaveHashMap::const_accessor acc;
if (m_paths.find(acc, chunk_seed)) {
return;
}
auto it = m_paths.find(chunk_seed);
if (it != m_paths.end()) {
return;
}
Random random{chunk_seed};
if (random.random_bool(static_cast<double>(m_cave_probability))) {
const int CHUNK_MIN_X = chunk_pos.x * CHUNK_SIZE;
@@ -48,17 +47,10 @@ void CaveCarver::try_to_add_path(const ChunkPos& chunk_pos,
}
void CaveCarver::cleanup_finished_caves() {
std::vector<unsigned int> finished_keys;
for (const auto& pair : m_paths) {
if (pair.second.is_finished()) {
finished_keys.push_back(pair.first);
}
}
for (const auto& key : finished_keys) {
m_paths.erase(key);
}
std::erase_if(m_paths,
[](const auto& kv) { return kv.second.is_finished(); });
}
int CaveCarver::cave_sum() const { return m_paths.size(); }
int CaveCarver::cave_sum() const { return m_sum; }
float& CaveCarver::cave_probability() { return m_cave_probability; }
} // namespace Cubed

8
src/gameplay/cave_path.cpp
View File

@@ -6,9 +6,10 @@
#include <algorithm>
namespace Cubed {
CavePath::CavePath(unsigned int chunk_seed, unsigned world_seed,
CavePath::CavePath(unsigned int world_seed, int path_id,
const glm::vec3& start_pos) {
m_seed = HASH::combine_32(chunk_seed, world_seed);
m_path_id = path_id;
m_seed = HASH::combine_32(world_seed, path_id);
m_random.init(m_seed);
m_yaw = m_random.random_float(0.0f, 360.0f);
m_pitch = m_random.random_float(-10.0f, 10.0f);
@@ -74,8 +75,7 @@ void CavePath::precompute_chunk_coverage() {
for (int cx = min_cx; cx <= max_cx; ++cx)
for (int cz = min_cz; cz <= max_cz; ++cz)
m_pending_chunks.insert(
std::make_pair(ChunkPos{cx, cz}, false));
m_pending_chunks.insert({cx, cz});
}
}

20
src/gameplay/chunk.cpp
View File

@@ -103,7 +103,8 @@ int Chunk::index(const glm::vec3& pos) {
return Chunk::index(pos.x, pos.y, pos.z);
}
void Chunk::gen_vertex_data(const OptionalBlockVectorArray& neighbor_block) {
void Chunk::gen_vertex_data(
const std::array<const std::vector<BlockType>*, 4>& neighbor_block) {
if (m_is_on_gen_vertex_data) {
return;
}
@@ -198,8 +199,9 @@ void Chunk::gen_phase_six(
Logger::error("ChunkGenerator is Nullptr");
return;
}
// This must be fully completed before any other operations can proceed!
m_generator->blend_surface_blocks_borders(neighbor_block);
// m_generator->blend_surface_blocks_borders(neighbor_block);
m_generator->generate_cave();
m_generator->generate_river();
}
void Chunk::gen_phase_seven() {
@@ -207,10 +209,6 @@ void Chunk::gen_phase_seven() {
Logger::error("ChunkGenerator is Nullptr");
return;
}
m_generator->ocean_build();
m_generator->generate_river();
m_generator->generate_cave();
m_generator->generate_vegetation();
mark_dirty();
m_generator = nullptr;
@@ -264,7 +262,8 @@ unsigned Chunk::seed() const {
BiomeConditions& Chunk::conditions() { return m_conditions; }
void Chunk::gen_vertices(const OptionalBlockVectorArray& neighbor_block) {
void Chunk::gen_vertices(
const std::array<const std::vector<BlockType>*, 4>& neighbor_block) {
static const glm::ivec3 DIR[6] = {{0, 0, 1}, {1, 0, 0}, {0, 0, -1},
{-1, 0, 0}, {0, 1, 0}, {0, -1, 0}};
@@ -297,9 +296,8 @@ void Chunk::gen_vertices(const OptionalBlockVectorArray& neighbor_block) {
World::chunk_pos(world_nx, world_nz);
auto is_culled =
[&](const std::optional<std::vector<BlockType>>&
chunk_blocks) {
if (chunk_blocks == std::nullopt) {
[&](const std::vector<BlockType>* chunk_blocks) {
if (chunk_blocks == nullptr) {
return true;
}
int x, y, z;

253
src/gameplay/chunk_generator.cpp
View File

@@ -18,11 +18,11 @@ namespace Cubed {
using enum BiomeType;
constexpr int BLEND_RADIUS = 8;
constexpr int BLEND_RADIUS = 12;
ChunkGenerator::ChunkGenerator(Chunk& chunk) : m_chunk(chunk) {
ASSERT_MSG(is_init, "ChunksGenerator is not init");
ChunkPos pos = m_chunk.get_chunk_pos();
unsigned seed = HASH::chunk_seed_hash(pos.x, pos.z, m_generator_seed);
unsigned seed = HASH::mix_hash(pos.x, pos.z, m_generator_seed);
m_random.init(seed);
m_chunk_seed = seed;
}
@@ -477,11 +477,9 @@ void ChunkGenerator::blend_surface_blocks_borders(
for (int y = WORLD_HEIGHT - 1; y >= 0; --y) {
int idx = Chunk::index(nx, y,
nz); // linear index: y * area + z * size + x
if (idx >= 0 && idx < static_cast<int>(blocks.size())) {
BlockType neighbor_type = blocks[idx];
if (BlockManager::is_transitional(neighbor_type)) {
return neighbor_type;
}
if (idx >= 0 && idx < static_cast<int>(blocks.size()) &&
blocks[idx] != 0) {
return blocks[idx];
}
}
return 0; // fallback, should not happen for valid chunks
@@ -501,8 +499,8 @@ void ChunkGenerator::blend_surface_blocks_borders(
// Weight map: type -> total weight
std::unordered_map<BlockType, float> weights;
float self_weight = 1.0f;
weights[type_self] = self_weight;
weights[type_self] = 1.0f; // self weight
// --- Right neighbor (index 0) ---
if (neighbor_block[0] && x >= CHUNK_SIZE - BLEND_RADIUS) {
int dist = (CHUNK_SIZE - 1) - x;
@@ -551,41 +549,34 @@ void ChunkGenerator::blend_surface_blocks_borders(
}
}
if (weights.empty()) {
continue;
}
// Find type with maximum total weight
BlockType final_type = type_self;
/*float max_weight = weights[type_self];
float max_weight = weights[type_self];
for (const auto& [type, w] : weights) {
if (w > max_weight) {
max_weight = w;
final_type = type;
}
}*/
float sum = 0.0f;
for (auto& kv : weights) {
sum += kv.second;
}
float rnd = m_random.random_float(0.0f, 1.0f);
float accum = 0.0f;
for (auto [t, w] : weights) {
accum += w / sum;
if (rnd < accum) {
final_type = t;
break;
}
}
if (!BlockManager::is_transitional(final_type)) {
continue;
if (final_type == 0) {
return;
}
// Update the top block if the type changed
if (final_type != type_self) {
// top block
BlockType new_surface = final_type;
m_blocks[Chunk::index(x, top_y, z)] = new_surface;
if (final_type == 7 && top_y > SEA_LEVEL) {
if (type_self == 7) {
m_blocks[Chunk::index(x, top_y, z)] = 0;
} else {
m_blocks[Chunk::index(x, top_y, z)] = type_self;
}
} else {
m_blocks[Chunk::index(x, top_y, z)] = final_type;
}
// bottom block
unsigned fill_type = 2;
if (final_type == 1 || final_type == 8) {
@@ -593,8 +584,12 @@ void ChunkGenerator::blend_surface_blocks_borders(
} else {
fill_type = final_type;
}
for (int y = std::max(0, top_y - 5); y < top_y; y++) {
m_blocks[Chunk::index(x, y, z)] = fill_type;
for (int y = top_y - 5; y < top_y; y++) {
if (fill_type == 7 && y > SEA_LEVEL) {
m_blocks[Chunk::index(x, y, z)] = 0;
} else {
m_blocks[Chunk::index(x, y, z)] = fill_type;
}
}
}
}
@@ -640,100 +635,65 @@ void ChunkGenerator::make_biome_builder() {
}
}
void ChunkGenerator::ocean_build() { m_biome_builder->ocean_water_build(); }
void ChunkGenerator::carve_worm(
const std::vector<PathPoint>& points, const ChunkPos& chunk_pos,
std::function<void(int /*x*/, int /*y*/, int /*z*/)> on_hit) {
void ChunkGenerator::generate_cave() {
auto& cave_carver = m_chunk.world().cave_carcer();
auto& paths = cave_carver.paths();
const auto& chunk_pos = m_chunk.chunk_pos();
auto& blocks = m_chunk.blocks();
const int CHUNK_MIN_X = chunk_pos.x * CHUNK_SIZE;
const int CHUNK_MIN_Z = chunk_pos.z * CHUNK_SIZE;
const int CHUNK_MAX_X = CHUNK_MIN_X + SIZE_X - 1;
const int CHUNK_MAX_Z = CHUNK_MIN_Z + SIZE_Z - 1;
const int CHUNK_MIN_Y = 0;
const int CHUNK_MAX_Y = SIZE_Y - 1;
for (const auto& point : points) {
const glm::vec3& center = point.pos;
float rad_xz = point.rad_xz;
float rad_y = point.rad_y;
if (center.x + rad_xz < CHUNK_MIN_X ||
center.x - rad_xz > CHUNK_MAX_X ||
center.z + rad_xz < CHUNK_MIN_Z ||
center.z - rad_xz > CHUNK_MAX_Z || center.y + rad_y < CHUNK_MIN_Y ||
center.y - rad_y > CHUNK_MAX_Y) {
continue;
}
int min_x = static_cast<int>(std::floor(center.x - rad_xz));
int max_x = static_cast<int>(std::floor(center.x + rad_xz));
int min_z = static_cast<int>(std::floor(center.z - rad_xz));
int max_z = static_cast<int>(std::floor(center.z + rad_xz));
int min_y = static_cast<int>(std::floor(center.y - rad_y));
int max_y = static_cast<int>(std::floor(center.y + rad_y));
min_x = std::max(min_x, CHUNK_MIN_X);
max_x = std::min(max_x, CHUNK_MAX_X);
min_z = std::max(min_z, CHUNK_MIN_Z);
max_z = std::min(max_z, CHUNK_MAX_Z);
min_y = std::max(min_y, CHUNK_MIN_Y);
max_y = std::min(max_y, CHUNK_MAX_Y);
glm::vec3 right_raw =
glm::cross(point.tangent, glm::vec3(0.0f, 1.0f, 0.0f));
if (glm::dot(right_raw, right_raw) < 1e-6f)
right_raw = glm::cross(point.tangent, glm::vec3(1.0f, 0.0f, 0.0f));
glm::vec3 right = glm::normalize(right_raw);
glm::vec3 up = glm::normalize(glm::cross(point.tangent, right));
float inv_a2 = 1.0f / (point.rad_xz * point.rad_xz);
float inv_b2 = 1.0f / (point.rad_y * point.rad_y);
for (int wy = min_y; wy <= max_y; ++wy) {
if (wy == 0)
for (auto& [id, path] : paths) {
for (const auto& point : path.points()) {
if ((m_chunk.biome() == BiomeType::RIVER) ||
(m_chunk.biome() == BiomeType::OCEAN)) {
path.clear_chunk(chunk_pos);
continue;
float dy = static_cast<float>(wy) - point.pos.y;
}
const glm::vec3& center = point.pos;
float rad_xz = point.rad_xz;
float rad_y = point.rad_y;
float vy_contrib = dy * up.y;
float vy2 = vy_contrib * vy_contrib * inv_b2;
if (vy2 >= 1.0f)
continue;
int min_x = static_cast<int>(std::floor(center.x - rad_xz));
int max_x = static_cast<int>(std::floor(center.x + rad_xz));
int min_z = static_cast<int>(std::floor(center.z - rad_xz));
int max_z = static_cast<int>(std::floor(center.z + rad_xz));
int min_y = static_cast<int>(std::floor(center.y - rad_y));
int max_y = static_cast<int>(std::floor(center.y + rad_y));
min_x = std::max(min_x, CHUNK_MIN_X);
max_x = std::min(max_x, CHUNK_MAX_X);
min_z = std::max(min_z, CHUNK_MIN_Z);
max_z = std::min(max_z, CHUNK_MAX_Z);
min_y = std::max(min_y, CHUNK_MIN_Y);
max_y = std::min(max_y, CHUNK_MAX_Y);
for (int wx = min_x; wx <= max_x; ++wx) {
float dx = static_cast<float>(wx) - point.pos.x;
int x = wx - CHUNK_MIN_X;
for (int wz = min_z; wz <= max_z; ++wz) {
float dz = static_cast<float>(wz) - point.pos.z;
glm::vec3 to_point(dx, dy, dz);
float h = glm::dot(to_point, right);
float v = glm::dot(to_point, up);
if (h * h * inv_a2 + v * v * inv_b2 > 1.0f)
continue;
int x = wx - CHUNK_MIN_X;
on_hit(x, wy, wz - CHUNK_MIN_Z);
int z = wz - CHUNK_MIN_Z;
for (int wy = min_y; wy <= max_y; ++wy) {
int y = wy;
glm::vec3 pos(static_cast<float>(wx),
static_cast<float>(wy),
static_cast<float>(wz));
if (point.contains(pos)) {
if (y == 0) {
continue;
}
if (blocks[Chunk::index(x, y, z)] == 7) {
continue;
}
blocks[Chunk::index(x, y, z)] = 0;
}
}
}
}
}
}
}
void ChunkGenerator::generate_cave() {
auto& cave_carver = m_chunk.world().cave_carcer();
auto& paths = cave_carver.paths();
const auto& chunk_pos = m_chunk.chunk_pos();
auto& blocks = m_chunk.blocks();
for (auto& [id, path] : paths) {
carve_worm(path.points(), chunk_pos, [&](int x, int y, int z) -> void {
int idx = Chunk::index(x, y, z);
if (blocks[idx] == 7)
return;
if (y < WORLD_SIZE_Y - 1 && blocks[Chunk::index(x, y + 1, z)] == 7)
return;
blocks[idx] = 0;
});
path.clear_chunk(chunk_pos);
}
}
@@ -744,27 +704,64 @@ void ChunkGenerator::generate_river() {
auto& paths = river_worm.paths();
const auto& chunk_pos = m_chunk.chunk_pos();
auto& blocks = m_chunk.blocks();
const int CHUNK_MIN_X = chunk_pos.x * CHUNK_SIZE;
const int CHUNK_MIN_Z = chunk_pos.z * CHUNK_SIZE;
const int CHUNK_MAX_X = CHUNK_MIN_X + SIZE_X - 1;
const int CHUNK_MAX_Z = CHUNK_MIN_Z + SIZE_Z - 1;
const int CHUNK_MIN_Y = 0;
const int CHUNK_MAX_Y = SIZE_Y - 1;
bool is_river = false;
for (auto& [id, path] : paths) {
if ((m_chunk.biome() == BiomeType::DESERT) ||
(m_chunk.biome() == BiomeType::OCEAN)) {
path.clear_chunk(chunk_pos);
continue;
for (const auto& point : path.points()) {
if ((m_chunk.biome() == BiomeType::DESERT) ||
(m_chunk.biome() == BiomeType::OCEAN)) {
path.clear_chunk(chunk_pos);
continue;
}
const glm::vec3& center = point.pos;
float rad_xz = point.rad_xz;
float rad_y = point.rad_y;
int min_x = static_cast<int>(std::floor(center.x - rad_xz));
int max_x = static_cast<int>(std::floor(center.x + rad_xz));
int min_z = static_cast<int>(std::floor(center.z - rad_xz));
int max_z = static_cast<int>(std::floor(center.z + rad_xz));
int min_y = static_cast<int>(std::floor(center.y - rad_y));
int max_y = static_cast<int>(std::floor(center.y + rad_y));
min_x = std::max(min_x, CHUNK_MIN_X);
max_x = std::min(max_x, CHUNK_MAX_X);
min_z = std::max(min_z, CHUNK_MIN_Z);
max_z = std::min(max_z, CHUNK_MAX_Z);
min_y = std::max(min_y, CHUNK_MIN_Y);
max_y = std::min(max_y, CHUNK_MAX_Y);
for (int wx = min_x; wx <= max_x; ++wx) {
int x = wx - CHUNK_MIN_X;
for (int wz = min_z; wz <= max_z; ++wz) {
int z = wz - CHUNK_MIN_Z;
for (int wy = min_y; wy <= max_y; ++wy) {
int y = wy;
glm::vec3 pos(static_cast<float>(wx),
static_cast<float>(wy),
static_cast<float>(wz));
if (point.contains(pos)) {
if (y > SEA_LEVEL) {
blocks[Chunk::index(x, y, z)] = 0;
continue;
}
is_river = true;
if (blocks[Chunk::index(x, y, z)] == 0) {
continue;
}
blocks[Chunk::index(x, y, z)] = 7;
}
}
}
}
}
carve_worm(path.points(), chunk_pos, [&](int x, int y, int z) -> void {
int idx = Chunk::index(x, y, z);
if (y > SEA_LEVEL) {
blocks[idx] = 0;
return;
}
is_river = true;
if (blocks[idx] == 0) {
return;
}
blocks[idx] = 7;
});
path.clear_chunk(chunk_pos);
}
if (is_river) {

17
src/gameplay/river_path.cpp
View File

@@ -5,15 +5,12 @@
#include <algorithm>
namespace Cubed {
RiverPath::RiverPath(unsigned int chunk_seed, unsigned world_seed,
RiverPath::RiverPath(unsigned int world_seed, int path_id,
const glm::vec3& start_pos) {
m_seed = HASH::combine_32(chunk_seed, world_seed);
m_path_id = path_id;
m_seed = HASH::combine_32(world_seed, path_id);
m_random.init(m_seed);
m_yaw = m_random.random_float(0.0f, 360.0f);
m_initial_yaw = m_yaw;
m_pitch = 0.0f;
m_start_path_point.pos = start_pos;
m_start_path_point.rad_xz =
@@ -44,15 +41,14 @@ void RiverPath::collect_path_points() {
float t = Math::smootherstep(0, m_step - 1, i);
float drad_xz = m_start_path_point.rad_xz * t;
float drad_y = m_start_path_point.rad_y * t;
float drad_xz = m_start_path_point.rad_xz * (1.0f - t);
float drad_y = m_start_path_point.rad_y * (1.0f - t);
drad_xz = std::max(drad_xz, 4.0f);
drad_y = std::max(drad_y, 4.0f);
m_points.emplace_back(m_points[i].pos + glm::vec3{dx, dy, dz}, drad_xz,
drad_y);
m_yaw += m_random.random_float(m_delta_angle_min, m_delta_angle_max);
m_yaw = std::clamp(m_yaw, m_initial_yaw - 10.0f, m_initial_yaw + 10.0f);
}
auto n = m_points.size();
if (n >= 2) {
@@ -76,8 +72,7 @@ void RiverPath::precompute_chunk_coverage() {
for (int cx = min_cx; cx <= max_cx; ++cx)
for (int cz = min_cz; cz <= max_cz; ++cz)
m_pending_chunks.insert(
std::make_pair(ChunkPos{cx, cz}, false));
m_pending_chunks.insert({cx, cz});
}
}

28
src/gameplay/river_worm.cpp
View File

@@ -5,11 +5,11 @@
namespace Cubed {
RiverWorm::RiverWorm() {}
RiverWorm::RiverHashMap& RiverWorm::paths() { return m_paths; }
std::unordered_map<unsigned, RiverPath>& RiverWorm::paths() { return m_paths; }
void RiverWorm::init(unsigned world_seed) {
m_seed = world_seed;
m_sum = 0;
m_random.init(m_seed);
}
@@ -20,16 +20,15 @@ void RiverWorm::reload(unsigned world_seed) {
}
void RiverWorm::add_path(const glm::vec3& pos, unsigned chunk_seed) {
m_paths.emplace(chunk_seed, RiverPath{chunk_seed, m_seed, pos});
m_paths.emplace(chunk_seed, RiverPath{m_seed, m_sum, pos});
m_sum++;
}
void RiverWorm::try_to_add_path(const ChunkPos& chunk_pos,
unsigned chunk_seed) {
{
RiverHashMap::const_accessor acc;
if (m_paths.find(acc, chunk_seed)) {
return;
}
auto it = m_paths.find(chunk_seed);
if (it != m_paths.end()) {
return;
}
Random random{chunk_seed};
if (random.random_bool(static_cast<double>(m_probability))) {
@@ -45,17 +44,10 @@ void RiverWorm::try_to_add_path(const ChunkPos& chunk_pos,
}
void RiverWorm::cleanup_finished_rivers() {
std::vector<unsigned> finished_keys;
for (const auto& pair : m_paths) {
if (pair.second.is_finished()) {
finished_keys.push_back(pair.first);
}
}
for (const auto& key : finished_keys) {
m_paths.erase(key);
}
std::erase_if(m_paths,
[](const auto& kv) { return kv.second.is_finished(); });
}
int RiverWorm::river_sum() const { return m_paths.size(); }
int RiverWorm::river_sum() const { return m_sum; }
float& RiverWorm::river_probability() { return m_probability; }
} // namespace Cubed

2
src/gameplay/tree.cpp
View File

@@ -1,6 +1,7 @@
#include "Cubed/gameplay/tree.hpp"
#include "Cubed/gameplay/chunk.hpp"
#include "Cubed/tools/log.hpp"
#include <array>
@@ -31,6 +32,7 @@ bool build_tree(Chunk& chunk, const glm::ivec3& pos) {
auto& block = chunk.get_chunk_blocks();
if (block[Chunk::index(pos)] != 1) {
Logger::info("Root is not Grass Block");
return false;
}
for (const auto& d : TREE) {

192
src/gameplay/world.cpp
View File

@@ -5,8 +5,6 @@
#include "Cubed/tools/cubed_assert.hpp"
#include "Cubed/tools/cubed_hash.hpp"
#include <execution>
namespace Cubed {
struct ChunkRenderData {
@@ -91,7 +89,6 @@ void World::init_world() {
void World::init_chunks() {
hot_reload();
while (!m_chunk_gen_finished) {
// Logger::info("World Spawn: {:.2f}%", m_chunk_gen_fraction.load());
std::this_thread::sleep_for(std::chrono::microseconds(200));
}
}
@@ -322,10 +319,8 @@ void World::gen_chunks_internal() {
m_chunk_gen_fraction = 0.0f;
m_chunk_gen_finished = false;
ChunkPosSet required_chunks;
ChunkPairVector temp_neighbor;
std::vector<ChunkPos> need_gen_temp_chunks_pos;
compute_required_chunks(required_chunks, temp_neighbor,
need_gen_temp_chunks_pos);
ChunkHashMap temp_neighbor;
compute_required_chunks(required_chunks, temp_neighbor);
ASSERT_MSG(!required_chunks.empty(), "required chunks is empty!!");
@@ -343,14 +338,11 @@ void World::gen_chunks_internal() {
m_chunk_gen_fraction = 0.1f;
ChunkPairVector new_chunks;
ChunkHashMap new_temp_chunks;
ChunkUpdateList new_chunks;
for (auto& pos : need_gen_chunks_pos) {
new_chunks.push_back({pos, Chunk(*this, pos)});
}
for (auto& pos : need_gen_temp_chunks_pos) {
new_temp_chunks.emplace(pos, Chunk(*this, pos));
}
ConstChunkMap new_chunks_neighbor;
// affected neighbor
ChunkPtrUpdateList affected_neighbor;
@@ -360,28 +352,17 @@ void World::gen_chunks_internal() {
// build new chunk, but the neighbor in m_chunks also need to re-build
std::for_each(std::execution::par, new_chunks.begin(), new_chunks.end(),
[this](std::pair<ChunkPos, Chunk>& new_chunk) {
auto& [pos, chunk] = new_chunk;
chunk.gen_phase_one();
m_cave_carcer.try_to_add_path(pos, chunk.seed());
m_river_worm.try_to_add_path(pos, chunk.seed());
});
std::for_each(new_temp_chunks.begin(), new_temp_chunks.end(),
[](std::pair<const ChunkPos, Chunk>& new_chunk) {
auto& [pos, chunk] = new_chunk;
chunk.gen_phase_one();
});
for (auto& [pos, chunk] : new_chunks) {
chunk.gen_phase_one();
m_cave_carcer.try_to_add_path(pos, chunk.seed());
m_river_worm.try_to_add_path(pos, chunk.seed());
}
// precompute path to ensure the continuity of the path
std::for_each(std::execution::par, temp_neighbor.begin(),
temp_neighbor.end(),
[this](std::pair<ChunkPos, Chunk>& new_chunk) {
auto& [pos, chunk] = new_chunk;
chunk.gen_phase_one();
m_cave_carcer.try_to_add_path(pos, chunk.seed());
m_river_worm.try_to_add_path(pos, chunk.seed());
});
for (auto& [pos, chunk] : temp_neighbor) {
chunk.gen_phase_one();
m_cave_carcer.try_to_add_path(pos, chunk.seed());
m_river_worm.try_to_add_path(pos, chunk.seed());
}
m_chunk_gen_fraction = 0.2f;
@@ -419,19 +400,15 @@ void World::gen_chunks_internal() {
m_chunk_gen_fraction = 0.3f;
std::for_each(std::execution::par, new_chunks.begin(), new_chunks.end(),
[](std::pair<ChunkPos, Chunk>& pair) {
auto& [pos, chunks] = pair;
chunks.gen_phase_three();
});
for (auto& [pos, chunk] : new_temp_chunks) {
chunk.gen_phase_three();
for (auto& [pos, chunks] : new_chunks) {
chunks.gen_phase_three();
}
// for (auto& [pos, chunks] : temp_neighbor) {
// chunks.gen_phase_three();
// }
m_chunk_gen_fraction = 0.4f;
/*
for (int i = 0; i < 4; i++) {
for (auto& [pos, chunks] : temp_neighbor) {
@@ -475,106 +452,68 @@ void World::gen_chunks_internal() {
}
}
*/
m_chunk_gen_fraction = 0.4f;
m_chunk_gen_fraction = 0.5f;
for (auto& [pos, chunks] : new_chunks) {
chunks.gen_phase_five();
}
m_chunk_gen_fraction = 0.45f;
for (auto& [pos, chunk] : new_temp_chunks) {
chunk.gen_phase_five();
}
m_chunk_gen_fraction = 0.5f;
/*
for (auto& [pos, chunks] : temp_neighbor) {
chunks.gen_phase_five();
}
*/
std::vector<std::pair<Chunk*, OptionalBlockVectorArray>>
new_chunks_surface_blend_data(new_chunks.size());
for (size_t idx = 0; idx < new_chunks.size(); idx++) {
auto& [pos, chunk] = new_chunks[idx];
new_chunks_surface_blend_data[idx].first = &chunk;
std::array<std::optional<std::vector<BlockType>>, 4> neighbor_blocks_data;
for (auto& [pos, chunks] : new_chunks) {
{
// std::lock_guard lk(m_chunks_mutex);
for (int i = 0; i < 4; i++) {
auto neighbor_pos = pos + CHUNK_DIR[i];
auto it = new_chunks_neighbor.find(neighbor_pos);
if (it == new_chunks_neighbor.end()) {
auto it = new_temp_chunks.find(neighbor_pos);
if (it == new_temp_chunks.end()) {
new_chunks_surface_blend_data[idx].second[i] =
std::nullopt;
Logger::warn(
"Can't find neighbor for chunk surface blend");
continue;
}
new_chunks_surface_blend_data[idx].second[i] =
it->second.get_chunk_blocks();
neighbor_blocks_data[i] = std::nullopt;
continue;
}
new_chunks_surface_blend_data[idx].second[i] =
it->second->get_chunk_blocks();
neighbor_blocks_data[i] = it->second->get_chunk_blocks();
}
}
chunks.gen_phase_six(neighbor_blocks_data);
}
std::for_each(
std::execution::par, new_chunks_surface_blend_data.begin(),
new_chunks_surface_blend_data.end(),
[](std::pair<Chunk*, OptionalBlockVectorArray>& new_chunk_data) {
auto& [chunk, neighbor_data] = new_chunk_data;
chunk->gen_phase_six(neighbor_data);
});
m_chunk_gen_fraction = 0.55f;
std::for_each(std::execution::par, new_chunks.begin(), new_chunks.end(),
[](std::pair<ChunkPos, Chunk>& new_chunk) {
auto& [pos, chunk] = new_chunk;
chunk.gen_phase_seven();
});
for (auto& [pos, chunks] : new_chunks) {
chunks.gen_phase_seven();
}
m_chunk_gen_fraction = 0.6f;
std::vector<std::pair<Chunk*, OptionalBlockVectorArray>>
new_chunk_vertices_data(new_chunks.size());
for (size_t idx = 0; idx < new_chunks.size(); idx++) {
auto& [pos, chunk] = new_chunks[idx];
new_chunk_vertices_data[idx].first = &chunk;
std::array<const std::vector<BlockType>*, 4> neighbor_block;
for (auto& [pos, chunk] : new_chunks) {
for (int i = 0; i < 4; i++) {
auto it = new_chunks_neighbor.find(pos + CHUNK_DIR[i]);
if (it != new_chunks_neighbor.end()) {
new_chunk_vertices_data[idx].second[i] =
(it->second->get_chunk_blocks());
neighbor_block[i] = &(it->second->get_chunk_blocks());
} else {
new_chunk_vertices_data[idx].second[i] = std::nullopt;
neighbor_block[i] = nullptr;
}
}
chunk.gen_vertex_data(neighbor_block);
}
std::for_each(
std::execution::par, new_chunk_vertices_data.begin(),
new_chunk_vertices_data.end(),
[](std::pair<Chunk*, OptionalBlockVectorArray>& new_chunk_data) {
auto& [chunk, neighbor_data] = new_chunk_data;
chunk->gen_vertex_data(neighbor_data);
});
m_chunk_gen_fraction = 0.7f;
build_neighbor_context_for_affected_neighbors(affected_neighbor,
new_chunks_neighbor);
m_chunk_gen_fraction = 0.8f;
OptionalBlockVectorArray neighbor_block;
for (auto& [pos, chunk] : affected_neighbor) {
for (int i = 0; i < 4; i++) {
auto it = new_chunks_neighbor.find(pos + CHUNK_DIR[i]);
if (it != new_chunks_neighbor.end()) {
neighbor_block[i] = (it->second->get_chunk_blocks());
neighbor_block[i] = &(it->second->get_chunk_blocks());
} else {
neighbor_block[i] = std::nullopt;
neighbor_block[i] = nullptr;
}
}
chunk->gen_vertex_data(neighbor_block);
@@ -600,53 +539,32 @@ void World::sync_player_pos(glm::vec3& player_pos) {
player_pos = m_gen_player_pos;
}
void World::compute_required_chunks(
ChunkPosSet& required_chunks, ChunkPairVector& temp_neighbor,
std::vector<ChunkPos>& need_gen_temp_chunks_pos) {
void World::compute_required_chunks(ChunkPosSet& required_chunks,
ChunkHashMap& temp_neighbor) {
glm::vec3 player_pos;
sync_player_pos(player_pos);
int x = std::floor(player_pos.x);
int z = std::floor(player_pos.z);
auto [chunk_x, chunk_z] = chunk_pos(x, z);
int radius = m_rendering_distance;
int r2 = radius * radius;
required_chunks.reserve(radius * radius);
for (int dx = -radius; dx <= radius; ++dx) {
for (int dz = -radius; dz <= radius; ++dz) {
if (dx * dx + dz * dz <= r2) {
required_chunks.emplace(chunk_x + dx, chunk_z + dz);
}
}
}
int new_radius = radius + 1;
int new_r2 = new_radius * new_radius;
for (int dx = -new_radius; dx <= new_radius; ++dx) {
for (int dz = -new_radius; dz <= new_radius; ++dz) {
if (dx * dx + dz * dz <= new_r2) {
int nx = chunk_x + dx;
int nz = chunk_z + dz;
auto it = required_chunks.find({nx, nz});
if (it == required_chunks.end()) {
need_gen_temp_chunks_pos.push_back({nx, nz});
}
}
required_chunks.reserve(m_rendering_distance * m_rendering_distance);
int half = m_rendering_distance / 2;
for (int u = chunk_x - half; u <= chunk_x + half; ++u) {
for (int v = chunk_z - half; v <= chunk_z + half; ++v) {
required_chunks.emplace(u, v);
}
}
int max_path_len = std::max(CavePath::step_max(), RiverPath::step_max());
radius = max_path_len / 2;
r2 = radius * radius;
for (int dx = -radius; dx <= radius; ++dx) {
for (int dz = -radius; dz <= radius; ++dz) {
if (dx * dx + dz * dz <= r2) {
ChunkPos pos{chunk_x + dx, chunk_z + dz};
auto it = required_chunks.find(pos);
if (it != required_chunks.end()) {
continue;
}
temp_neighbor.emplace_back(pos, Chunk(*this, pos));
half = std::ceil(static_cast<float>(max_path_len) / CHUNK_SIZE) * 2;
for (int u = chunk_x - half; u <= chunk_x + half; ++u) {
for (int v = chunk_z - half; v <= chunk_z + half; ++v) {
ChunkPos pos{u, v};
auto it = required_chunks.find(pos);
if (it != required_chunks.end()) {
continue;
}
temp_neighbor.emplace(pos, Chunk(*this, pos));
}
}
}
@@ -673,7 +591,7 @@ void World::sync_and_collect_missing_chunks(
void World::build_neighbor_context_for_new_chunks(
ConstChunkMap& new_chunks_neighbor, ChunkPtrUpdateList& affected_neighbor,
const ChunkPairVector& new_chunks) {
const ChunkUpdateList& new_chunks) {
{
std::lock_guard lk(m_chunks_mutex);
for (auto& [pos, chunk] : new_chunks) {
@@ -918,13 +836,13 @@ void World::update(float delta_time) {
for (auto& [pos, chunk] : m_chunks) {
if (chunk.is_dirty()) {
// the curial fator influence
OptionalBlockVectorArray neighbor_block;
std::array<const std::vector<BlockType>*, 4> neighbor_block;
for (int i = 0; i < 4; i++) {
auto it = m_chunks.find(pos + CHUNK_DIR[i]);
if (it != m_chunks.end()) {
neighbor_block[i] = (it->second.get_chunk_blocks());
neighbor_block[i] = &(it->second.get_chunk_blocks());
} else {
neighbor_block[i] = std::nullopt;
neighbor_block[i] = nullptr;
}
}
chunk.gen_vertex_data(neighbor_block);

32
src/tools/cubed_random.cpp
View File

@@ -5,15 +5,8 @@ namespace Cubed {
Random::Random() {}
Random::Random(unsigned seed) { init(seed); }
bool Random::random_bool(double probability) {
if (probability <= 0.0)
return false;
if (probability >= 1.0)
return true;
const double MAX_VAL = 4294967295.0;
unsigned threshold = static_cast<unsigned>(probability * MAX_VAL);
return m_engine() <= threshold;
std::bernoulli_distribution dist(probability);
return dist(m_engine);
}
std::mt19937& Random::engine() { return m_engine; }
@@ -25,23 +18,12 @@ void Random::init(unsigned seed) {
m_engine.seed(seed);
}
int Random::random_int(int min, int max) {
unsigned range = static_cast<unsigned>(max - min) + 1;
const unsigned LIMIT =
(std::numeric_limits<unsigned>::max() / range) * range;
unsigned r;
do {
r = m_engine();
} while (r >= LIMIT);
return min + static_cast<int>(r % range);
std::uniform_int_distribution<int> dist(min, max);
return dist(m_engine);
}
float Random::random_float(float min, float max) {
unsigned r = m_engine() >> 8;
float t = static_cast<float>(r) * (1.0f / 16777216.0f);
float result = min + t * (max - min);
return result;
std::uniform_real_distribution<float> dist(min, max);
return dist(m_engine);
}
} // namespace Cubed

7
src/tools/math_tools.cpp
View File

@@ -59,12 +59,7 @@ bool is_aabb_in_frustum(const glm::vec3& center, const glm::vec3& half_extents,
}
return true;
}
float deterministic_random(int x, int z, uint64_t seed) {
uint64_t h = seed;
h = h * 6364136223846793005ULL + (uint64_t)x;
h = h * 6364136223846793005ULL + (uint64_t)z;
return (float)(h >> 40) / (float)(1 << 24);
}
} // namespace Math
} // namespace Cubed