refactor: world generation (#17)

* refactor: use TBB for concurrent hash maps and parallelize chunk processing

* fix: tbb link fail

* refactor(chunk): remove biome check for caves in rivers and oceans

* refactor(random): replace std distributions with custom implementations

Avoid overhead and platform-dependent behavior of `<random>` distributions by using direct engine operations and integer arithmetic. This ensures deterministic, cross-platform results and improves performance.

* refactor(generation): use chunk seed for cave and river paths

- Use per-chunk seed instead of global path_id for cave and river generation.
- Remove unused m_sum variables and m_path_id members.
- Clamp river yaw within 10 degrees of initial direction.
- Fix river radius interpolation (use t instead of 1-t).
- Lower sea level from 64 to 63.

.clang-format

@@ -0,0 +1,321 @@
+---
+Language:        Cpp
+AlignAfterOpenBracket: true
+AccessModifierOffset: -4
+AlignArrayOfStructures: None
+AlignConsecutiveAssignments:
+  Enabled:         false
+  AcrossEmptyLines: false
+  AcrossComments:  false
+  AlignCompound:   false
+  AlignFunctionDeclarations: false
+  AlignFunctionPointers: false
+  PadOperators:    true
+AlignConsecutiveBitFields:
+  Enabled:         false
+  AcrossEmptyLines: false
+  AcrossComments:  false
+  AlignCompound:   false
+  AlignFunctionDeclarations: false
+  AlignFunctionPointers: false
+  PadOperators:    false
+AlignConsecutiveDeclarations:
+  Enabled:         false
+  AcrossEmptyLines: false
+  AcrossComments:  false
+  AlignCompound:   false
+  AlignFunctionDeclarations: true
+  AlignFunctionPointers: false
+  PadOperators:    false
+AlignConsecutiveMacros:
+  Enabled:         false
+  AcrossEmptyLines: false
+  AcrossComments:  false
+  AlignCompound:   false
+  AlignFunctionDeclarations: false
+  AlignFunctionPointers: false
+  PadOperators:    false
+AlignConsecutiveShortCaseStatements:
+  Enabled:         false
+  AcrossEmptyLines: false
+  AcrossComments:  false
+  AlignCaseArrows: false
+  AlignCaseColons: false
+AlignConsecutiveTableGenBreakingDAGArgColons:
+  Enabled:         false
+  AcrossEmptyLines: false
+  AcrossComments:  false
+  AlignCompound:   false
+  AlignFunctionDeclarations: false
+  AlignFunctionPointers: false
+  PadOperators:    false
+AlignConsecutiveTableGenCondOperatorColons:
+  Enabled:         false
+  AcrossEmptyLines: false
+  AcrossComments:  false
+  AlignCompound:   false
+  AlignFunctionDeclarations: false
+  AlignFunctionPointers: false
+  PadOperators:    false
+AlignConsecutiveTableGenDefinitionColons:
+  Enabled:         false
+  AcrossEmptyLines: false
+  AcrossComments:  false
+  AlignCompound:   false
+  AlignFunctionDeclarations: false
+  AlignFunctionPointers: false
+  PadOperators:    false
+AlignEscapedNewlines: Right
+AlignOperands:   Align
+AlignTrailingComments:
+  AlignPPAndNotPP: true
+  Kind:            Always
+  OverEmptyLines:  0
+AllowAllArgumentsOnNextLine: true
+AllowAllParametersOfDeclarationOnNextLine: true
+AllowBreakBeforeNoexceptSpecifier: Never
+AllowBreakBeforeQtProperty: false
+AllowShortBlocksOnASingleLine: Never
+AllowShortCaseExpressionOnASingleLine: true
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortCompoundRequirementOnASingleLine: true
+AllowShortEnumsOnASingleLine: true
+AllowShortFunctionsOnASingleLine: All
+AllowShortIfStatementsOnASingleLine: Never
+AllowShortLambdasOnASingleLine: All
+AllowShortLoopsOnASingleLine: false
+AllowShortNamespacesOnASingleLine: false
+AlwaysBreakAfterDefinitionReturnType: None
+AlwaysBreakBeforeMultilineStrings: false
+AttributeMacros:
+  - __capability
+BinPackArguments: true
+BinPackLongBracedList: true
+BinPackParameters: BinPack
+BitFieldColonSpacing: Both
+BracedInitializerIndentWidth: -1
+BraceWrapping:
+  AfterCaseLabel:  false
+  AfterClass:      false
+  AfterControlStatement: Never
+  AfterEnum:       false
+  AfterExternBlock: false
+  AfterFunction:   false
+  AfterNamespace:  false
+  AfterObjCDeclaration: false
+  AfterStruct:     false
+  AfterUnion:      false
+  BeforeCatch:     false
+  BeforeElse:      false
+  BeforeLambdaBody: false
+  BeforeWhile:     false
+  IndentBraces:    false
+  SplitEmptyFunction: true
+  SplitEmptyRecord: true
+  SplitEmptyNamespace: true
+BreakAdjacentStringLiterals: true
+BreakAfterAttributes: Leave
+BreakAfterJavaFieldAnnotations: false
+BreakAfterOpenBracketBracedList: false
+BreakAfterOpenBracketFunction: false
+BreakAfterOpenBracketIf: false
+BreakAfterOpenBracketLoop: false
+BreakAfterOpenBracketSwitch: false
+BreakAfterReturnType: None
+BreakArrays:     true
+BreakBeforeBinaryOperators: None
+BreakBeforeCloseBracketBracedList: false
+BreakBeforeCloseBracketFunction: false
+BreakBeforeCloseBracketIf: false
+BreakBeforeCloseBracketLoop: false
+BreakBeforeCloseBracketSwitch: false
+BreakBeforeConceptDeclarations: Always
+BreakBeforeBraces: Attach
+BreakBeforeInlineASMColon: OnlyMultiline
+BreakBeforeTemplateCloser: false
+BreakBeforeTernaryOperators: true
+BreakBinaryOperations: Never
+BreakConstructorInitializers: BeforeColon
+BreakFunctionDefinitionParameters: false
+BreakInheritanceList: BeforeColon
+BreakStringLiterals: true
+BreakTemplateDeclarations: MultiLine
+ColumnLimit:     80
+CommentPragmas:  '^ IWYU pragma:'
+CompactNamespaces: false
+ConstructorInitializerIndentWidth: 4
+ContinuationIndentWidth: 4
+Cpp11BracedListStyle: AlignFirstComment
+DerivePointerAlignment: false
+DisableFormat:   false
+EmptyLineAfterAccessModifier: Never
+EmptyLineBeforeAccessModifier: LogicalBlock
+EnumTrailingComma: Leave
+ExperimentalAutoDetectBinPacking: false
+FixNamespaceComments: true
+ForEachMacros:
+  - foreach
+  - Q_FOREACH
+  - BOOST_FOREACH
+IfMacros:
+  - KJ_IF_MAYBE
+IncludeBlocks:   Regroup
+IncludeCategories:
+  - Regex:           '^"(llvm|llvm-c|clang|clang-c)/'
+    Priority:        2
+    SortPriority:    0
+    CaseSensitive:   false
+  - Regex:           '^(<|"(gtest|gmock|isl|json)/)'
+    Priority:        3
+    SortPriority:    0
+    CaseSensitive:   false
+  - Regex:           '.*'
+    Priority:        1
+    SortPriority:    0
+    CaseSensitive:   false
+IncludeIsMainRegex: '(Test)?$'
+IncludeIsMainSourceRegex: ''
+IndentAccessModifiers: false
+IndentCaseBlocks: false
+IndentCaseLabels: false
+IndentExportBlock: true
+IndentExternBlock: AfterExternBlock
+IndentGotoLabels: true
+IndentPPDirectives: None
+IndentRequiresClause: true
+IndentWidth:     4
+IndentWrappedFunctionNames: false
+InsertBraces:    false
+InsertNewlineAtEOF: false
+InsertTrailingCommas: None
+IntegerLiteralSeparator:
+  Binary:          0
+  BinaryMinDigitsInsert: 0
+  BinaryMaxDigitsRemove: 0
+  Decimal:         0
+  DecimalMinDigitsInsert: 0
+  DecimalMaxDigitsRemove: 0
+  Hex:             0
+  HexMinDigitsInsert: 0
+  HexMaxDigitsRemove: 0
+  BinaryMinDigits: 0
+  DecimalMinDigits: 0
+  HexMinDigits:    0
+JavaScriptQuotes: Leave
+JavaScriptWrapImports: true
+KeepEmptyLines:
+  AtEndOfFile:     false
+  AtStartOfBlock:  true
+  AtStartOfFile:   true
+KeepFormFeed:    false
+LambdaBodyIndentation: Signature
+LineEnding:      DeriveLF
+MacroBlockBegin: ''
+MacroBlockEnd:   ''
+MainIncludeChar: Quote
+MaxEmptyLinesToKeep: 1
+NamespaceIndentation: None
+NumericLiteralCase:
+  ExponentLetter:  Leave
+  HexDigit:        Leave
+  Prefix:          Leave
+  Suffix:          Leave
+ObjCBinPackProtocolList: Auto
+ObjCBlockIndentWidth: 2
+ObjCBreakBeforeNestedBlockParam: true
+ObjCSpaceAfterProperty: false
+ObjCSpaceBeforeProtocolList: true
+OneLineFormatOffRegex: ''
+PackConstructorInitializers: BinPack
+PenaltyBreakAssignment: 2
+PenaltyBreakBeforeFirstCallParameter: 19
+PenaltyBreakBeforeMemberAccess: 150
+PenaltyBreakComment: 300
+PenaltyBreakFirstLessLess: 120
+PenaltyBreakOpenParenthesis: 0
+PenaltyBreakScopeResolution: 500
+PenaltyBreakString: 1000
+PenaltyBreakTemplateDeclaration: 10
+PenaltyExcessCharacter: 1000000
+PenaltyIndentedWhitespace: 0
+PenaltyReturnTypeOnItsOwnLine: 60
+PointerAlignment: Left
+PPIndentWidth:   -1
+QualifierAlignment: Leave
+ReferenceAlignment: Pointer
+ReflowComments:  Always
+RemoveBracesLLVM: false
+RemoveEmptyLinesInUnwrappedLines: false
+RemoveParentheses: Leave
+RemoveSemicolon: false
+RequiresClausePosition: OwnLine
+RequiresExpressionIndentation: OuterScope
+SeparateDefinitionBlocks: Leave
+ShortNamespaceLines: 1
+SkipMacroDefinitionBody: false
+SortIncludes:
+  Enabled:         true
+  IgnoreCase:      false
+  IgnoreExtension: false
+SortJavaStaticImport: Before
+SortUsingDeclarations: LexicographicNumeric
+SpaceAfterCStyleCast: false
+SpaceAfterLogicalNot: false
+SpaceAfterOperatorKeyword: false
+SpaceAfterTemplateKeyword: true
+SpaceAroundPointerQualifiers: Default
+SpaceBeforeAssignmentOperators: true
+SpaceBeforeCaseColon: false
+SpaceBeforeCpp11BracedList: false
+SpaceBeforeCtorInitializerColon: true
+SpaceBeforeInheritanceColon: true
+SpaceBeforeJsonColon: false
+SpaceBeforeParens: ControlStatements
+SpaceBeforeParensOptions:
+  AfterControlStatements: true
+  AfterForeachMacros: true
+  AfterFunctionDefinitionName: false
+  AfterFunctionDeclarationName: false
+  AfterIfMacros:   true
+  AfterNot:        false
+  AfterOverloadedOperator: false
+  AfterPlacementOperator: true
+  AfterRequiresInClause: false
+  AfterRequiresInExpression: false
+  BeforeNonEmptyParentheses: false
+SpaceBeforeRangeBasedForLoopColon: true
+SpaceBeforeSquareBrackets: false
+SpaceInEmptyBraces: Never
+SpacesBeforeTrailingComments: 1
+SpacesInAngles:  Never
+SpacesInContainerLiterals: true
+SpacesInLineCommentPrefix:
+  Minimum:         1
+  Maximum:         -1
+SpacesInParens:  Never
+SpacesInParensOptions:
+  ExceptDoubleParentheses: false
+  InCStyleCasts:   false
+  InConditionalStatements: false
+  InEmptyParentheses: false
+  Other:           false
+SpacesInSquareBrackets: false
+Standard:        Latest
+StatementAttributeLikeMacros:
+  - Q_EMIT
+StatementMacros:
+  - Q_UNUSED
+  - QT_REQUIRE_VERSION
+TableGenBreakInsideDAGArg: DontBreak
+TabWidth:        8
+UseTab:          Never
+VerilogBreakBetweenInstancePorts: true
+WhitespaceSensitiveMacros:
+  - BOOST_PP_STRINGIZE
+  - CF_SWIFT_NAME
+  - NS_SWIFT_NAME
+  - PP_STRINGIZE
+  - STRINGIZE
+WrapNamespaceBodyWithEmptyLines: Leave
+...
+

.clang-format-ignore

@@ -0,0 +1,3 @@
+third_party/
+build/
+vendor/

.clangd

@@ -0,0 +1,2 @@
+CompileFlags:
+  Add: [-Wall, -Wextra, -Wpedantic, -Wno-unused-parameter]

.github/workflows/format-check.yml

@@ -0,0 +1,17 @@
+# .github/workflows/format-check.yml
+name: Code Format Check
+
+on: [push, pull_request]
+
+permissions:
+  contents: read
+
+jobs:
+  formatting:
+    runs-on: ubuntu-latest
+    container: silkeh/clang:latest   
+    steps:
+      - uses: actions/checkout@v4
+      - name: Run clang-format
+        run: |
+          find src include -name '*.cpp' -o -name '*.h' -print0 | xargs -0 clang-format --dry-run --Werror

.gitignore

@@ -39,4 +39,6 @@ CMakeError.log
 *.swp
 *.swo
 *~
-.DS_Store
+.DS_Store
+assets/config.toml
+.venv/

.pre-commit-config.yaml

@@ -0,0 +1,8 @@
+repos:
+  - repo: https://github.com/pre-commit/mirrors-clang-format
+    rev: "v22.1.4"
+    hooks:
+      - id: clang-format
+        args: ["--style=file"]
+        types_or: ["c++", "c"]
+        exclude: '^third_party/.*$'

.python-version

@@ -0,0 +1 @@
+3.14

CMakeLists.txt

@@ -1,7 +1,7 @@
 cmake_minimum_required(VERSION 3.14...3.24)
 project(Cubed LANGUAGES C CXX)
 
-set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD 23)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_EXTENSIONS OFF)
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
@@ -58,6 +58,21 @@ 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(
@@ -74,6 +89,14 @@ FetchContent_Declare(
     
 )
 FetchContent_MakeAvailable(soil2)
+FetchContent_Declare(
+    tomlplusplus
+    GIT_REPOSITORY https://github.com/marzer/tomlplusplus.git
+    GIT_TAG v3.4.0
+)
+FetchContent_MakeAvailable(tomlplusplus)
+
+add_subdirectory(third_party/imgui)
 
 set(INCLUDE_DIR ${PROJECT_SOURCE_DIR}/include)
 
@@ -82,34 +105,55 @@ add_executable(${PROJECT_NAME}
     src/app.cpp
     src/debug_collector.cpp
     src/camera.cpp
+    src/config.cpp
+    src/dev_panel.cpp
+    src/gameplay/biome.cpp
     src/gameplay/chunk.cpp
+    src/gameplay/chunk_generator.cpp
     src/gameplay/player.cpp
+    src/gameplay/tree.cpp
     src/gameplay/world.cpp
     src/input.cpp
     src/map_table.cpp
     src/renderer.cpp
     src/shader.cpp
     src/texture_manager.cpp
+    src/tools/cubed_random.cpp
     src/tools/math_tools.cpp
     src/tools/shader_tools.cpp
     src/tools/font.cpp
-    src/tools/log.cpp
     src/tools/perlin_noise.cpp
     src/ui/text.cpp
     src/window.cpp
+    src/gameplay/builders/biome_builder.cpp
+    src/gameplay/builders/plain_builder.cpp
+    src/gameplay/builders/mountain_builder.cpp
+    src/gameplay/builders/river_builder.cpp
+    src/gameplay/builders/desert_builder.cpp
+    src/gameplay/builders/forest_builder.cpp
+    src/gameplay/cave_carver.cpp
+    src/gameplay/cave_path.cpp
+    src/gameplay/builders/snowy_plain_builder.cpp
+    src/gameplay/river_worm.cpp
+    src/gameplay/river_path.cpp
+    src/block.cpp
+    src/gameplay/vertex_data.cpp
+    src/gameplay/builders/ocean_builder.cpp
 )
 
 if(CMAKE_BUILD_TYPE STREQUAL "Debug")
     message(STATUS "Building with AddressSanitizer enabled for target: ${PROJECT_NAME}")
 
     target_compile_options(${PROJECT_NAME} PRIVATE
-        -fsanitize=address
+        #-fsanitize=address
+        #-fsanitize=thread
         -fno-omit-frame-pointer   
         -g                        
     )
 
     target_link_options(${PROJECT_NAME} PRIVATE
-        -fsanitize=address
+        #-fsanitize=address
+        #-fsanitize=thread
     )
 
     target_compile_definitions(${PROJECT_NAME} PRIVATE DEBUG_MODE)
@@ -132,8 +176,15 @@ target_link_libraries(${PROJECT_NAME}
         OpenGL::GL
         soil2
         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)
+endif()
+
 if (UNIX AND NOT APPLE)
     target_link_libraries(${PROJECT_NAME}
         PRIVATE
@@ -151,3 +202,19 @@ 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()

README.md

@@ -1,2 +1,21 @@
 ## What's it
-A cube game like Minecraft, using C++ and OpenGL.
+A cube game like Minecraft, using C++ and OpenGL.  
+
+## Build Guide  
+### Prerequisites  
+- **CMake** (>= 3.24)
+- **C++ 23** compatible compiler
+### Step 
+1. Clone the repository  
+   ```bash
+   git clone https://github.com/zhenyan121/Cubed.git && cd Cubed
+   ```
+2. Configure with CMake
+   ```bash
+   mkdir build && cd build
+   cmake -G "Ninja" ..
+   ```
+3. Build the project  
+   ```bash
+   ninja
+   ```

assets/data/block/air.toml

@@ -0,0 +1,10 @@
+id = 0
+is_blend = false
+is_cross_plane = false
+is_discard = true
+is_gas = true
+is_liquid = false
+is_passable = true
+is_transitional = false
+is_transparent = true
+name = 'air'

assets/data/block/dirt.toml

@@ -0,0 +1,10 @@
+id = 2
+is_blend = false
+is_cross_plane = false
+is_discard = false
+is_gas = false
+is_liquid = false
+is_passable = false
+is_transitional = true
+is_transparent = false
+name = 'dirt'

assets/data/block/grass.toml

@@ -0,0 +1,10 @@
+id = 9
+is_blend = false
+is_cross_plane = true
+is_discard = true
+is_gas = false
+is_liquid = false
+is_passable = true
+is_transitional = false
+is_transparent = true
+name = 'grass'

assets/data/block/grass_block.toml

@@ -0,0 +1,10 @@
+id = 1
+is_blend = false
+is_cross_plane = false
+is_discard = false
+is_gas = false
+is_liquid = false
+is_passable = false
+is_transitional = true
+is_transparent = false
+name = 'grass_block'

assets/data/block/leaf.toml

@@ -0,0 +1,10 @@
+id = 6
+is_blend = false
+is_cross_plane = false
+is_discard = true
+is_gas = false
+is_liquid = false
+is_passable = false
+is_transitional = false
+is_transparent = true
+name = 'leaf'

assets/data/block/log.toml

@@ -0,0 +1,10 @@
+id = 5
+is_blend = false
+is_cross_plane = false
+is_discard = false
+is_gas = false
+is_liquid = false
+is_passable = false
+is_transitional = false
+is_transparent = false
+name = 'log'

assets/data/block/sand.toml

@@ -0,0 +1,10 @@
+id = 4
+is_blend = false
+is_cross_plane = false
+is_discard = false
+is_gas = false
+is_liquid = false
+is_passable = false
+is_transitional = true
+is_transparent = false
+name = 'sand'

assets/data/block/snowy_grass_block.toml

@@ -0,0 +1,10 @@
+id = 8
+is_blend = false
+is_cross_plane = false
+is_discard = false
+is_gas = false
+is_liquid = false
+is_passable = false
+is_transitional = true
+is_transparent = false
+name = 'snowy_grass_block'

assets/data/block/stone.toml

@@ -0,0 +1,10 @@
+id = 3
+is_blend = false
+is_cross_plane = false
+is_discard = false
+is_gas = false
+is_liquid = false
+is_passable = false
+is_transitional = true
+is_transparent = false
+name = 'stone'

assets/data/block/template.toml

@@ -0,0 +1,10 @@
+name = "template"
+id = 0
+is_liquid = false
+is_gas = false
+is_passable = false
+is_cross_plane = false
+is_transparent = false
+is_discard = false
+is_blend = false
+is_transitional = false

assets/data/block/water.toml

@@ -0,0 +1,10 @@
+id = 7
+is_blend = true
+is_cross_plane = false
+is_discard = false
+is_gas = false
+is_liquid = true
+is_passable = true
+is_transitional = false
+is_transparent = true
+name = 'water'

assets/shaders/block_accumulation_f_shader.glsl

@@ -0,0 +1,28 @@
+#version 460
+
+layout (location = 0) out vec4 accum;
+layout (location = 1) out float reveal;
+
+in vec2 tc;
+flat in int tex_layer;
+in float v_depth;
+layout (binding = 0) uniform sampler2DArray samp;
+
+float weight(float z, float a) {
+    float intermediate = 0.03 / (1e-5 + pow(z / 200.0, 4.0));
+    
+    return a * clamp(intermediate, 1e-2, 3e2);
+}
+
+void main() {
+    vec4 color = texture(samp, vec3(tc, tex_layer));
+    float alpha = color.a;
+    if (alpha < 1e-4) discard;
+
+
+    float w = weight(v_depth, alpha);
+
+    accum = vec4(color.rgb * alpha * w, alpha * w);
+
+    reveal = alpha;
+}

assets/shaders/block_accumulation_v_shader.glsl

@@ -0,0 +1,21 @@
+#version 460
+
+layout (location = 0) in vec3 pos;
+layout (location = 1) in vec2 texCoord;
+layout (location = 2) in float layer;
+out vec2 tc;
+flat out int tex_layer;
+out float v_depth;
+
+uniform mat4 mv_matrix;
+uniform mat4 proj_matrix;
+
+
+
+void main(void) {
+    vec4 view_pos = mv_matrix * vec4(pos, 1.0);
+    gl_Position = proj_matrix * view_pos;
+    tc = texCoord;
+    tex_layer = int(layer);
+    v_depth = -view_pos.z;
+}

assets/shaders/block_composite_f_shader.glsl

@@ -0,0 +1,19 @@
+#version 460
+
+uniform sampler2D u_accumTex;
+uniform sampler2D u_revealTex;
+in vec2 TexCoord;
+out vec4 FragColor;
+
+void main() {
+    vec4 a = texture(u_accumTex, TexCoord);
+    float r = texture(u_revealTex, TexCoord).r;
+
+    if (a.a < 1e-4) discard;
+
+    vec3 color = a.rgb / max(a.a, 1e-5);
+    float transmittance = r;
+    float opacity = 1.0 - transmittance;
+
+    FragColor = vec4(color * opacity, opacity);
+}

assets/shaders/block_composite_v_shader.glsl

@@ -0,0 +1,11 @@
+#version 460
+
+layout (location = 0) in vec2 pos;
+layout (location = 1) in vec2 texCoord;
+
+out vec2 TexCoord;
+
+void main() {
+    gl_Position = vec4(pos.x, pos.y, 0.0, 1.0);
+    TexCoord = texCoord;
+}

assets/shaders/block_f_shader.glsl

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

assets/shaders/under_water_f_shader.glsl

@@ -0,0 +1,35 @@
+#version 460
+
+in vec2 TexCoord;
+
+out vec4 FragColor;
+
+uniform sampler2D u_sceneTexture;
+uniform float u_time;
+uniform bool u_underwater;
+uniform vec3 u_waterColor;
+uniform float u_fogDensity;
+
+void main() {
+    vec4 original = texture(u_sceneTexture, TexCoord);
+
+    if (!u_underwater) {
+        FragColor = original;
+        return;
+    }
+
+    vec2 distoredUV = TexCoord;
+    float strength = 0.003;
+    distoredUV.x += sin(TexCoord.y * 15.0 + u_time * 5.0) * strength;
+    distoredUV.y += cos(TexCoord.x * 15.0 + u_time * 4.3) * strength;
+    distoredUV = clamp(distoredUV, 0.001, 0.999);
+    vec4 distorted = texture(u_sceneTexture, distoredUV);
+
+    float caustic = 0.9 + 0.1 * sin(TexCoord.x * 20.0 + u_time) * cos(TexCoord.y * 20.0 + u_time * 1.2);
+    vec3 causticLight = vec3(caustic, caustic * 0.95, caustic * 0.9);
+    //vec3 causticLight = vec3(1.0);
+    float fogFactor = clamp(1.0 - (TexCoord.y * u_fogDensity * 10.0), 0.0, 1.0);
+    vec3 mixed = mix(u_waterColor, distorted.rgb * causticLight, fogFactor);
+
+    FragColor = vec4(mixed, 1.0);
+}

assets/shaders/under_water_v_shader.glsl

@@ -0,0 +1,11 @@
+#version 460
+
+layout (location = 0) in vec2 pos;
+layout (location = 1) in vec2 texCoord;
+
+out vec2 TexCoord;
+
+void main() {
+    gl_Position = vec4(pos.x, pos.y, 0.0, 1.0);
+    TexCoord = texCoord;
+}

include/Cubed/AABB.hpp

@@ -1,19 +1,20 @@
 #pragma once
 #include <glm/glm.hpp>
+
+namespace Cubed {
+
 struct AABB {
     glm::vec3 min{0.0f, 0.0f, 0.0f};
     glm::vec3 max{0.0f, 0.0f, 0.0f};
 
-    AABB(glm::vec3 min_point, glm::vec3 max_point):
-        min(min_point),
-        max(max_point)
-    {
-
-    }
+    AABB(glm::vec3 min_point, glm::vec3 max_point)
+        : min(min_point), max(max_point) {}
 
     bool intersects(const AABB& other) const {
         return (min.x <= other.max.x && max.x >= other.min.x) &&
                (min.y <= other.max.y && max.y >= other.min.y) &&
                (min.z <= other.max.z && max.z >= other.min.z);
     }
-};
+};
+
+} // namespace Cubed

include/Cubed/app.hpp

@@ -1,49 +1,68 @@
 #pragma once
-
-#include <Cubed/camera.hpp>
-#include <Cubed/gameplay/world.hpp>
-#include <Cubed/input.hpp>
-#include <Cubed/renderer.hpp>
-#include <Cubed/texture_manager.hpp>
-#include <Cubed/window.hpp>
+#define GLFW_INCLUDE_NONE
+#include "Cubed/camera.hpp"
+#include "Cubed/dev_panel.hpp"
+#include "Cubed/gameplay/world.hpp"
+#include "Cubed/renderer.hpp"
+#include "Cubed/texture_manager.hpp"
+#include "Cubed/window.hpp"
+namespace Cubed {
 
 class App {
 public:
     App();
     ~App();
-    static void cursor_position_callback(GLFWwindow* window, double xpos, double ypos);
-    static void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods);
-    static void mouse_button_callback(GLFWwindow* window, int button, int action, int mods);
+    static void cursor_position_callback(GLFWwindow* window, double xpos,
+                                         double ypos);
+    static void key_callback(GLFWwindow* window, int key, int scancode,
+                             int action, int mods);
+    static void mouse_button_callback(GLFWwindow* window, int button,
+                                      int action, int mods);
     static void window_focus_callback(GLFWwindow* window, int focused);
-    static void window_reshape_callback(GLFWwindow* window, int new_width, int new_height);
-
+    static void window_reshape_callback(GLFWwindow* window, int new_width,
+                                        int new_height);
+    static void mouse_scroll_callback(GLFWwindow* window, double xoffset,
+                                      double yoffset);
+    static void cursor_enter_callback(GLFWwindow* window, int entered);
+    static void char_callback(GLFWwindow* window, unsigned int ch);
     static int start_cubed_application(int argc, char** argv);
+
     static unsigned int seed();
     static float delte_time();
     static float get_fps();
+
+    Camera& camera();
+    DevPanel& dev_panel();
+    Renderer& renderer();
+    TextureManager& texture_manager();
+    Window& window();
+    World& world();
+
 private:
     Camera m_camera;
     TextureManager m_texture_manager;
     World m_world;
-    Renderer m_renderer{m_camera, m_world, m_texture_manager};
+    DevPanel m_dev_panel{*this};
+    Renderer m_renderer{m_camera, m_world, m_texture_manager, m_dev_panel};
 
     Window m_window{m_renderer};
-    
+
     inline static double last_time = glfwGetTime();
     inline static double current_time = glfwGetTime();
     inline static double delta_time = 0.0f;
     inline static double fps_time_count = 0.0f;
     inline static int frame_count = 0;
     inline static int fps = 0;
-    inline static unsigned int m_seed = 0;
-    
+
     void init();
-    
+
     auto init_camera();
     auto init_texture();
     auto init_world();
-    
+
     void render();
     void run();
     void update();
-};
+};
+
+} // namespace Cubed

