learn-code-the-hard-way
/
raycaster
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 1 Wiki Activity

Converted all the variable names from Lode's tutorial style to the one I use in prep for some review and cleanup.

Browse Source
master
Zed A. Shaw 4 weeks ago
parent 0cbe20af35
commit 51972b0c35
6 changed files with 157 additions and 156 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 38
      camera.cpp
  2. 16
      camera.hpp
  3. 6
      gui.cpp
  4. 1
      meson.build
  5. 238
      raycaster.cpp
  6. 14
      raycaster.hpp

38
camera.cpp
Unescape View File

@ -5,45 +5,45 @@
Point CameraLOL::plan_move(Raycaster &rayview, int dir, bool strafe) { Point CameraLOL::plan_move(Raycaster &rayview, int dir, bool strafe) {
t = 0.0; t = 0.0;
if(strafe) { if(strafe) {
targetX = rayview.$posX + int(-rayview.$dirY * 1.5 * dir); target_x = rayview.$pos_x + int(-rayview.$dir_y * 1.5 * dir);
targetY = rayview.$posY + int(rayview.$dirX * 1.5 * dir); target_y = rayview.$pos_y + int(rayview.$dir_x * 1.5 * dir);
} else { } else {
targetX = rayview.$posX + int(rayview.$dirX * 1.5 * dir); target_x = rayview.$pos_x + int(rayview.$dir_x * 1.5 * dir);
targetY = rayview.$posY + int(rayview.$dirY * 1.5 * dir); target_y = rayview.$pos_y + int(rayview.$dir_y * 1.5 * dir);
} }
return {size_t(targetX), size_t(targetY)}; return {size_t(target_x), size_t(target_y)};
} }
void CameraLOL::plan_rotate(Raycaster &rayview, int dir) { void CameraLOL::plan_rotate(Raycaster &rayview, int dir) {
t = 0.0; t = 0.0;
double angle_dir = std::numbers::pi * 0.25 * dir; double angle_dir = std::numbers::pi * 0.25 * dir;
targetDirX = rayview.$dirX * cos(angle_dir) - rayview.$dirY * sin(angle_dir); target_dir_x = rayview.$dir_x * cos(angle_dir) - rayview.$dir_y * sin(angle_dir);
targetDirY = rayview.$dirX * sin(angle_dir) + rayview.$dirY * cos(angle_dir); target_dir_y = rayview.$dir_x * sin(angle_dir) + rayview.$dir_y * cos(angle_dir);
targetPlaneX = rayview.$planeX * cos(angle_dir) - rayview.$planeY * sin(angle_dir); target_plane_x = rayview.$plane_x * cos(angle_dir) - rayview.$plane_y * sin(angle_dir);
targetPlaneY = rayview.$planeX * sin(angle_dir) + rayview.$planeY * cos(angle_dir); target_plane_y = rayview.$plane_x * sin(angle_dir) + rayview.$plane_y * cos(angle_dir);
} }
bool CameraLOL::play_rotate(Raycaster &rayview) { bool CameraLOL::play_rotate(Raycaster &rayview) {
t += rotSpeed; t += rot_speed;
rayview.$dirX = std::lerp(rayview.$dirX, targetDirX, t); rayview.$dir_x = std::lerp(rayview.$dir_x, target_dir_x, t);
rayview.$dirY = std::lerp(rayview.$dirY, targetDirY, t); rayview.$dir_y = std::lerp(rayview.$dir_y, target_dir_y, t);
rayview.$planeX = std::lerp(rayview.$planeX, targetPlaneX, t); rayview.$plane_x = std::lerp(rayview.$plane_x, target_plane_x, t);
rayview.$planeY = std::lerp(rayview.$planeY, targetPlaneY, t); rayview.$plane_y = std::lerp(rayview.$plane_y, target_plane_y, t);
return t > 1.0; return t > 1.0;
} }
bool CameraLOL::play_move(Raycaster &rayview) { bool CameraLOL::play_move(Raycaster &rayview) {
t += moveSpeed; t += move_speed;
rayview.$posX = std::lerp(rayview.$posX, targetX, t); rayview.$pos_x = std::lerp(rayview.$pos_x, target_x, t);
rayview.$posY = std::lerp(rayview.$posY, targetY, t); rayview.$pos_y = std::lerp(rayview.$pos_y, target_y, t);
return t >= 1.0; return t >= 1.0;
} }
void CameraLOL::abort_plan(Raycaster &rayview) { void CameraLOL::abort_plan(Raycaster &rayview) {
targetX = rayview.$posX; target_x = rayview.$pos_x;
targetY = rayview.$posY; target_y = rayview.$pos_y;
} }

