@devlsx

This morning, I focused on the combat subsystem, implementing new mechanics that enhance player interactions and feedback during combat. These changes are pivotal for establishing a robust gameplay foundation.

combat_resist: Implemented a resistance mechanic that determines damage mitigation based on player attributes, allowing for more nuanced combat outcomes.combat_rng: Added a random number generator for damage calculations, introducing variability in combat results to enhance unpredictability and player engagement.combat_knockback: Developed a knockback effect that alters player position upon receiving damage, improving the physicality of combat interactions.combat_log_death_message: Implemented logging functionality to display a message when a player character dies, providing clear feedback for the player on their status.stub out combat_log: Created a basic structure for the combat log system, laying the groundwork for future enhancements in tracking combat events and player actions.
Current progress has established essential combat mechanics. The next step will involve integrating these systems into the overall game loop for testing and refinement.

Today, I focused on the combat subsystem, specifically implementing various components necessary for managing health, damage, and character behaviors during combat scenarios. This work is critical for establishing a solid foundation for player interactions and enemy behaviors.

Combat System: Implemented combat_health, which tracks and manages health points for entities, including health reduction mechanics and thresholds for death events.Combat System: Added combat_invuln, providing temporary invulnerability states for characters, which allows for the management of damage immunity during specific animations or effects.Combat System: Developed combat_knockback, a mechanic that applies force to characters upon receiving damage, enhancing the feedback of combat interactions.Behavior Tree: Stubbed out the combat_combo, which will facilitate chaining of attacks for characters, setting up a framework for more advanced combat mechanics.Behavior Management: Completed behavior_tree_free to ensure proper memory management of behavior trees, preventing memory leaks during runtime.Behavior Management: Initiated behavior_runner_init, which sets up the initial state for behavior execution, crucial for managing different character actions effectively.Combat System: Implemented combat_dmg_info_get, which retrieves damage information relevant for interaction logic, aiding in the clarity of combat events.Cleanup: Conducted code tidying and minor fixes across the combat module to enhance readability and maintainability.
The combat subsystem now has a more cohesive structure with the groundwork laid for complex interactions. The next step will involve fleshing out the behavior tree logic to integrate advanced AI behaviors and attack combos.

registry is DONE and it’s a chunky one.
45 species total including a few legendaries hiding at the bottom of the rarity tablegave the legendaries proper standout glyphs and brutal difficulty so they feel like eventsstarted the bait registry, 6 baits so far, each shifting bite odds and which species show interestsanity-checked the whole list for dead entries one more time.45 fish feels like the right amount, enough to fill a journal without me writing content until winter. good night’s work.

Today, I focused on the animation subsystem of the voxl engine, specifically enhancing the animation systems to support skeletal animation and procedural walking behaviors. This work is crucial for implementing character animations that are both dynamic and responsive to gameplay inputs.

behavior_leaf: Implemented the behavior_leaf module, establishing a base for behavior trees that allows for more complex AI decision-making processes.behavior_builder: Developed the behavior_builder to construct behavior trees programmatically, centralizing the creation and management of AI behaviors.behavior_act_target_in_reach: Completed the implementation of the behavior_act_target_in_reach, which checks proximity to targets for AI actions, enhancing interaction capabilities.anim_skeleton: Began scaffolding the anim_skeleton module, which will define the structure and hierarchy of skeletal animations, essential for character rigging.anim_rig: Set up the anim_rig, providing the framework for binding animations to skeletal structures, facilitating smooth character movement.animation_procedural_walk: Expanded the animation_procedural_walk to allow for dynamic adjustments based on character speed and terrain, improving realism in character locomotion.anim_controller: Introduced the anim_controller to manage the state and transitions of animations, allowing for layered animation blending and more responsive character behaviors.entity_render: Implemented entity_render functionality, which integrates the rendering of animated entities into the broader scene graph, ensuring visual coherence.
The current state of the animation system is foundational but progressing well, with core modules in place for skeletal animation. The next steps will involve refining the blending of animations and integrating more complex animation states.

kept feeding the registry and wired up the lookup side.
more species in, edging toward the deeper and rarer end nowadded the fish lookup so systems can query by id or by what’s currently biteableintroduced the Catch type, a caught fish plus its rolled size and the conditions it was landed inCatch is what the journal and shop will eventually pass aroundgetting close to a full roster. once lookup and Catch are solid the actual fishing can start pulling from real data.