include/Cubed/camera.hpp

@@ -1,35 +1,37 @@
 #pragma once
 
+#define GLFW_INCLUDE_NONE
+#include <GLFW/glfw3.h>
 #include <glm/glm.hpp>
 #include <glm/gtc/matrix_transform.hpp>
 #include <glm/gtc/type_ptr.hpp>
-#include <glad/glad.h>
-#include <GLFW/glfw3.h>
+
+namespace Cubed {
 
 class Player;
 
-
 class Camera {
 private:
-
     bool m_firse_mouse = true;
     Player* m_player;
     float m_last_mouse_x, m_last_mouse_y;
     glm::vec3 m_camera_pos;
-    
+    bool m_under_water = false;
 
 public:
-
     Camera();
 
     void update_move_camera();
 
     void camera_init(Player* player);
+    void hot_reload();
     void reset_camera();
     void update_cursor_position_camera(double xpos, double ypos);
 
     const glm::mat4 get_camera_lookat() const;
     const glm::vec3& get_camera_pos() const;
+
+    bool is_under_water() const;
 };
 
-
+} // namespace Cubed

include/Cubed/config.hpp

@@ -1,150 +1,107 @@
 #pragma once
-constexpr int WORLD_SIZE_Y = 256;
-constexpr int MAX_BLOCK_NUM = 4;
-constexpr int MAX_UI_NUM = 1;
+#include "Cubed/tools/cubed_assert.hpp"
 