16
camera.hpp
Unescape View File

@ -3,14 +3,14 @@
struct CameraLOL { struct CameraLOL {
double t = 0.0; double t = 0.0;
double moveSpeed = 0.1; double move_speed = 0.1;
double rotSpeed = 0.06; double rot_speed = 0.06;
double targetX = 0.0; double target_x = 0.0;
double targetY = 0.0; double target_y = 0.0;
double targetDirX = 0.0; double target_dir_x = 0.0;
double targetDirY = 0.0; double target_dir_y = 0.0;
double targetPlaneX = 0.0; double target_plane_x = 0.0;
double targetPlaneY = 0.0; double target_plane_y = 0.0;
Point plan_move(Raycaster &rayview, int dir, bool strafe); Point plan_move(Raycaster &rayview, int dir, bool strafe);
void plan_rotate(Raycaster &rayview, int dir); void plan_rotate(Raycaster &rayview, int dir);

6
gui.cpp
Unescape View File

@ -135,7 +135,7 @@ namespace gui {
void FSM::MOVING(Event ) { void FSM::MOVING(Event ) {
if($camera.play_move($rayview)) { if($camera.play_move($rayview)) {
System::plan_motion(*$level.world, {size_t($camera.targetX), size_t($camera.targetY)}); System::plan_motion(*$level.world, {size_t($camera.target_x), size_t($camera.target_y)});
run_systems(); run_systems();
state(State::IDLE); state(State::IDLE);
} }
@ -272,8 +272,8 @@ namespace gui {
"pos: {:>2.02},{:>2.02}\n\n", "pos: {:>2.02},{:>2.02}\n\n",
$stats.mean(), $stats.stddev(), $stats.min, $stats.mean(), $stats.stddev(), $stats.min,
$stats.max, $stats.n, VSYNC, $stats.max, $stats.n, VSYNC,
FRAME_LIMIT, DEBUG_BUILD, $rayview.$dirX, FRAME_LIMIT, DEBUG_BUILD, $rayview.$dir_x,
$rayview.$dirY, $rayview.$posX, $rayview.$posY)); $rayview.$dir_y, $rayview.$pos_x, $rayview.$pos_y));
$window.draw($text); $window.draw($text);
} }

1
meson.build
Unescape View File