Today, I focused on implementing the initial stages of the animation and AI subsystems, as well as enhancements to the water rendering pipeline. These components are critical for enhancing the game’s dynamic interactions and visual fidelity.

Animation System: Implemented foundational structures for anim_blend. This allows for smooth transitions between different animations, improving character movement fluidity.Entity System: Completed the entity module, enabling proper management of game objects, including their lifecycle and state management, which is essential for gameplay.AI Module: Introduced the pathfind function, allowing entities to navigate the game world effectively. This is a crucial step towards integrating more complex AI behaviors.Water Rendering: Established the water_pass, implementing the water rendering pipeline. This includes setting up reflection and refraction capabilities using a dedicated reflection camera (water_reflcam), enhancing visual realism.Water Effects: Started work on water_wave and water_foam, which will simulate surface interactions and enhance the dynamic appearance of water bodies.AI Updates: Added ai_tick, which will manage updates to AI behaviors each frame, ensuring responsive and engaging NPC interactions.
Current progress includes foundational setups for both animation and AI systems, alongside initial water rendering capabilities. The next logical step involves refining the AI behaviors and continuing the development of the water effects to enhance environmental interactions.

more fish. head down, tables growing.
another batch of species across the seasons, some spring spawners and a couple summer night biterstuned size ranges so the same species varies believably, a small bass vs a hefty onedouble checked every entry lists at least one valid water and time or it’d never be catchableno new systems, purely contentjust filling the registry out. it’s oddly relaxing writing little fish biographies after work.

Today, I focused on implementing various aspects of the volumetric rendering subsystem. This work is critical for enhancing the visual fidelity of the water rendering and introducing new volumetric effects, which are essential for achieving realistic environmental interactions in the engine.

water_reflect: Implemented reflective properties for water surfaces, enhancing the realism of water rendering by calculating reflection vectors based on the viewer’s position and the surface normals.volumetric_programs_use_march: Wired up the volumetric rendering programs to utilize a raymarching approach for rendering volumetric effects, allowing for more complex light interactions within volumes.vol_raymarch: Began development of the raymarching algorithm for volumetric rendering, laying the groundwork for subsequent implementations of effects such as fog and smoke.volumetric_pass_run: Implemented the core function to execute volumetric passes, establishing a pipeline for rendering volumetric effects sequentially within the main render loop.vol_caustics: Initiated the caustics rendering system, which will simulate light patterns created by surface reflections on the volumetric medium, enhancing the visual complexity of water interactions.vol_pass: Scaffolded the volumetric pass structure, defining how different volumetric effects will be processed in the render pipeline.vol_medium: Created an initial implementation of volumetric mediums, allowing the engine to define properties such as density and scattering for various materials.
The volumetric rendering subsystem is now more robust and modular, with foundational components in place. The next step is to continue refining the raymarching implementation and integrate the caustics calculations within the rendering pipeline.

the fun part begins. defining what actually lives in the water.
laid out the fish registry, each species carries name, glyph, valid seasons, waters, times of day, rarity, size range, difficulty, sell price and a bait preferencegot the first handful of common species written, your bluegill and perch tierrarity and difficulty are separate on purpose, a fish can be common but a pain to reeleverything is plain data, no serde, just const-ish tablesthis is the content grind i’ve been looking forward to. going to be a lot of nights of just adding fish.

Today, I focused on the development of the tonemapping subsystem, which is essential for controlling the luminance and color mapping of rendered scenes to enhance visual fidelity. This work is crucial as it directly affects the output quality of rendered images.

volumetric_blur: Scaffolded the vol_blur module to introduce volumetric blur processing. This lays the groundwork for further development of blur algorithms.tonemap: Established the initial framework for tonemapping, including scaffolded modules for tonemap_params, tonemap_grade, and tonemap_curve. This modular approach allows for easy future enhancements and testing.tonemap_selftest: Wired up self-testing capabilities for tonemapping to ensure that changes can be effectively validated. This includes fleshing out the self-test to cover edge cases and expected behavior.tonemap_lut: Implemented a lookup table (LUT) for tonemapping, which will optimize color grading processes. Set up associated functions to support LUT creation and application.tonemap_exposure: Started the implementation of exposure management in tonemapping, including functions to retrieve and adjust exposure levels dynamically.text_layout: Completed the implementation of the text layout system, which will be utilized for rendering debug information and UI elements related to tonemapping.cleanup: Conducted code cleanup across several modules, focusing on reducing technical debt and improving readability.
The current state of the tonemapping subsystem is foundational, with several key components scaffolded and initial implementations underway. The next logical step involves further developing the tonemapping algorithms and integrating them into the rendering pipeline to evaluate their impact on scene output.