-constexpr int CHUCK_SIZE = 16;
-constexpr int DISTANCE = 16;
-constexpr int MAX_BLOCK_STATUS = 1;
-constexpr int MAX_CHARACTER = 128;
-constexpr float NORMAL_FOV = 70.0f;
+#include <toml++/toml.hpp>
 
-constexpr int SEED = 999;
+namespace Cubed {
 
-constexpr float VERTICES_POS[6][6][3] = {
-        // ===== front (z = +1) =====
-        0.0f, 0.0f, 1.0f,  // bottom left
-        0.0f, 1.0f, 1.0f,  // top left
-        1.0f, 1.0f, 1.0f,  // top right
-        1.0f, 1.0f, 1.0f,  // top right
-        1.0f, 0.0f, 1.0f,  // bottom right
-        0.0f, 0.0f, 1.0f,  // bottom left
-        // ===== right (x = +1) =====
-        1.0f, 0.0f, 1.0f,  // bottom front
-        1.0f, 0.0f, 0.0f,  // bottom back
-        1.0f, 1.0f, 0.0f,  // top back
-        1.0f, 1.0f, 0.0f,  // top back
-        1.0f, 1.0f, 1.0f,  // top front
-        1.0f, 0.0f, 1.0f,  // bottom front
-        // ===== back (z = -1) =====
-        0.0f, 0.0f, 0.0f,  // bottom left
-        1.0f, 0.0f, 0.0f,  // bottom right
-        1.0f, 1.0f, 0.0f,  // top right
-        1.0f, 1.0f, 0.0f,  // top right
-        0.0f, 1.0f, 0.0f,  // top left
-        0.0f, 0.0f, 0.0f,  // bottom left
-        // ===== left (x = -1) =====
-        0.0f, 0.0f, 0.0f,  // bottom back
-        0.0f, 0.0f, 1.0f,  // bottom front
-        0.0f, 1.0f, 1.0f,  // top front
-        0.0f, 1.0f, 1.0f,  // top front
-        0.0f, 1.0f, 0.0f,  // top back
-        0.0f, 0.0f, 0.0f,  // bottom back
-        // ===== top (y = +1) =====
-        0.0f, 1.0f, 0.0f,  // back left
-        1.0f, 1.0f, 0.0f,  // back right
-        1.0f, 1.0f, 1.0f,  // front right
-        1.0f, 1.0f, 1.0f,  // front right
-        0.0f, 1.0f, 1.0f,  // front left
-        0.0f, 1.0f, 0.0f,  // back left
-        // ===== bottom (y = -1) =====
-        0.0f, 0.0f, 1.0f,  // front left
-        1.0f, 0.0f, 1.0f,  // front right
-        1.0f, 0.0f, 0.0f,  // back right
-        1.0f, 0.0f, 0.0f,  // back right
-        0.0f, 0.0f, 0.0f,  // back left
-        0.0f, 0.0f, 1.0f   // front left
-    };
+template <typename T>
+concept TomlValueType =
+    std::same_as<T, int> || std::same_as<T, bool> || std::same_as<T, double> ||
+    std::same_as<T, const char*> || std::same_as<T, toml::date> ||
+    std::same_as<T, toml::time> || std::same_as<T, toml::date_time> ||
+    std::same_as<T, std::string>;
 
-constexpr float TEX_COORDS[6][6][2] = {
-    // ===== front (z = +1) =====
-    0.0f, 1.0f,  // bottom left
-    0.0f, 0.0f,  // top left
-    1.0f, 0.0f,  // top right
-    1.0f, 0.0f,  // top right
-    1.0f, 1.0f,  // bottom right
-    0.0f, 1.0f,  // bottom left
-    // ===== right (x = +1) =====
-    0.0f, 1.0f,  // bottom front
-    1.0f, 1.0f,  // bottom back
-    1.0f, 0.0f,  // top back
-    1.0f, 0.0f,  // top back
-    0.0f, 0.0f,  // top front
-    0.0f, 1.0f,  // bottom front
-    // ===== back (z = -1) =====
-    1.0f, 1.0f,  // bottom left
-    0.0f, 1.0f,  // bottom right
-    0.0f, 0.0f,  // top right
-    0.0f, 0.0f,  // top right
-    1.0f, 0.0f,  // top left
-    1.0f, 1.0f,  // bottom left
-    // ===== left (x = -1) =====
-    1.0f, 1.0f,  // bottom back
-    0.0f, 1.0f,  // bottom front
-    0.0f, 0.0f,  // top front
-    0.0f, 0.0f,  // top front
-    1.0f, 0.0f,  // top back
-    1.0f, 1.0f,  // bottom back
-    // ===== top (y = +1) =====
-    0.0f, 0.0f,  // back left
-    1.0f, 0.0f,  // back right
-    1.0f, 1.0f,  // front right
-    1.0f, 1.0f,  // front right
-    0.0f, 1.0f,  // front left
-    0.0f, 0.0f,  // back left
-    // ===== bottom (y = -1) =====
-    0.0f, 0.0f,  // front left
-    1.0f, 0.0f,  // front right
-    1.0f, 1.0f,  // back right
-    1.0f, 1.0f,  // back right
-    0.0f, 1.0f,  // back left
-    0.0f, 0.0f,  // front left
+class Config {
+public:
+    Config();
+    ~Config();
+
+    static Config& get();
+
+    toml::table& table();
+
+    void load_or_create_config();
+    void save_to_file();
+
+    template <TomlValueType T> T get(std::string_view key) const {
+        size_t cur = 0;
+        auto pos = key.find('.');
+        const toml::table* table = &m_tbl;
+        while (pos != std::string_view::npos) {
+            std::string_view s = key.substr(cur, pos - cur);
+            if (s.empty()) {
+                Logger::error("Empty key/table name in path '{}'", key);
+                ASSERT(false);
+                std::abort();
+            }
+            cur = pos + 1;
+            pos = key.find('.', cur);
+            if (auto* next = (*table)[s].as_table()) {
+                table = next;
+            } else {
+                Logger::error("Can't find table {}", s);
+                ASSERT(false);
+                std::abort();
+            }
+        }
+        std::string_view n_key = key.substr(cur);
+        if (n_key.empty()) {
+            Logger::error("Trailing dot in path '{}'", key);
+            ASSERT(false);
+            std::abort();
+        }
+        auto opt = (*table)[n_key].value<T>();
+        if (opt) {
+            return *opt;
+        } else {
+            Logger::error("Can't find key {}", n_key);
+            ASSERT(false);
+            std::abort();
+        }
+    }
+    template <typename T> void set(std::string_view key, T&& val) {
+        if constexpr (!TomlValueType<std::decay_t<T>>) {
+            static_assert(false, "Type Not Support");
+        }
+        size_t cur = 0;
+        auto pos = key.find('.');
+        toml::table* table = &m_tbl;
+        while (pos != std::string_view::npos) {
+            std::string_view s = key.substr(cur, pos - cur);
+            if (s.empty()) {
+                Logger::error("Empty key/table name in path '{}'", key);
+                ASSERT(false);
+                std::abort();
+            }
+            cur = pos + 1;
+            pos = key.find('.', cur);
+            if (auto* next = (*table)[s].as_table()) {
+                table = next;
+            } else {
+                auto [it, inserted] = table->insert_or_assign(s, toml::table{});
+                table = it->second.as_table();
+            }
+        }
+        std::string_view n_key = key.substr(cur);
+        if (n_key.empty()) {
+            Logger::error("Trailing dot in path '{}'", key);
+            ASSERT(false);
+            std::abort();
+        }
+        table->insert_or_assign(n_key, std::forward<T>(val));
+    }
+    template <typename T> void set_and_save(std::string_view key, T&& val) {
+        set(key, std::forward(val));
+        save_to_file();
+    }
+    toml::node_view<toml::node> val_view(std::string_view key);
+
+private:
+    toml::table m_tbl;
+    constexpr static inline std::string_view CONGIF_PATH =
+        ASSETS_PATH "config.toml";
+    void create_config();
 };
 
-constexpr float CUBE_VER[24] = {
-        0.0, 0.0, 0.0,
-        1.0, 0.0, 0.0,
-        1.0, 1.0, 0.0,
-        0.0, 1.0, 0.0,
-        0.0, 0.0, 1.0,
-        1.0, 0.0, 1.0,
-        1.0, 1.0, 1.0,
-        0.0, 1.0, 1.0
-    };
-
-
-constexpr int OUTLINE_CUBE_INDICES[24] = {
-        0,1, 1,2, 2,3, 3,0,
-        4,5, 5,6, 6,7, 7,4,
-        0,4, 1,5, 2,6, 3,7
-    };
-
-constexpr float SQUARE_VERTICES[6][2] = {
-        -0.5f, -0.5f,  // bottom left
-        -0.5f,  0.5f,  // top left
-        0.5f,  0.5f,  // top right
-        0.5f,  0.5f,  // top right
-        0.5f, -0.5f,  // bottom right
-        -0.5f, -0.5f   // bottom left
-    };
-
-constexpr float SQUARE_TEXTURE_POS[6][2] = {
-        0.0f, 0.0f,
-        0.0f, 1.0f,
-        1.0f, 1.0f,
-        1.0f, 1.0f,
-        1.0f, 0.0f,
-        0.0f, 0.0f,
-    };
-
-struct Vertex {
-    float x = 0.0f, y = 0.0f, z = 0.0f;
-    float s = 0.0f, t = 0.0f;
-    float layer = 0.0f;
-};
-
-struct Vertex2D {
-    float x = 0.0f, y = 0.0f;
-    float s = 0.0f, t = 0.0f;
-    float layer = 0.0f;
-};
+} // namespace Cubed

include/Cubed/constants.hpp

@@ -0,0 +1,35 @@
+#pragma once
+#include "Cubed/gameplay/chunk_pos.hpp"
+
+#include <array>
+namespace Cubed {
+
+constexpr int WORLD_SIZE_Y = 256;
+constexpr int CHUNK_SIZE = 16;
+constexpr int SEA_LEVEL = 63;
+
+constexpr int MAX_UI_NUM = 1;
+constexpr int MAX_BLOCK_STATUS = 1;
+constexpr int MAX_BIOME_SUM = 4;
+constexpr int MAX_CHARACTER = 128;
+
+constexpr int PRE_LOAD_DISTANCE = 24;
+
+constexpr int MAX_DISTANCE = 128;
+constexpr int CROSS_PLANE_DISTANCE = 8;
+constexpr float DEFAULT_FOV = 70.0f;
+constexpr float DEFAULT_MAX_WALK_SPEED = 4.5f;
+constexpr float DEFAULT_MAX_RUN_SPEED = 7.0f;
+constexpr float DEFAULT_ACCELERATION = 10.0f;
+constexpr float DEFAULT_DECELERATION = 15.0f;
+constexpr float DEFAULT_G = 22.5f;
+static constexpr int SIZE_X = CHUNK_SIZE;
+static constexpr int SIZE_Y = WORLD_SIZE_Y;
+static constexpr int SIZE_Z = CHUNK_SIZE;
+
+constexpr ChunkPos CHUNK_DIR[]{{1, 0}, {-1, 0}, {0, 1},  {0, -1},
+                               {1, 1}, {-1, 1}, {1, -1}, {-1, -1}};
+
+using HeightMapArray = std::array<std::array<int, CHUNK_SIZE>, CHUNK_SIZE>;
+
+} // namespace Cubed

include/Cubed/debug_collector.hpp

@@ -1,14 +1,16 @@
 #pragma once
 
-#include <Cubed/ui/text.hpp>
+#include "Cubed/ui/text.hpp"
 
 #include <unordered_map>
 
+namespace Cubed {
+
 class DebugCollector {
 public:
     static DebugCollector& get();
     DebugCollector();
-    
+
     std::unordered_map<std::size_t, Text>& all_texts();
 
     Text& text(std::string_view name);
@@ -17,4 +19,6 @@ public:
 
 private:
     std::unordered_map<std::size_t, Text> m_texts;
-};
+};
+
+} // namespace Cubed

