* refactor(ui): replace Text with Label/Widget component system
Replace the old `Text` class with a new component-based UI system consisting of `Widget` and `Label` classes. Key changes:
- Remove `Text` class and its GPU upload logic; introduce `Label` as a `Widget` subclass with dirty-flag vertex update.
- Add `UIVertexData` struct to manage per-label vertex buffer/array and memory.
- Refactor `DebugCollector` to store labels in a `Widget` tree, removing hash-based lookup.
- Simplify `Font::vertices()` signature by removing position/scale parameters; scaling is now applied in the renderer’s model matrix.
- Update `Renderer` with `render_label()` and move UI rendering to a `render_ui()` that renders the widget tree.
- Add new source files `label.cpp`, `widget.cpp`, `ui_vertex_data.cpp` and update CMakeLists.
* refactor(render): replace UI shaders with image shaders and Image widget
* refactor(core): add event system and scene management
- Introduce Event variant and Overloaded helper for input handling
- Move game state (camera, client_world, dev_panel) from App to WorldScene
- Add SceneManager with push/pop/change operations for scene stack
- Refactor input callbacks to dispatch events through scene hierarchy
- Extract Argument struct to separate header
- Update Renderer and WorldRenderer to accept world reference
- Replace global input state with event-driven processing in ClientPlayer, Camera, etc.
* refactor: add framebuffer resize event and separate UI management
* fix(font): use correct texture format and clamp to edge for font atlas
* feat(input): add KeyAction::REPEAT for key repeat events
Add a new REPEAT value to the KeyAction enum and update the input callbacks to map GLFW_REPEAT actions to the new value instead of treating them as press.
* feat(client-player): add block cooldown and track mouse state
Introduce a time-based cooldown for block placement (PLACE_BLOCK_INTERVAL) to prevent rapid clicking. Replace the global InputState with per-player MouseState tracking in ClientPlayer. Rename place_block() to get_current_block() for clarity. Remove the old src/input.cpp and the Cubed/input.hpp header, moving input structures to Cubed/input/input.hpp.
* ui: add main menu scene and interactive button widget
- Implement MainMenuScene with a "Start Game" button that pushes the WorldScene.
- Extend Button class with background/foreground, hover detection, and size queries.
- Add virtual width/height and event handlers to Widget base class.
- Update WorldUIManager to propagate mouse move events.
- Adjust Window mouse mode based on game running state.
* feat(ui): add button scaling and change square vertices to top-left origin
* refactor(font): return TextMesh from Font::vertices to include bounding box
Replace the plain vertex vector with a TextMesh struct that carries width, height, and min coordinates. Update Label to compute and store these values immediately on text change (removing lazy dirty update). Fix Button's width/height to factor in scale and use concrete widget types for background and foreground.
* feat(ui): support scaling of labels and images
Modify width() and height() methods to multiply by m_scale for both Label and Image. Rename internal dimensions to m_real_width and m_real_height for clarity. Adjust Button foreground position to vertically center when label is scaled.
* refactor(ui): move scale property to subclasses and fix resize event handling
Remove scale from base Widget class and add per-type set_scale/scale methods to Button, Image, and Label. Dispatch separate WindowResizeEvent alongside existing FrameBufferResizeEvent. Correct centering calculations from `+` to `-` in main menu and world UI managers.
* fix(render): remove duplicate scaling in render_image model matrix
* feat(ui): introduce anchor-based widget positioning system
Replace set_position with anchor and offset for relative positioning. Add parent pointer to widget hierarchy. Remove manual resize logic in UI managers.
* feat(ui): introduce ColumnLayout widget and refactor widget parenting
- Add ColumnLayout widget that arranges children vertically with spacing.
- Refactor Widget::add_child to automatically pass `this` as parent.
- Update DebugCollector to use ColumnLayout for consistent spacing.
- Expose children() accessor in Widget for layout management.
* feat(main_menu): add exit button and refactor layout with ColumnLayout
- Add `should_close_window()` method to force window close from UI.
- Replace standalone button with ColumnLayout for proper centering.
- Add "Exit" button that calls `should_close_window()`.
- Update ESC key handling to only close window when game is not running.
- Fix ColumnLayout to respect parent's anchor instead of hardcoded TOP_LEFT.
- Remove unused parameter name in Image::update for consistency.
* feat(ui): add Rect widget with fill, color, and parent-relative sizing
* refactor(ui): extract common UI manager logic into base class
* refactor: move server logic to WorldScene and refactor UI methods
* feat(scene): implement pause menu with UI manager and escape key toggling
Add PauseMenuUIManager class and integrate pause state into WorldScene.
Escape key toggles pause in ClientPlayer and PauseMenuUIManager.
Refactor Window mouse and imgui control to support pause state.
* refactor(scene): dispatch events via typed handlers and move pause toggle to WorldScene
* feat(ui): add HUD visibility toggle and image fill features
* refactor(app): remove redundant ImGui WantCaptureMouse check in cursor callback
* feat(scene): add credits scene and UI
* feat(credits): add ESC key handling; remove about tab from dev panel
* feat(ui): add Slider widget for value selection
* refactor(ui/slider): improve track/thumb initialization and validation
Rename track/thumb accessors from set_track/set_thumb to get_track/get_thumb.
Add private init methods and a constant THUMB_WIDTH.
Add validation to set_width with log and assert.
Modify set_height to assume non-null m_thumb.
* refactor(ui): simplify Button API with property setters
* feat(ui): add label and image support to slider
- Add `set_text()`, `set_track_image()`, `set_thumb_image()` methods.
- Include label rendering and auto-scaling based on slider dimensions.
- Replace static `THUMB_WIDTH` with dynamic thumb sizing.
- Add slider thumb and track texture assets.
* feat(ui): add int slider support and fix update_text_scale calls
* refactor(config): rename hot_reload to reload_config and add settings scene
* feat(ui): add auto-scaling option for button and slider text
* feat(ui): add button enable/disable and reset on re-enter
Prevent double-clicking on buttons that push new scenes by disabling them on click and re-enabling when the UI manager's on_re_enter is called.
* fix(input): reset key status on pause
* feat(ui): add ComboButton widget and integrate into settings
Introduce ComboButton, a button that cycles through options on click.
Used in SettingsUI for fullscreen, V-Sync, and anisotropic filtering.
Adds texture reload support in SettingsScene and makes Button methods
virtual to allow overriding. Also fixes default mouse_enable to true.
* feat(ui): add child anchor and content sizing to column layout
* feat(ui): add TextField widget with UTF-8 text input support
* feat(scene): add host game scene and world parameter handling
* feat(scene): add join game scene and UI
* feat(ui): add clipboard paste to TextField
* feat(ui): add blinking cursor to text field
* feat(ui): add error UI for connection failures and network errors
Introduce ErrorUI to display error messages in-world when the client encounters connection failures or network errors. The network client now stores error strings thread-safely and exposes them via `get_error_string()`. The world scene suspends normal update/render when an error is active and shows the error overlay, allowing the user to return to the previous scene. Additionally, the client world checks for connection errors during exit to avoid hanging, and the join game UI is fixed to correctly default to client mode.
* refactor: move connect error check to WorldScene and add UI titles
* feat(ui): add error display in host and join game screens
* feat(ui): add configurable child traversal order for event handling
Add TraversalOrder enum to Widget, allowing event handlers to iterate children in back-to-front (default) or front-to-back order.
Set ColumnLayout to front-to-back order.
Change TextField mouse button handler to return false, enabling event propagation.
* fix: window build fail
* style(ui): remove extra blank line
* refactor(config): replace singleton with dependency injection
* refactor(client_player): return ChunkPosSet by value in non-const getter
Copy the internal set under the mutex lock to avoid exposing a mutable reference that could be used unsafely after the lock is released. This fixes a potential data race when the caller holds the returned reference beyond the critical section. Also update the caller in `client_world` to remove the now-unnecessary `std::move`.
* fix(gameplay): prevent use-after-free in pending delete queues during destruction
* refactor(config): separate game and server configuration with explicit paths
* refactor(render): move render files to subdirectory, add RAII vertex buffer/array classes
* refactor(render): encapsulate OpenGL textures into Texture class
* refactor(texture): encapsulate textures with unique_ptr and bind methods
Replace raw GLuint framebuffer textures with std::unique_ptr<Texture>. Update TextureManager to return const Texture* instead of GLuint. Use Texture::bind() for active texture binding. Add RGBA16F and RGB formats. Add texture parameter methods. Update destructors accordingly.
* refactor(render): use Texture, VertexBuffer, VertexArray classes
* feat(render): add FrameBuffer class to encapsulate framebuffer operations
* refactor(render): extract world rendering into WorldRenderer class
* refactor(render): rename projection and model matrix members for clarity
* chore(render): remove unused matrix members
* fix(texture-manager): correct delet_texture typo and add null checks for textures
* refactor(player): extract player rendering into PlayerRenderer class
Move player rendering code from Renderer to new PlayerRenderer class.
Add normal and tangent vertex attributes for improved per-pixel lighting.
* feat(player-renderer): add shadow rendering and include local player data
* feat(gameplay): add player yaw/pitch synchronization and rendering
* refactor(player_renderer): split rendering into per-body-part VAOs and VBOs
Move `PlayerVertex` struct to header and replace single VAO/VBO with arrays of 6 parts. Implement head pitch rotation in `render()` and `shadow_render()` by applying a separate model matrix for the head (index 0). Remove old `vao()` and `sum()` accessors. Adjust model translation for consistency.
* feat(player): add texture mapping to player model using skin
* fix(player-renderer): correct player rendering rotation and texture coordinates
* feat(gameplay): add player gait system with limb animation
* fix(player): update leg UVs and remove yaw wrap
Update left and right leg UV coordinates to align with updated player texture. Remove yaw modulo operation to allow unrestricted yaw rotation beyond 360 degrees.
* feat(camera): add third-person perspective and walk animation
- Introduce Perspective enum (FIRST_PERSON, THIRD_PERSON_BACK, THIRD_PERSON_FRONT) and m_front member for camera direction.
- Handle F5 key to cycle perspectives.
- Add angle and walk_time to ClientPlayer for walking animation.
- Update player rendering to skip local player only in first person and fix rotation sign.
- Remove redundant player info reporting; update player data with animation angle.
* fix(camera): replace magic number with constant and fix missing break
* fix(client-player): stop sprinting on forward key release
* feat: add camera collision and sphere collision for world
* fix(skin): update player001 texture
* refactor(gameplay): improve thread safety and remove debug logging
* refactor(shaders): extract shadow and normal logic into include files and add lighting to player shaders
* chore(shader): remove unused uniforms cameraPos and specularStrength
* fix: inlcude <array> header
* build: add asio library
* feat(dev_panel): add Asio to about table
* refactor(gameplay): split Chunk into server/client variants and add networking
* feat(gameplay): add Session class and UUID generation utility
* feat(network): integrate protobuf for player sync and session management
Add Protobuf dependency, define proto messages for player requests, positions, and chunk data. Refactor Session to use strand and async write. Implement player join/exit and position sync in ServerWorld.
* refactor(proto): restructure protobuf definitions and update build system
* feat(protocol): add packet serialization and login handling
Introduce packet header and ID mapping for protobuf messages.
Refactor session and server_world to use new packet wrapper.
Fix missing semicolons in proto files.
* refactor(packet): serialize directly into packet buffer with ByteSizeLong
* feat(world): add player-based chunk loading and UUID support
Restructure world generation to trigger chunk loading based on player
movement. Replace player name with UUID for identification. Implement
chunk request/response protocol. Improve thread management for gen
thread.
* feat(server): add block change packet handling and increase reserved threads
* refactor(server): enhance thread safety and session management
* fix(session): catch std::exception in read_loop and log error
* fix(network-server): stop accept loop on shutdown flag
* fix(gameplay): correct unknown error log condition and missing chunk pos update
* feat(client): add client-side chunk, player, world and network classes
* feat(client-chunk): add greedy meshing, receive_chunk, and biome field
* feat(client_player): add name constructor param, remove chunk transition
* feat(gameplay): integrate network client and thread-safe player pos
* feat(gameplay): add block change sync and coordinate utils
* refactor(server): replace Chunk with ServerChunk
* refactor(gameplay): split world into client and server
Remove monolithic World, Player, Chunk classes. Introduce ClientWorld, ServerWorld, ClientPlayer, and related networked components. Add Abseil dependency for logging and checks. Rename old files to pre_remove_* and update all includes and references accordingly.
* feat(gameplay): add time sync and network improvements
* fix: correct neighbor block indexing and add time update support
* feat(gameplay): optimize chunk request with player chunk tracking
Add `update_player_chunk()` method to `ClientPlayer` that triggers a chunk request when the player moves more than 2 chunks away from the last recorded chunk. Introduce an atomic `m_requesting_chunk` flag in `ClientWorld` to prevent concurrent requests. Rename `m_player_chunk_pos` to `m_last_chunk_pos` for clarity.
* refactor(client_world): split pending queue into data and upload queues
* feat(client): add center-based chunk loading priority
* feat(app): add client/server CLI arguments and init guards
* feat(multiplayer): add rendering of other players as colored cubes
* feat(gameplay): add thread pool for asynchronous chunk data processing
* feat(gameplay): add player logout and disconnect handling
* fix(dev_panel): add protobuf to about table libraries
* build: add ZLIB dependency
* refactor(packet): replace zlib with zstd compression and restructure header
Increase header length to 12 bytes, add CompressType and PacketHeader struct, and implement decode_packet_header. Update CMake to find zstd and link against it, adding Findzstd module.
* refactor(network): extract packet header decoding into function
* feat(packet): implement zstd compression and refactor packet decoding
* perf(gameplay): optimize protobuf message allocation with Arena and limit thread pool size
Switch to Arena allocation for protobuf messages to reduce heap allocations. Pass ChunkDataRsp by value to enable move semantics. Cap thread pool size to hardware concurrency with max 4 threads.
* refactor(gameplay): use steady clock and sleep_until for tick loop timing
* refactor(gameplay): rename remote player types and add interpolation
* refactor(server_world): use thread pool for chunk request handling
* refactor(packet): replace if-constexpr chain with explicit template specializations
Refactor `get_packet_id()` by removing the if-constexpr chain and instead
providing explicit specializations for each packet type. This simplifies the
primary template (which now only contains a static assertion) and improves
compile-time dispatch clarity. The `always_false` helper is no longer needed
in the primary template.
* feat(gameplay): add packet to clear all chunks on server rebuild
Add new packet S2C_ClearAllChunks (ID 3005) to notify clients when the server rebuilds its world. Clients respond by clearing their chunk cache and requesting fresh chunks. Shift UPDATE_TIME packet ID to 3006 to accommodate.
* feat(dev_panel): split world tab; add chunk request logging and fix flag reset
* feat(tools): add RecentQueue to replace std::deque in server_world
* feat(gameplay): add task ID to chunk requests to discard stale responses
* refactor(block): move block source to gameplay directory
* feat(toml): add shared TOML utilities and handle ip.toml
* feat: add player name configuration and rename config file
- Add --player command-line argument and 'player' field in Arguments struct
- Rename ip.toml to server.toml and corresponding internal variable to 'server'
- Fix block.cpp source path in CMakeLists.txt
* build(cmake): modularize build configuration
* fix: build fail on windows
* refactor(renderer): rename Logger level enum value DEBUG to L_DEBUG
* refactor(world): rework chunk state machine and player chunk tracking
Introduce ChunkState enum and ChunkEntity struct to manage chunk lifecycle. Store chunks as shared_ptr to avoid move operations during generation. Add clear_unused_chunks to remove chunks not referenced by any player. Implement deferred chunk request queue for safe processing after generation completes. Update player chunk set during required chunk computation. Improve thread safety with mutexes on chunk and player maps. Fix m_gening flag not reset after generation and add assertions for correctness. Change need_gen to require a player UUID, removing std::optional. Add chunk_size query method for debugging.
* fix(server): ensure chunk is ready before sending or setting block
* refactor(server_world): separate gen and net thread pools
Introduce a second thread pool for network operations and a `ThreadPoolKind` enum to distinguish between gen and net pools. Rename `pool_threads()` to `gen_pool_threads()`, add `change_pool_threads()` overload that accepts the pool kind, and update the dev panel to use the gen pool. Adjust logging and initialization to handle both pools.
* feat(client_world): implement server exit acknowledgment with timeout
* feat(gameplay): implement server stop and client exit handling
Add server_stop flag to LogoutRsp protocol. Modify client_world to check for server stop or own logout to set exit flag. Add ServerWorld::stop() to broadcast stop and cleanly shut down. Refactor chunk ownership to unique_ptr. Remove name parameter from get_look_block_pos.
* fix(app): correct port validation and remove redundant TOML helper
* fix: address unused parameter warnings and missing port assignment
* refactor(gameplay): remove old pre_remove chunk, player, and world files
* refactor(server): replace chunk set with flat_hash_set and add ref count
- Replace std::unordered_set with absl::flat_hash_set for chunk position sets.
- Add ref_count field to ChunkEntity and implement update_ref_count().
- Remove clear_unused_chunks() and use ref counting for chunk lifetime.
- Add get_chunk_pos_set() accessors to ServerPlayer.
* fix(client-world): delay chunk request to wait for server central chunk generation
* refactor(gameplay): migrate chunk storage to tbb::concurrent_hash_map
* refactor(server_world): replace future-based chunk generation with queue
Remove `std::future` per-chunk tracking and poll_finished_chunks().
Instead, generation tasks push completed chunks to a concurrent queue
consumed during update. This eliminates wait_all_chunk_tasks() and
simplifies synchronization.
* refactor(client_world): use concurrent data structures for chunk management
Replace std::shared_mutex and std::unordered_set with tbb::concurrent_hash_map for chunk storage, tbb::concurrent_queue for pending uploads, and absl::flat_hash_set for player chunk positions. This improves thread safety and reduces locking overhead. Refactor receive_chunk and request_chunk to work with the new concurrent model.
* build(windows): add Nvidia and AMD GPU high performance exports
* fix(ci): update header file pattern in clang-format check
* style(clang-format): comment out AlignPPAndNotPP option
* chore: enable AlignPPAndNotPP in clang-format and pin clang version in CI
* ci(workflow): update format check to use LLVM 22
* ci(format-check): install clang-format-22
* perf(world): cull distant players from updates and rendering
Add distance2 utility function. On client, skip rendering other players if distance squared exceeds rendering distance. On server, only send player position and block change updates to players in relevant chunks.
* refactor(math_tools): convert free functions to inline in header
* refactor(dev_panel): remove seed editing and server rebuild world, move client rebuild
- Remove text editing for perlin seed and filter function
- Remove ServerWorld::rebuild_world() method and its atomic flag
- Move 'Rebuild World' button to client world tab
- Remove unused perlin_noise_input_buffer
* fix(server_world): floor block position coordinates in handle_block_change
* refactor(gameplay): pass new_chunks vector as parameter instead of member variable
* perf(client): improve chunk rendering performance with snapshots and threaded generation
* feat(tools): add PriorityThreadPool with priority scheduling
Implement PriorityThreadPool supporting task priorities and FIFO ordering for same priority.
Update ClientWorld to use the new pool with explicit priority for chunk operations.
Fix ThreadPool stop logic with atomic exchange and remove unnecessary lambda capture.
* feat(networking): add priority and sequence ordering to packet send queues
* feat(server-world): use priority thread pool for chunk generation
Introduce PriorityThreadPool to process chunk generation tasks with priorities based on their distance from the player. Closer chunks receive higher priority, improving responsiveness.
* refactor(client): extract AABB creation and add collision check on block place
Make ClientPlayer::get_aabb and ClientWorld::get_block_aabb static.
Change player size to static constexpr M_SIZE.
Use shared_mutex for concurrent reads of other players.
Check for collision with other players before placing a block.
* feat(build): add build-time version system via CMake configure_file
* ci(release): add release build workflow for windows
* feat(gameplay): implement greedy meshing for chunk generation
Replace the per-face vertex generation with a greedy meshing algorithm that merges adjacent faces of the same block type into larger quads. Introduce `FaceKey` struct and helper functions (`axis_dir_to_face`, `get_block_safe`, `is_face_culled`, `choose_buf`) to support the new algorithm. Comment out the old `gen_vertices` implementation.
In texture management, rename `m_pbr_texture_array` to `m_normal_texture_array` to reflect its actual usage, and set texture wrap mode to `GL_REPEAT` for both the block and normal texture arrays.
* fix(primitive_data): correct back face texture coordinates and tangents
* fix(texture-manager): correct texture deletion and refactor reload
Make hot_reload private and add public need_reload method. Update UI to call need_reload instead of hot_reload. Fix incorrect use of glDeleteBuffers for normal texture array by using glDeleteTextures.
* feat: add grass texture and update grass_block texture
* feat: add block data
* feat: add blocks_tool
* feat: add sync info and change function in blocks_tools
* feat: add check and new function
* refactor: make block texture loading data-driven
* feat: add rendering for grass
* feat: passable grass
* feat: random grass place
* fix: memory leak in TextureManager::load_cross_plane_texture