This morning’s work focused on the tonemapping subsystem, particularly enhancing exposure control and initializing the necessary data structures. These changes are critical for achieving realistic rendering through proper dynamic range management.

Tonemap Exposure: Implemented tonemap_exposure to calculate exposure values based on scene luminance, improving how bright areas are rendered.Tonemap Configuration: Added tonemap_config, defining parameters for exposure and curve settings, facilitating easy adjustments and future expansion.Tonemap Curve: Began the implementation of tonemap_curve, establishing a basis for non-linear mapping of color values to enhance dynamic range perception.Text Layout: Completed the text_layout function, which manages text rendering for UI elements, ensuring proper alignment and spacing.Tonemap Debugging: Implemented tonemap_debug_run_split to allow testing of various tonemapping scenarios, aiding in fine-tuning the visual output.
Current progress sets a solid foundation for further work on the tonemapping pipeline, with the next steps aimed at refining the tonemap grading process and integrating it into the rendering loop.

weather came alive tonight and it already changes how the game feels.
7 weather types in: clear, cloudy, rain, storm, fog, snow, windyeach one nudges fishing, rain perks up bites, storms open the door for rare stuff, fog is moody and slowweather picks per day weighted by season, no snow in summer thankfullystarted the fish registry, the big onerain making the lake livelier is exactly the kind of small texture i wanted. onto the actual fish.

Today, I focused on the text rendering subsystem, specifically the development of the text context and text batch systems. This work is foundational for rendering 2D text efficiently, which is crucial for UI elements and in-game text displays.

text_ctx: Implemented the initial structure for the text context, which manages the state related to text rendering. This includes setting up memory allocations for text data and glyph information.text_batch: Created a scaffold for the text batch system to handle multiple text draw calls efficiently. This will allow for batching of text rendering operations to minimize state changes.text_atlas: Developed the initial setup for the text atlas, which will store glyph images for rapid access during rendering. This will improve performance by reducing texture binding overhead.text_font: Initialized the text font subsystem to load and manage font data. This includes parsing font files and generating the necessary glyph data.text_glyphdata: Started the implementation of glyph data handling, allowing for precise control over individual characters and their metrics.ssr_settings and ssr_pass: Set up the screen space reflections (SSR) settings and pass, which will enhance the visual fidelity of reflective surfaces in the engine.ssrx_material_unpack: Completed the unpacking of material data for SSR, ensuring that material properties are correctly interpreted during rendering.
The text rendering subsystem is now well-structured, and the next step will involve integrating the text rendering into the main rendering pipeline to ensure text is displayed correctly in the game environment.

short session but still good progress
calendar is done: 4 seasons of 28 days each, so a clean 112-day yearday rolls into season rolls into year, all wrapping correctlywrote a couple tests for the boundary days because off-by-one on day 28 would haunt mestarted stubbing the weather systemnot much to show, just the machinery that makes tomorrow actually be tomorrow.

Today I worked on the implementation of screen space reflections (SSR) and screen space ambient occlusion (SSAO) within the rendering subsystem. These features are vital for enhancing visual fidelity and realism in lighting interactions within the voxel environment.

SSR Module: Introduced the ssr_fsquad, which sets up a full-screen quad for executing the SSR shader pass. This establishes a foundation for reflection calculations.SSR Configuration: Created ssr_config scaffolding to manage SSR parameters, allowing for adjustable settings such as reflection intensity and roughness.SSR Depth Setup: Implemented the ssr_depth, which captures depth information necessary for accurate reflection rendering. This enables proper occlusion of reflections based on scene depth.SSR Debugging: Set up ssr_debug to visualize reflection calculations during development, aiding in the identification of rendering artifacts or inaccuracies.SSAO Configuration: Initialized ssao_settings to provide user-adjustable controls over ambient occlusion effects, including radius and intensity.SSAO Pass Setup: Established the ssao_pass, which integrates the SSAO calculations into the render pipeline, ensuring it runs alongside other post-processing effects.SSAO Sampling: Started working on ssao_sample, which defines the sampling strategy for ambient occlusion, leveraging a kernel to calculate occlusion values based on neighboring pixels.Kernel Statistics: Set up ssao_kernel_stats to track and debug the parameters of the SSAO kernel, which will assist in optimizing performance and quality.
The rendering subsystem now has a foundational implementation for both SSR and SSAO, with key components in place. The next steps will involve refining the sampling methods for SSAO and integrating the blurring effect for the final output to enhance visual quality.