include/Cubed/dev_panel.hpp

@@ -0,0 +1,60 @@
+#pragma once
+
+#include <toml++/toml.hpp>
+
+namespace Cubed {
+
+class App;
+class Player;
+class DevPanel {
+    struct ConfigView {
+        float fov = 70.0f;
+        bool fullscreen = false;
+        bool v_sync = true;
+        float mouse_sensitivity = 0.15f;
+        int width = 800;
+        int height = 600;
+        int rendering_distance = 24;
+        int aniso = 1;
+        int max_aniso = 1;
+        bool is_enable_aniso = false;
+        bool is_support_aniso = true;
+        bool is_reload = true;
+    };
+    struct PlayerProfile {
+        int game_mode = 0;
+        int gait = 0;
+        float pos[3] = {0.0f, 0.0f, 0.0f};
+    };
+    struct TextEditing {
+        bool perlin_seed = false;
+    };
+
+public:
+    DevPanel(App& app);
+    void init();
+    void render();
+
+private:
+    App& m_app;
+    ConfigView m_config;
+    Player* m_player;
+    PlayerProfile m_player_profile;
+    TextEditing m_text_editing;
+    bool m_need_save_config = false;
+    bool m_gen_thread_running = true;
+    int m_theme = 0;
+    void show_about_table_bar();
+    void show_biome_table_bar();
+    void show_cave_table_bar();
+    void show_river_table_bar();
+    void show_settings_tab_item();
+    void show_world_tab_item();
+    void show_player_tab_item();
+    void show_items_tab_item();
+
+    void update_config_view();
+    void update_player_profile();
+};
+
+} // namespace Cubed