@ -90,6 +90,7 @@ executable('runtests', sources + [
], override_options: exe_defaults, ], override_options: exe_defaults,
dependencies: dependencies + [catch2]) dependencies: dependencies + [catch2])
executable('zedcaster', executable('zedcaster',
sources + [ 'main.cpp' ], sources + [ 'main.cpp' ],
cpp_args: cpp_args, cpp_args: cpp_args,

238
raycaster.cpp
Unescape View File

@ -38,7 +38,7 @@ Raycaster::Raycaster(TexturePack &textures, int width, int height) :
$view_texture({(unsigned int)width, (unsigned int)height}), $view_texture({(unsigned int)width, (unsigned int)height}),
$view_sprite($view_texture), $view_sprite($view_texture),
$width(width), $height(height), $width(width), $height(height),
ZBuffer(width), $zbuffer(width),
$anim(256, 256, 10, "assets/monster-1.ogg") $anim(256, 256, 10, "assets/monster-1.ogg")
{ {
$view_sprite.setPosition({0, 0}); $view_sprite.setPosition({0, 0});
@ -52,8 +52,8 @@ void Raycaster::set_position(int x, int y) {
void Raycaster::position_camera(float player_x, float player_y) { void Raycaster::position_camera(float player_x, float player_y) {
// x and y start position // x and y start position
$posX = player_x; $pos_x = player_x;
$posY = player_y; $pos_y = player_y;
} }
void Raycaster::draw_pixel_buffer() { void Raycaster::draw_pixel_buffer() {
@ -61,12 +61,12 @@ void Raycaster::draw_pixel_buffer() {
} }
void Raycaster::sprite_casting(sf::RenderTarget &target) { void Raycaster::sprite_casting(sf::RenderTarget &target) {
const int textureWidth = TEXTURE_WIDTH; constexpr const int texture_width = TEXTURE_WIDTH;
const int textureHeight = TEXTURE_HEIGHT; constexpr const int texture_height = TEXTURE_HEIGHT;
const int halfHeight = TEXTURE_HEIGHT / 2; constexpr const int half_height = TEXTURE_HEIGHT / 2;
// sort sprites from far to close // sort sprites from far to close
auto sprite_order = $level.collision->distance_sorted({(size_t)$posX, (size_t)$posY}); auto sprite_order = $level.collision->distance_sorted({(size_t)$pos_x, (size_t)$pos_y});
// after sorting the sprites, do the projection // after sorting the sprites, do the projection
for(auto& rec : sprite_order) { for(auto& rec : sprite_order) {
@ -75,67 +75,67 @@ void Raycaster::sprite_casting(sf::RenderTarget &target) {
auto& sf_sprite = $sprites.at(rec.second).sprite; auto& sf_sprite = $sprites.at(rec.second).sprite;
auto sprite_pos = $level.world->get<components::Position>(rec.second); auto sprite_pos = $level.world->get<components::Position>(rec.second);
double spriteX = double(sprite_pos.location.x) - $posX + 0.5; double sprite_x = double(sprite_pos.location.x) - $pos_x + 0.5;
double spriteY = double(sprite_pos.location.y) - $posY + 0.5; double sprite_y = double(sprite_pos.location.y) - $pos_y + 0.5;
//transform sprite with the inverse camera matrix //transform sprite with the inverse camera matrix
// [ $planeX $dirX ] -1 [ $dirY -$dirX ] // [ $plane_x $dir_x ] -1 [ $dir_y -$dir_x ]
// [ ] = 1/($planeX*$dirY-$dirX*$planeY) * [ ] // [ ] = 1/($plane_x*$dir_y-$dir_x*$plane_y) * [ ]
// [ $planeY $dirY ] [ -$planeY $planeX ] // [ $plane_y $dir_y ] [ -$plane_y $plane_x ]
double invDet = 1.0 / ($planeX * $dirY - $dirX * $planeY); // required for correct matrix multiplication double inv_det = 1.0 / ($plane_x * $dir_y - $dir_x * $plane_y); // required for correct matrix multiplication
double transformX = invDet * ($dirY * spriteX - $dirX * spriteY); double transform_x = inv_det * ($dir_y * sprite_x - $dir_x * sprite_y);
//this is actually the depth inside the screen, that what Z is in 3D, the distance of sprite to player, matching sqrt(spriteDistance[i]) //this is actually the depth inside the screen, that what Z is in 3D, the distance of sprite to player, matching sqrt(spriteDistance[i])
double transformY = invDet * (-$planeY * spriteX + $planeX * spriteY); double transform_y = inv_det * (-$plane_y * sprite_x + $plane_x * sprite_y);
int spriteScreenX = int(($width / 2) * (1 + transformX / transformY)); int sprite_screen_x = int(($width / 2) * (1 + transform_x / transform_y));
// calculate the height of the sprite on screen // calculate the height of the sprite on screen
//using "transformY" instead of the real distance prevents fisheye //using "transform_y" instead of the real distance prevents fisheye
int spriteHeight = abs(int($height / transformY)); int sprite_height = abs(int($height / transform_y));
// calculate width the the sprite // calculate width the the sprite
// same as height of sprite, given that it's square // same as height of sprite, given that it's square
int spriteWidth = abs(int($height / transformY)); int sprite_width = abs(int($height / transform_y));
int drawStartX = -spriteWidth / 2 + spriteScreenX; int draw_start_x = -sprite_width / 2 + sprite_screen_x;
if(drawStartX < 0) drawStartX = 0; if(draw_start_x < 0) draw_start_x = 0;
int drawEndX = spriteWidth / 2 + spriteScreenX; int draw_end_x = sprite_width / 2 + sprite_screen_x;
if(drawEndX > $width) drawEndX = $width; if(draw_end_x > $width) draw_end_x = $width;
int stripe = drawStartX; int stripe = draw_start_x;
for(; stripe < drawEndX; stripe++) { for(; stripe < draw_end_x; stripe++) {
//the conditions in the if are: //the conditions in the if are:
//1) it's in front of camera plane so you don't see things behind you //1) it's in front of camera plane so you don't see things behind you
//2) ZBuffer, with perpendicular distance //2) $zbuffer, with perpendicular distance
if(!(transformY > 0 && transformY < ZBuffer[stripe])) break; if(!(transform_y > 0 && transform_y < $zbuffer[stripe])) break;
} }
int texX_end = int(textureWidth * (stripe - (-spriteWidth / 2 + spriteScreenX)) * textureWidth / spriteWidth) / textureWidth; int tex_x_end = int(texture_width * (stripe - (-sprite_width / 2 + sprite_screen_x)) * texture_width / sprite_width) / texture_width;
if(drawStartX < drawEndX && transformY > 0 && transformY < ZBuffer[drawStartX]) { if(draw_start_x < draw_end_x && transform_y > 0 && transform_y < $zbuffer[draw_start_x]) {
//calculate lowest and highest pixel to fill in current stripe //calculate lowest and highest pixel to fill in current stripe
int drawStartY = -spriteHeight / 2 + $height / 2; int draw_start_y = -sprite_height / 2 + $height / 2;
if(drawStartY < 0) drawStartY = 0; if(draw_start_y < 0) draw_start_y = 0;
int drawEndY = spriteHeight / 2 + $height / 2; int draw_end_y = sprite_height / 2 + $height / 2;
if(drawEndY >= $height) drawEndY = $height - 1; if(draw_end_y >= $height) draw_end_y = $height - 1;
int texX = int(textureWidth * (drawStartX - (-spriteWidth / 2 + spriteScreenX)) * textureWidth / spriteWidth) / textureWidth; int tex_x = int(texture_width * (draw_start_x - (-sprite_width / 2 + sprite_screen_x)) * texture_width / sprite_width) / texture_width;
int texRenderWidth = texX_end - texX; int tex_render_width = tex_x_end - tex_x;
if(texRenderWidth <= 0) continue; if(tex_render_width <= 0) continue;
float x = float(drawStartX + RAY_VIEW_X); float x = float(draw_start_x + RAY_VIEW_X);
float y = float(drawStartY + RAY_VIEW_Y); float y = float(draw_start_y + RAY_VIEW_Y);
float sprite_w = float(spriteWidth) / float(textureWidth); float sprite_w = float(sprite_width) / float(texture_width);
float sprite_h = float(spriteHeight) / float(textureHeight); float sprite_h = float(sprite_height) / float(texture_height);
int d = y * textureHeight - $height * halfHeight + spriteHeight * halfHeight; int d = y * texture_height - $height * half_height + sprite_height * half_height;
int texY = ((d * textureHeight) / spriteHeight) / textureHeight; int tex_y = ((d * texture_height) / sprite_height) / texture_height;
sf_sprite->setScale({sprite_w, sprite_h}); sf_sprite->setScale({sprite_w, sprite_h});
$anim.step(*sf_sprite, texX, texY, texRenderWidth, textureHeight); $anim.step(*sf_sprite, tex_x, tex_y, tex_render_width, texture_height);
sf_sprite->setPosition({x, y}); sf_sprite->setPosition({x, y});
$brightness.setUniform("offsetFactor", sf::Glsl::Vec2{0.0f, 0.0f}); $brightness.setUniform("offsetFactor", sf::Glsl::Vec2{0.0f, 0.0f});
@ -148,125 +148,125 @@ void Raycaster::sprite_casting(sf::RenderTarget &target) {
} }
void Raycaster::cast_rays() { void Raycaster::cast_rays() {
constexpr static const int textureWidth = TEXTURE_WIDTH; constexpr static const int texture_width = TEXTURE_WIDTH;
constexpr static const int textureHeight = TEXTURE_HEIGHT; constexpr static const int texture_height = TEXTURE_HEIGHT;
double perpWallDist; double perp_wall_dist;
// WALL CASTING // WALL CASTING
for(int x = 0; x < $width; x++) { for(int x = 0; x < $width; x++) {
// calculate ray position and direction // calculate ray position and direction
double cameraX = 2 * x / double($width) - 1; // x-coord in camera space double cameraX = 2 * x / double($width) - 1; // x-coord in camera space
double rayDirX = $dirX + $planeX * cameraX; double ray_dir_x = $dir_x + $plane_x * cameraX;
double rayDirY = $dirY + $planeY * cameraX; double ray_dir_y = $dir_y + $plane_y * cameraX;
// which box of the map we're in // which box of the map we're in
int mapX = int($posX); int map_x = int($pos_x);
int mapY = int($posY); int map_y = int($pos_y);
// length of ray from current pos to next x or y-side // length of ray from current pos to next x or y-side
double sideDistX; double side_dist_x;
double sideDistY; double side_dist_y;
// length of ray from one x or y-side to next x or y-side // length of ray from one x or y-side to next x or y-side
double deltaDistX = std::abs(1.0 / rayDirX); double delta_dist_x = std::abs(1.0 / ray_dir_x);
double deltaDistY = std::abs(1.0 / rayDirY); double delta_dist_y = std::abs(1.0 / ray_dir_y);
int stepX = 0; int step_x = 0;
int stepY = 0; int step_y = 0;
int hit = 0; int hit = 0;
int side = 0; int side = 0;
// calculate step and initial sideDist // calculate step and initial sideDist
if(rayDirX < 0) { if(ray_dir_x < 0) {
stepX = -1; step_x = -1;
sideDistX = ($posX - mapX) * deltaDistX; side_dist_x = ($pos_x - map_x) * delta_dist_x;
} else { } else {
stepX = 1; step_x = 1;
sideDistX = (mapX + 1.0 - $posX) * deltaDistX; side_dist_x = (map_x + 1.0 - $pos_x) * delta_dist_x;
} }
if(rayDirY < 0) { if(ray_dir_y < 0) {
stepY = -1; step_y = -1;
sideDistY = ($posY - mapY) * deltaDistY; side_dist_y = ($pos_y - map_y) * delta_dist_y;
} else { } else {
stepY = 1; step_y = 1;
sideDistY = (mapY + 1.0 - $posY) * deltaDistY; side_dist_y = (map_y + 1.0 - $pos_y) * delta_dist_y;
} }
// perform DDA // perform DDA
while(hit == 0) { while(hit == 0) {
if(sideDistX < sideDistY) { if(side_dist_x < side_dist_y) {
sideDistX += deltaDistX; side_dist_x += delta_dist_x;
mapX += stepX; map_x += step_x;
side = 0; side = 0;
} else { } else {
sideDistY += deltaDistY; side_dist_y += delta_dist_y;
mapY += stepY; map_y += step_y;
side = 1; side = 1;
} }
if($map[mapY][mapX] > 0) hit = 1; if($map[map_y][map_x] > 0) hit = 1;
} }
if(side == 0) { if(side == 0) {
perpWallDist = (sideDistX - deltaDistX); perp_wall_dist = (side_dist_x - delta_dist_x);
} else { } else {
perpWallDist = (sideDistY - deltaDistY); perp_wall_dist = (side_dist_y - delta_dist_y);
} }
int lineHeight = int($height / perpWallDist); int line_height = int($height / perp_wall_dist);
int drawStart = -lineHeight / 2 + $height / 2 + $pitch; int draw_start = -line_height / 2 + $height / 2 + $pitch;
if(drawStart < 0) drawStart = 0; if(draw_start < 0) draw_start = 0;
int drawEnd = lineHeight / 2 + $height / 2 + $pitch; int draw_end = line_height / 2 + $height / 2 + $pitch;
if(drawEnd >= $height) drawEnd = $height - 1; if(draw_end >= $height) draw_end = $height - 1;
auto texture = $textures.get_surface($map[mapY][mapX] - 1); auto texture = $textures.get_surface($map[map_y][map_x] - 1);
// calculate value of wallX // calculate value of wall_x
double wallX; // where exactly the wall was hit double wall_x; // where exactly the wall was hit
if(side == 0) { if(side == 0) {
wallX = $posY + perpWallDist * rayDirY; wall_x = $pos_y + perp_wall_dist * ray_dir_y;
} else { } else {
wallX = $posX + perpWallDist * rayDirX; wall_x = $pos_x + perp_wall_dist * ray_dir_x;
} }
wallX -= floor((wallX)); wall_x -= floor((wall_x));
// x coorindate on the texture // x coorindate on the texture
int texX = int(wallX * double(textureWidth)); int tex_x = int(wall_x * double(texture_width));
if(side == 0 && rayDirX > 0) texX = textureWidth - texX - 1; if(side == 0 && ray_dir_x > 0) tex_x = texture_width - tex_x - 1;
if(side == 1 && rayDirY < 0) texX = textureWidth - texX - 1; if(side == 1 && ray_dir_y < 0) tex_x = texture_width - tex_x - 1;
// LODE: an integer-only bresenham or DDA like algorithm could make the texture coordinate stepping faster // LODE: an integer-only bresenham or DDA like algorithm could make the texture coordinate stepping faster
// How much to increase the texture coordinate per screen pixel // How much to increase the texture coordinate per screen pixel
double step = 1.0 * textureHeight / lineHeight; double step = 1.0 * texture_height / line_height;
// Starting texture coordinate // Starting texture coordinate
double texPos = (drawStart - $pitch - $height / 2 + lineHeight / 2) * step; double tex_pos = (draw_start - $pitch - $height / 2 + line_height / 2) * step;
for(int y = drawStart; y < drawEnd; y++) { for(int y = draw_start; y < draw_end; y++) {
int texY = (int)texPos & (textureHeight - 1); int tex_y = (int)tex_pos & (texture_height - 1);
texPos += step; tex_pos += step;
RGBA pixel = texture[textureHeight * texY + texX]; RGBA pixel = texture[texture_height * tex_y + tex_x];
$pixels[pixcoord(x, y)] = dumb_lighting(pixel, perpWallDist); $pixels[pixcoord(x, y)] = dumb_lighting(pixel, perp_wall_dist);
} }
// SET THE ZBUFFER FOR THE SPRITE CASTING // SET THE ZBUFFER FOR THE SPRITE CASTING
ZBuffer[x] = perpWallDist; $zbuffer[x] = perp_wall_dist;
} }
} }
void Raycaster::draw_ceiling_floor() { void Raycaster::draw_ceiling_floor() {
constexpr static const int textureWidth = TEXTURE_WIDTH; constexpr static const int texture_width = TEXTURE_WIDTH;
constexpr static const int textureHeight = TEXTURE_HEIGHT; constexpr static const int texture_height = TEXTURE_HEIGHT;
for(int y = $height / 2 + 1; y < $height; ++y) { for(int y = $height / 2 + 1; y < $height; ++y) {
// rayDir for leftmost ray (x=0) and rightmost (x = w) // rayDir for leftmost ray (x=0) and rightmost (x = w)
float rayDirX0 = $dirX - $planeX; float ray_dir_x0 = $dir_x - $plane_x;
float rayDirY0 = $dirY - $planeY; float ray_dir_y0 = $dir_y - $plane_y;
float rayDirX1 = $dirX + $planeX; float ray_dir_x1 = $dir_x + $plane_x;
float rayDirY1 = $dirY + $planeY; float ray_dir_y1 = $dir_y + $plane_y;
// current y position compared to the horizon // current y position compared to the horizon
int p = y - $height / 2; int p = y - $height / 2;
@ -275,53 +275,53 @@ void Raycaster::draw_ceiling_floor() {
// 0.5 will the camera at the center horizon. For a // 0.5 will the camera at the center horizon. For a
// different value you need a separate loop for ceiling // different value you need a separate loop for ceiling
// and floor since they're no longer symmetrical. // and floor since they're no longer symmetrical.
float posZ = 0.5 * $height; float pos_z = 0.5 * $height;
// horizontal distance from the camera to the floor for the current row // horizontal distance from the camera to the floor for the current row
// 0.5 is the z position exactly in the middle between floor and ceiling // 0.5 is the z position exactly in the middle between floor and ceiling
// See NOTE in Lode's code for more. // See NOTE in Lode's code for more.
float rowDistance = posZ / p; float row_distance = pos_z / p;
// calculate the real world step vector we have to add for each x (parallel to camera plane) // calculate the real world step vector we have to add for each x (parallel to camera plane)
// adding step by step avoids multiplications with a wight in the inner loop // adding step by step avoids multiplications with a wight in the inner loop
float floorStepX = rowDistance * (rayDirX1 - rayDirX0) / $width; float floor_step_x = row_distance * (ray_dir_x1 - ray_dir_x0) / $width;
float floorStepY = rowDistance * (rayDirY1 - rayDirY0) / $width; float floor_step_y = row_distance * (ray_dir_y1 - ray_dir_y0) / $width;
// real world coordinates of the leftmost column. // real world coordinates of the leftmost column.
// This will be updated as we step to the right // This will be updated as we step to the right
float floorX = $posX + rowDistance * rayDirX0; float floor_x = $pos_x + row_distance * ray_dir_x0;
float floorY = $posY + rowDistance * rayDirY0; float floor_y = $pos_y + row_distance * ray_dir_y0;
auto floor_texture = (const uint32_t *)$textures.floor.getPixelsPtr(); auto floor_texture = (const uint32_t *)$textures.floor.getPixelsPtr();
auto ceiling_texture = (const uint32_t *)$textures.ceiling.getPixelsPtr(); auto ceiling_texture = (const uint32_t *)$textures.ceiling.getPixelsPtr();
for(int x = 0; x < $width; ++x) { for(int x = 0; x < $width; ++x) {
// the cell coord is simply taken from the int parts of // the cell coord is simply taken from the int parts of
// floorX and floorY. // floor_x and floor_y.
int cellX = int(floorX); int cell_x = int(floor_x);
int cellY = int(floorY); int cell_y = int(floor_y);
// get the texture coordinate from the fractional part // get the texture coordinate from the fractional part
int tx = int(textureWidth * (floorX - cellX)) & (textureWidth - 1); int tx = int(texture_width * (floor_x - cell_x)) & (texture_width - 1);
int ty = int(textureWidth * (floorY - cellY)) & (textureHeight - 1); int ty = int(texture_width * (floor_y - cell_y)) & (texture_height - 1);
floorX += floorStepX; floor_x += floor_step_x;
floorY += floorStepY; floor_y += floor_step_y;
double d = std::sqrt(($posX - floorX) * ($posX - floorX) + ($posY - floorY) * ($posY - floorY)); double d = std::sqrt(($pos_x - floor_x) * ($pos_x - floor_x) + ($pos_y - floor_y) * ($pos_y - floor_y));
// now get the pixel from the texture // now get the pixel from the texture
uint32_t color; uint32_t color;
// this uses the previous ty/tx fractional parts of // this uses the previous ty/tx fractional parts of
// floorX cellX to find the texture x/y. How? // floor_x cell_x to find the texture x/y. How?
// FLOOR // FLOOR
color = floor_texture[textureWidth * ty + tx]; color = floor_texture[texture_width * ty + tx];
$pixels[pixcoord(x, y)] = dumb_lighting(color, d); $pixels[pixcoord(x, y)] = dumb_lighting(color, d);
// CEILING // CEILING
color = ceiling_texture[textureWidth * ty + tx]; color = ceiling_texture[texture_width * ty + tx];
$pixels[pixcoord(x, $height - y - 1)] = dumb_lighting(color, d); $pixels[pixcoord(x, $height - y - 1)] = dumb_lighting(color, d);
} }
} }

14
raycaster.hpp
Unescape View File

@ -15,16 +15,16 @@ struct Raycaster {
sf::Clock $clock; sf::Clock $clock;
sf::Shader $brightness; sf::Shader $brightness;
TexturePack &$textures; TexturePack &$textures;
double $posX = 0; double $pos_x = 0;
double $posY = 0; double $pos_y = 0;
// initial direction vector // initial direction vector
double $dirX = -1; double $dir_x = -1;
double $dirY = 0; double $dir_y = 0;
// the 2d raycaster version of camera plane // the 2d raycaster version of camera plane
double $planeX = 0; double $plane_x = 0;
double $planeY = 0.66; double $plane_y = 0.66;
sf::Texture $view_texture; sf::Texture $view_texture;
sf::Sprite $view_sprite; sf::Sprite $view_sprite;
@ -35,7 +35,7 @@ struct Raycaster {
GameLevel $level; GameLevel $level;
Matrix $map; Matrix $map;
std::unordered_map<DinkyECS::Entity, SpriteTexture> $sprites; std::unordered_map<DinkyECS::Entity, SpriteTexture> $sprites;
std::vector<double> ZBuffer; // width std::vector<double> $zbuffer; // width
Animator $anim; Animator $anim;
Raycaster(TexturePack &textures, int width, int height); Raycaster(TexturePack &textures, int width, int height);

Write Preview
Loading…
Cancel
Save