time is a surprisingly fiddly thing to model. season module now has Season, TimeOfDay and WaterType, built the in-game clock, days run 6am to roughly 2am and advance in 10-minute tickspassing out or sleeping rolls it forward to the next morningstarted the calendar on top of itspent way too long deciding when “night” begins for fishing purposes. settled on it, moved on. WaterType is going to matter a lot once fish exist.

Today, I focused on enhancing the rendering subsystem with the implementation of Screen Space Ambient Occlusion (SSAO). This feature is critical for improving scene depth and realism by simulating how light interacts with surfaces.

SSAO Module: Implemented the foundational SSAO computation logic in ssao_compute, which calculates ambient occlusion based on depth and normal maps to enhance shading realism.SSAO Debugging: Developed ssao_debug to visualize SSAO outputs, allowing for quick verification of occlusion values and aiding in fine-tuning the algorithm.SSAO Blur: Completed the SSAO blur process in ssao_blur, which smooths the occlusion map to reduce artifacts and achieve a more visually appealing result. The blur uses a separable Gaussian filter for performance efficiency.Skybox Renderer: Progressed on the skybox rendering system by fleshing out skyb_renderer_upload_dome and skyb_dome_vertex, which define the dome geometry and texture uploads for the skybox, ensuring proper visual integration with the ambient occlusion effects.Skybox Palette and Gradient: Initiated the scaffolding for skyb_palette and set up skyb_gradient, enabling gradient-based skybox coloring to enhance atmospheric effects in conjunction with SSAO.
The SSAO implementation is now functional, with debug features in place to assess its performance and visual fidelity. The next step will involve further optimizing the SSAO calculations and integrating them seamlessly into the main rendering pipeline.

good chunk of the skeleton went in tonight.
finished tile, every variant has its glyph and walkability nowmap is a 2D grid with bounds checks and a walkable() querysketched the player struct: position, facing, energy, gold, equipped rod and baitbegan the season enumsstill can’t do anything but it’s starting to have shape. the player just sits at a Point staring into the void, which is honestly relatable.

Today I focused on the lighting subsystem, specifically implementing shadow mapping techniques and enhancing the atmospheric rendering system. These improvements are crucial for achieving realistic lighting and depth effects in the voxel environment.

shadow_map: Implemented the shadow mapping algorithm, which includes creating a depth texture to store the distance from the light source to the nearest surface, enabling more realistic shadows.shadow_pcf: Developed percentage-closer filtering (PCF) for shadows to soften the edges of the shadow map, increasing visual fidelity. This involved setting up the filtering process within the shader pipeline.shadow_split: Introduced the shadow split technique to improve shadow rendering across varying depths. This includes calculating split distances based on the camera’s frustum to reduce artifacts.shadow_matrix: Added a shadow matrix computation to transform world coordinates into shadow map space, ensuring correct shadow projection during rendering.skyb: Began implementing the skybox atmospheric effects, specifically the skyb_atmosphere_clear_color and skyb_billboard. This includes color adjustments for clearer skies and setting up billboards for celestial bodies.shadow_stabilize: Stubbed out a shadow stabilization technique to reduce flickering and aliasing in shadow rendering, which will be fleshed out in future commits.code maintenance: Conducted minor cleanups and cosmetic tweaks across multiple files for better readability and organization, including renaming functions for clarity.
The current state of the shadow rendering system is functional with basic shadow mapping and initial atmospheric effects implemented. The next step will be to refine the shadow stabilization method and continue developing the full atmospheric rendering features.

first real evening of code. mostly laying pipe under the floor.
added a .gitignore so target/ stops following me aroundwrote geom with Point, Dir and Rect helpers, the small stuff everything else leans onrolled my own rng, a seeded splitmix64. std only, no getrandom, i want catches to be reproducible from a seedstarted the tile module, the enum and per-tile glyphsno graphics, no game, just the vocabulary the rest of the code will speak in. slow but satisfying.