include/Cubed/gameplay/biome.hpp

@@ -0,0 +1,80 @@
+#pragma once
+#include <array>
+#include <string>
+#include <vector>
+
+namespace Cubed {
+
+constexpr float BIOME_NOISE_FREQUENCY = 0.06f;
+constexpr float HEIGHTMAP_NOISE_FREQUENCY = 0.001f;
+constexpr float MOUNTAINOUS_NOISE_FREQUENCY = 0.003f;
+enum class BiomeType {
+    PLAIN = 0,
+    FOREST,
+    DESERT,
+    MOUNTAIN,
+    RIVER,
+    SNOWY_PLAIN,
+    OCEAN,
+    NONE
+};
+
+struct BiomeConditions {
+    float temp = 0.0f;
+    float humid = 0.0f;
+    float mountainous = 0.0f;
+};
+
+struct BiomeHeightRange {
+    int base_y;
+    int amplitude;
+};
+
+struct BiomeNonAdjacent {
+    BiomeType first;
+    std::vector<BiomeType> second;
+    BiomeType replace;
+};
+
+static inline const std::vector<BiomeNonAdjacent> NON_ADJACENT{
+    {{BiomeType::PLAIN, {BiomeType::DESERT}, BiomeType::RIVER},
+     {BiomeType::FOREST, {BiomeType::DESERT}, BiomeType::RIVER},
+     {BiomeType::DESERT, {BiomeType::FOREST}, BiomeType::RIVER},
+     {BiomeType::MOUNTAIN, {BiomeType::NONE}, BiomeType::RIVER}}};
+
+struct BaseBiomeParams {
+    BiomeType biome;
+    std::pair<float, float> temp;
+    std::pair<float, float> humid;
+    std::array<float, 3> frequencies;
+    BiomeHeightRange height_range;
+};
+
+struct PlainParams : public BaseBiomeParams {};
+
+struct ForestParams : public BaseBiomeParams {
+    float tree_frequency;
+};
+
+struct DesertParams : public BaseBiomeParams {};
+
+struct MountainParams : public BaseBiomeParams {};
+
+struct RiverParams : public BaseBiomeParams {};
+
+std::string get_biome_str(BiomeType biome);
+// std::array<float, 3> get_noise_frequencies_for_biome(BiomeType biome);
+// BiomeHeightRange get_biome_height_range(BiomeType biome);
+BiomeType safe_int_to_biome(int x);
+int get_interpolated_height(float world_x, float world_z, float temp,
+                            float humid);
+
+BiomeType determine_biome(const BiomeConditions& conditions);
+
+PlainParams& plain_params();
+ForestParams& forest_params();
+DesertParams& desert_params();
+MountainParams& mountain_params();
+RiverParams& river_params();
+
+} // namespace Cubed

