The GetBlock() call has specific offsets that are angle and axis dependent to get the correct
square on the grid from the coordinates of a hit.
This is something that I forgot when introducing the RaycastResult struct, and just used
the first GetBlock() as a common call, returning wrong types in some cases.
As with the hit coordinates, save the type of block hit and use that depending on
the closest hit later, rather than a common and wrong GetBlock().
Use CMake FetchContent to pull tracy sources and build it if frame tracing is enabled.
As frame tracing requires annotations in the code, create a wrapper that replaces them
with our own defines that are empty when tracing is not enabled.
In order to implement more complexe behaviors, more information than the distance
is needed from a raycast.
Add a new struct to store and return this information, currently hit position
and hit type, and update castRay to return that instead.
Rays are all sent from the center of the camera plane, which makes rays
with a greater angle longer than if they were properly sent perpendicularly
from the camera plane.
Correct this by projecting the ray to the look direction (which is
perpendicular to the camera plane).
sf::RectangleShapes were created brand new each frame, which takes a lot of time.
Instead, keep an array of them available and update them instead of creating new ones.
This also allows a nice optimization of only updating them if needed, by checking their
previous value.
Update the available number of rects when the window resizes.
Use memmove to shift the whole array by one measure to the left,
dropping the oldest one and adding a new one at the head.
This creates a better visual effect of a graph being produced on the right
and scrolling to the left, rather than a looping writing head that overwrites
previous data.
Clear up the computation and split the result from the ray cast to the scale
factor.
Update the castRay explanations to add the issue of unmatched axes.
SFML and Dear ImGui have incompatible color types, abstract them through
a new Color class which has conversions.
Centralize color constants in a namespace as well.
Introduce Dear ImGui to the CMakeBuild, allow building without it.
Add two debug interfaces : one FPS counter and frame time graph,
one map visualizer and editor.
Previously CastRay did the scale computation and used the player view statistics.
This makes it quite specialized, and the rest of the computations are made outside.
Move the computations in the render function and make castRay generic.
World has a lot of type conversion warnings. Take care of most of them,
for a slight performance hit ( :( ).
Re-order constructor parameters to match declaration.
Move FillColumn to a more appropriate place.
GetBlock gets called a lot : use direct memory access of the vector
rather than going through bounds checks with .at().
Introduce an integer overload to remove warnings.
Handle window resizes by resizing the view frame as well.
Clean up the event handling to allow interleaving other code between
different checks.
Remove early first frame, handle it like the others.
Player: Add rotation and linear speeds, as well as their current state.
Player: Allow to move in the local coordinates and compute
world-speed equivalent.
Player: Update movement axis while rotating.
World: Add a function to advance a step.
Main: Handle key events, add world step in the main loop.
Implement the basic raycaster, checking every block intersection and the block
linked to that position.
Split the screen uniformally along the width.
Add data needed for camera maths in the Player class
Specify constraints on the raycast parameters.
Render the screen using the raycasts.
Call the renderer in the main loop.
Rotation wasn't handled properly at all.
Properly bound between 0 and 360, and use
a proper modulo for floats.
Switch to float to have a more fluid rotation
between frames.