include/Cubed/gameplay/block.hpp

@@ -1,10 +1,13 @@
 #pragma once
+
 #include <glad/glad.h>
 #include <glm/glm.hpp>
 #include <string>
 #include <vector>
 
+namespace Cubed {
 
+using BlockType = uint8_t;
 
 struct BlockTexture {
     std::string name;
@@ -12,9 +15,7 @@ struct BlockTexture {
     std::vector<GLuint> texture;
 };
 
-struct Block : public BlockTexture{
-
-};
+struct Block : public BlockTexture {};
 
 struct BlockRenderData {
     std::vector<bool> draw_face;
@@ -22,12 +23,8 @@ struct BlockRenderData {
     BlockRenderData() = default;
     BlockRenderData(const BlockRenderData&) = default;
     BlockRenderData& operator=(const BlockRenderData&) = default;
-    BlockRenderData(BlockRenderData&& data) :
-        draw_face(std::move(data.draw_face)),
-        block_id(data.block_id)
-    {
-        
-    }
+    BlockRenderData(BlockRenderData&& data)
+        : draw_face(std::move(data.draw_face)), block_id(data.block_id) {}
     BlockRenderData& operator=(BlockRenderData&& data) {
         draw_face = std::move(data.draw_face);
         block_id = data.block_id;
@@ -38,4 +35,57 @@ struct BlockRenderData {
 struct LookBlock {
     glm::ivec3 pos;
     glm::ivec3 normal;
-};
+};
+
+struct BlockData {
+    std::string name;
+    BlockType id = 0;
+
+    bool is_liquid = false;
+    bool is_gas = false;
+
+    bool is_passable = false;
+    bool is_cross_plane = false;
+    bool is_transparent = false;
+
+    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)
+        : 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) {}
+};
+
+class BlockManager {
+
+public:
+    static const std::vector<BlockData>& datas();
+    static void init();
+    static unsigned sums();
+    static unsigned cross_plane_sum();
+    static const std::string& name_form_id(BlockType id);
+
+    static bool is_gas(BlockType id);
+    static bool is_liquid(BlockType id);
+
+    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 bool is_transitional(BlockType id);
+    static BlockType cross_plane_index(BlockType id);
+
+private:
+    static void set_up_cross_plane_map();
+    static inline std::vector<BlockData> m_datas;
+    static inline bool is_init = false;
+    static inline std::unordered_map<BlockType, BlockType> m_cross_plane_map;
+};
+
+} // namespace Cubed

include/Cubed/gameplay/builders/biome_builder.hpp

@@ -0,0 +1,18 @@
+#pragma once
+
+namespace Cubed {
+class ChunkGenerator;
+class BiomeBuilder {
+public:
+    BiomeBuilder() = default;
+    virtual ~BiomeBuilder() = default;
+    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();
+};
+} // namespace Cubed

include/Cubed/gameplay/builders/desert_builder.hpp

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "Cubed/gameplay/builders/biome_builder.hpp"
+namespace Cubed {
+
+class ChunkGenerator;
+
+class DesertBuilder : public BiomeBuilder {
+public:
+    DesertBuilder(ChunkGenerator& chunk_generator);
+    void build_biome() override;
+    ChunkGenerator& get_chunk_generator() override;
+    void build_vegetation() override;
+
+private:
+    ChunkGenerator& m_chunk_generator;
+
+    void build_blocks();
+};
+
+} // namespace Cubed

include/Cubed/gameplay/builders/forest_builder.hpp

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "Cubed/gameplay/builders/biome_builder.hpp"
+namespace Cubed {
+
+class ChunkGenerator;
+
+class ForestBuilder : public BiomeBuilder {
+public:
+    ForestBuilder(ChunkGenerator& chunk_generator);
+    void build_biome() override;
+    ChunkGenerator& get_chunk_generator() override;
+    void build_vegetation() override;
+
+private:
+    ChunkGenerator& m_chunk_generator;
+
+    void build_blocks();
+};
+
+} // namespace Cubed

include/Cubed/gameplay/builders/mountain_builder.hpp

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "Cubed/gameplay/builders/biome_builder.hpp"
+namespace Cubed {
+
+class ChunkGenerator;
+
+class MountainBuilder : public BiomeBuilder {
+public:
+    MountainBuilder(ChunkGenerator& chunk_generator);
+    void build_biome() override;
+    ChunkGenerator& get_chunk_generator() override;
+    void build_vegetation() override;
+
+private:
+    ChunkGenerator& m_chunk_generator;
+
+    void build_blocks();
+};
+
+} // namespace Cubed

include/Cubed/gameplay/builders/ocean_builder.hpp

@@ -0,0 +1,23 @@
+#pragma once
+
+#pragma once
+
+#include "Cubed/gameplay/builders/biome_builder.hpp"
+namespace Cubed {
+
+class ChunkGenerator;
+
+class OceanBuilder : public BiomeBuilder {
+public:
+    OceanBuilder(ChunkGenerator& chunk_generator);
+    void build_biome() override;
+    ChunkGenerator& get_chunk_generator() override;
+    void build_vegetation() override;
+
+private:
+    ChunkGenerator& m_chunk_generator;
+
+    void build_blocks();
+};
+
+} // namespace Cubed

include/Cubed/gameplay/builders/plain_builder.hpp

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "Cubed/gameplay/builders/biome_builder.hpp"
+namespace Cubed {
+
+class ChunkGenerator;
+
+class PlainBuilder : public BiomeBuilder {
+public:
+    PlainBuilder(ChunkGenerator& chunk_generator);
+    void build_biome() override;
+    ChunkGenerator& get_chunk_generator() override;
+    void build_vegetation() override;
+
+private:
+    ChunkGenerator& m_chunk_generator;
+
+    void build_blocks();
+};
+
+} // namespace Cubed

include/Cubed/gameplay/builders/river_builder.hpp

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "Cubed/gameplay/builders/biome_builder.hpp"
+namespace Cubed {
+
+class ChunkGenerator;
+
+class RiverBuilder : public BiomeBuilder {
+public:
+    RiverBuilder(ChunkGenerator& chunk_generator);
+    void build_biome() override;
+    ChunkGenerator& get_chunk_generator() override;
+    void build_vegetation() override;
+
+private:
+    ChunkGenerator& m_chunk_generator;
+
+    void build_blocks();
+};
+
+} // namespace Cubed

include/Cubed/gameplay/builders/snowy_plain_builder.hpp

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "Cubed/gameplay/builders/biome_builder.hpp"
+namespace Cubed {
+
+class ChunkGenerator;
+
+class SnowyPlainBuilder : public BiomeBuilder {
+public:
+    SnowyPlainBuilder(ChunkGenerator& chunk_generator);
+    void build_biome() override;
+    ChunkGenerator& get_chunk_generator() override;
+    void build_vegetation() override;
+
+private:
+    ChunkGenerator& m_chunk_generator;
+
+    void build_blocks();
+};
+
+} // namespace Cubed

include/Cubed/gameplay/cave_carver.hpp

@@ -0,0 +1,27 @@
+#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();
+    void init(unsigned world_seed);
+    void reload(unsigned world_seed);
+    void add_path(const glm::vec3& pos, unsigned chunk_seed);
+    void try_to_add_path(const ChunkPos& pos, unsigned chunk_seed);
+    void cleanup_finished_caves();
+
+    int cave_sum() const;
+    float& cave_probability();
+
+private:
+    CaveHashMap m_paths;
+    unsigned m_seed = 0;
+    Random m_random;
+    float m_cave_probability = 0.035f;
+};
+} // namespace Cubed

include/Cubed/gameplay/cave_path.hpp

@@ -0,0 +1,54 @@
+#pragma once
+
+#include "Cubed/gameplay/chunk_pos.hpp"
+#include "Cubed/gameplay/path_point.hpp"
+#include "Cubed/tools/cubed_random.hpp"
+
+#include <glm/glm.hpp>
+#include <tbb/concurrent_hash_map.h>
+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);
+    const std::vector<PathPoint>& points() const;
+    void clear_chunk(const ChunkPos& pos);
+    bool is_finished() const;
+
+    static float& radius_xz_min();
+    static float& radius_xz_max();
+    static float& radius_y_min();
+    static float& radius_y_max();
+    static float& delta_angle_min();
+    static float& delta_angle_max();
+    static int& step_min();
+    static int& step_max();
+
+private:
+    static inline float m_radius_xz_min = 5.0f;
+    static inline float m_radius_xz_max = 15.0f;
+    static inline float m_radius_y_min = 4.0f;
+    static inline float m_radius_y_max = 10.0f;
+    static inline float m_delta_angle_min = -5.0f;
+    static inline float m_delta_angle_max = 5.0f;
+    static inline int m_step_min = 10;
+    static inline int m_step_max = 400;
+
+    unsigned int m_seed = 0;
+    float m_yaw = 0.0f;
+    float m_pitch = 0.0f;
+    int m_step = 0;
+    float m_step_len = 1.0f;
+    PathPoint m_start_path_point{{0.0f, 0.0f, 0.0f}, 0.0f, 0.0f};
+    Random m_random;
+
+    std::vector<PathPoint> m_points;
+    ChunkPosSet m_pending_chunks;
+    void collect_path_points();
+    void precompute_chunk_coverage();
+};
+} // namespace Cubed

include/Cubed/gameplay/chunk.hpp

@@ -1,59 +1,134 @@
 #pragma once
 
-#include <atomic>
-#include <cstdint>
+#include "Cubed/gameplay/biome.hpp"
+#include "Cubed/gameplay/block.hpp"
+#include "Cubed/gameplay/chunk_generator.hpp"
+#include "Cubed/gameplay/chunk_pos.hpp"
+#include "Cubed/gameplay/vertex_data.hpp"
 
-#include <Cubed/config.hpp>
-#include <Cubed/gameplay/chunk_status.hpp>
-#include <Cubed/gameplay/block.hpp>
+#include <atomic>
+#include <mutex>
+namespace Cubed {
 
 class World;
-// if want to use, do init_chunk(), gen_vertex_data() and 
+// if want to use, do init_chunk(), gen_vertex_data() and
 class Chunk {
 private:
-    std::atomic<bool> m_dirty {false};
-    
-    static constexpr int SIZE_X = CHUCK_SIZE;
+    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 = CHUCK_SIZE;
-    
+    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<BiomeType> m_biome = BiomeType::PLAIN;
+    std::mutex m_vertexs_data_mutex;
+
+    std::unique_ptr<ChunkGenerator> m_generator;
+
     ChunkPos m_chunk_pos;
     World& m_world;
+    HeightMapArray m_heightmap;
     // the index is a array of block id
-    std::vector<uint8_t> m_blocks;
-    GLuint m_vbo = 0;
-    std::vector<Vertex> m_vertexs_data;
-    
+    std::vector<BlockType> m_blocks;
+
+    /*
+    0 - normal
+    1 - cross_plane
+    2 - normal_discard
+    3 - transparent and blend
+    */
+    std::vector<VertexData> m_vertex_data;
     float frequency = 0.01f;
     float height = 80;
+    unsigned m_seed = 0;
+
+    BiomeConditions m_conditions;
 
     void clear_dirty();
+    void gen_vertices(const OptionalBlockVectorArray& neighbor_block);
+    void gen_cross_plane_vertices(int world_x, int world_y, int world_z,
+                                  BlockType id);
+
 public:
     Chunk(World& world, ChunkPos chunk_pos);
     ~Chunk();
     Chunk(const Chunk&) = delete;
     Chunk& operator=(const Chunk&) = delete;
-    Chunk(Chunk&&);
-    Chunk& operator=(Chunk&&);
-    const std::vector<uint8_t>& get_chunk_blocks() const;    
-    
-    static int get_index(int x, int y, int z);
-    
-    void init_chunk();
-    void gen_vertex_data();
-    // 0 : (1, 0)
-    // 1 : (-1, 0) 
-    // 2 : (0, 1) 
-    // 3 : (0, -1)
-    void gen_vertex_data(const std::vector<const std::vector<uint8_t>*>& neighbor_block);
+    Chunk(Chunk&&) noexcept;
+    Chunk& operator=(Chunk&&) noexcept;
+
+    static std::tuple<int, int, int> world_to_block(int world_x, int world_y,
+                                                    int world_z, int chunk_x,
+                                                    int chunk_z);
+    static std::tuple<int, int, int> world_to_block(const glm::ivec3& block_pos,
+                                                    ChunkPos chunk_pos);
+    static std::tuple<int, int, int> block_to_world(int x, int y, int z,
+                                                    int chunk_x, int chunk_z);
+    static std::tuple<int, int, int> block_to_world(const glm::ivec3& block_pos,
+                                                    ChunkPos chunk_pos);
+    BiomeType get_biome() const;
+    ChunkPos get_chunk_pos() const;
+    const std::vector<BlockType>& get_chunk_blocks() const;
+    HeightMapArray get_heightmap() const;
+    static int index(int x, int y, int z);
+    static int index(const glm::vec3& pos);
+    // Init Chunk
+    // Determine biome from temperature and humidity noise
+    void gen_phase_one();
+    // Resolve biome adjacency conflicts with neighbor chunks
+    void gen_phase_two(const std::array<const Chunk*, 8>& adj_chunks);
+    // Generate heightmap using biome-specific noise
+    void gen_phase_three();
+    // Blend heightmap with neighbors for smooth transitions
+    void gen_phase_four(
+        const std::array<std::optional<HeightMapArray>, 8>& neighbor_heightmap,
+        const std::array<BiomeType, 8>& neighbor_biome);
+    // Generate terrain blocks from heightmap and biome
+    void gen_phase_five();
+    // Blend surface blocks at chunk borders with neighbors
+    void gen_phase_six(const std::array<std::optional<std::vector<BlockType>>,
+                                        4>& neighbor_block);
+    // Generate biome-specific vegetation/structures
+    void gen_phase_seven();
+    // void gen_vertex_data();
+    //  0 : (1, 0)
+    //  1 : (-1, 0)
+    //  2 : (0, 1)
+    //  3 : (0, -1)
+    void gen_vertex_data(const OptionalBlockVectorArray& neighbor_block);
     void upload_to_gpu();
-    
-    GLuint get_vbo() const;
-    const std::vector<Vertex>& get_vertex_data() const;
-   
+
+    GLuint get_normal_vao() const;
+    size_t get_normal_vertices_sum() const;
+
+    GLuint get_cross_vao() const;
+    size_t get_cross_vertices_sum() const;
+
+    GLuint get_normal_discard_vao() const;
+    size_t get_normal_discard_vertices_sum() const;
+
+    GLuint get_normal_blend_vao() const;
+    size_t get_normal_blend_vertices_sum() const;
+
     bool is_dirty() const;
     void mark_dirty();
-    
+
+    bool is_need_upload() const;
+    void need_upload();
+
     void set_chunk_block(int index, unsigned id);
-    
-};
+
+    ChunkPos chunk_pos() const;
+    BiomeType biome() const;
+    void biome(BiomeType b);
+    HeightMapArray& heightmap();
+    std::vector<BlockType>& blocks();
+    World& world();
+    unsigned seed() const;
+    BiomeConditions& conditions();
+};
+
+} // namespace Cubed

include/Cubed/gameplay/chunk_generator.hpp

@@ -0,0 +1,70 @@
+#pragma once
+
+#include "Cubed/constants.hpp"
+#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>
+#include <memory>
+#include <optional>
+namespace Cubed {
+
+class Chunk;
+
+class ChunkGenerator {
+public:
+    ChunkGenerator(Chunk& chunk);
+
+    static void init();
+    static void reload();
+    static const unsigned& seed();
+    static void seed(unsigned s);
+    unsigned chunk_seed() const;
+    // Generate Biome
+    void assign_chunk_biome();
+    // Adjust Biome
+    void resolve_biome_adjacency_conflict(
+        const std::array<const Chunk*, 8>& adj_chunks);
+    // Generate Heightmap
+    void generate_heightmap();
+    // Adjust Height
+    void blend_heightmap_boundaries(
+        const std::array<std::optional<HeightMapArray>, 8>& neighbor_heightmap,
+        const std::array<BiomeType, 8>& neighbor_biome);
+    // Generate Block
+    void generate_terrain_blocks();
+    // Adjust Block;
+    void blend_surface_blocks_borders(
+        const std::array<std::optional<std::vector<BlockType>>, 4>&
+            neighbor_block);
+    // Generate Structure
+    void generate_vegetation();
+    BiomeType get_biome_at(float world_x, float world_z);
+    Chunk& chunk();
+    Random& random();
+    const std::array<BiomeType, 8>& neighbor_biome() const;
+    void ocean_build();
+    void generate_cave();
+    void generate_river();
+
+private:
+    static inline std::atomic<bool> is_init{false};
+    static inline unsigned m_generator_seed{0};
+    static inline std::atomic<bool> is_seed_change{false};
+    Chunk& m_chunk;
+    Random m_random;
+    std::unique_ptr<BiomeBuilder> m_biome_builder{nullptr};
+    bool is_cur_chunk_ins = false;
+    std::array<BiomeType, 8> m_neighbor_biome;
+    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