From b18b27e23c4e4d495ecc461761cba0dff52683da Mon Sep 17 00:00:00 2001 From: "Zed A. Shaw" Date: Mon, 13 Jan 2025 13:24:53 -0500 Subject: [PATCH] Goodbye fenster, you were fun but I need something more stable and easier to live with. --- meson.build | 7 + sfmlcaster.cpp | 376 +++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 383 insertions(+) create mode 100644 sfmlcaster.cpp diff --git a/meson.build b/meson.build index 4a4e2b9..d047015 100644 --- a/meson.build +++ b/meson.build @@ -38,6 +38,13 @@ executable('timcaster', [ ], dependencies: dependencies + [sdl2, sdl2main]) +executable('sfmlcaster', [ + 'dbc.cpp', + 'matrix.cpp', + 'sfmlcaster.cpp', + ], + dependencies: dependencies) + executable('fenstercaster', [ 'dbc.cpp', 'matrix.cpp', diff --git a/sfmlcaster.cpp b/sfmlcaster.cpp new file mode 100644 index 0000000..7fa3484 --- /dev/null +++ b/sfmlcaster.cpp @@ -0,0 +1,376 @@ +#include +#include +#include +#include +#include +#include +#include "matrix.hpp" +#include +#include "dbc.hpp" + +using matrix::Matrix; +using namespace fmt; + +Matrix MAP{ + {2,2,2,2,2,2,2,2,2}, + {2,0,8,0,0,0,0,0,2}, + {2,0,7,0,0,5,6,0,2}, + {2,0,0,0,0,0,0,0,2}, + {2,2,0,0,0,0,0,2,2}, + {2,0,0,1,3,4,0,0,2}, + {2,0,0,0,0,0,2,2,2}, + {2,0,0,0,0,0,0,0,2}, + {2,2,2,2,2,2,2,2,2} +}; + +const int SCREEN_HEIGHT=480; +const int SCREEN_WIDTH=SCREEN_HEIGHT * 2; + +const int THREED_VIEW_WIDTH=480; +const int THREED_VIEW_HEIGHT=480; +const int MAP_SIZE=matrix::width(MAP); +const int TILE_SIZE=(SCREEN_WIDTH/2) / MAP_SIZE; +const float FOV = std::numbers::pi / 3.0; +const float HALF_FOV = FOV / 2; +const int CASTED_RAYS=120; +const float STEP_ANGLE = FOV / CASTED_RAYS; +const int MAX_DEPTH = MAP_SIZE * TILE_SIZE; +const float SCALE = (SCREEN_WIDTH / 2) / CASTED_RAYS; +int PITCH=25; + +float player_x = SCREEN_WIDTH / 4; +float player_y = SCREEN_WIDTH / 4; + +// x and y start position +double posX = player_x / TILE_SIZE; +double posY = player_y / TILE_SIZE; + +// initial direction vector +double dirX = -1; +double dirY = 0; + +// the 2d raycaster version of camera plane +double planeX = 0; +double planeY = 0.66; + +#define rgba_color(r,g,b,a) (r<<(0*8))|(g<<(1*8))|(b<<(2*8))|(a<<(3*8)) +#define gray_color(c) rgba_color(c, c, c, 255) + +std::vector texture[8]; +#define texWidth 64 +#define texHeight 64 + +#define pixcoord(X, Y) ((Y) * SCREEN_HEIGHT) + (X) + +uint32_t pixels[SCREEN_HEIGHT * SCREEN_HEIGHT] = {0}; + +sf::Texture view_texture; +sf::Sprite view_sprite; + +void loadImage(std::vector& texture, const char *filename) { + sf::Image img; + bool good = img.loadFromFile(filename); + dbc::check(good, format("failed to load {}", filename)); + uint32_t *pixbuf = (uint32_t *)img.getPixelsPtr(); + std::copy_n(pixbuf, texture.size(), texture.begin()); +} + +void load_textures() { + for(int i = 0; i < 8; i++) { + texture[i].resize(texWidth * texHeight); + } + + loadImage(texture[0], "pics/eagle.png"); + loadImage(texture[1], "pics/redbrick.png"); + loadImage(texture[2], "pics/purplestone.png"); + loadImage(texture[3], "pics/greystone.png"); + loadImage(texture[4], "pics/bluestone.png"); + loadImage(texture[5], "pics/mossy.png"); + loadImage(texture[6], "pics/wood.png"); + loadImage(texture[7], "pics/colorstone.png"); +} + +void draw_sfml_rect(sf::RenderWindow &window, sf::Vector2f pos, sf::Vector2f size, uint8_t color) { + sf::RectangleShape rect(size); + rect.setFillColor({color, color, color}); + rect.setPosition(pos); + window.draw(rect); +} + +void draw_pixel_rect(sf::RenderWindow &window, Point pos, Point size, uint32_t color) { + size_t x_start = size_t(pos.x - SCREEN_HEIGHT); + size_t y_start = size_t(pos.y); + size_t width = size_t(size.x); + size_t height = size_t(size.y); + + for(size_t y = y_start; y < y_start + height; y++) { + for(size_t x = x_start; x < x_start + width; x++) { + size_t pixel_index = (y * SCREEN_HEIGHT) + x; + pixels[pixel_index] = color; + } + } +} + +void draw_pixel_buffer(sf::RenderWindow &window) { + view_texture.update((uint8_t *)pixels, SCREEN_HEIGHT, SCREEN_HEIGHT, 0, 0); + // BUG: can I do this once and just update it? + window.draw(view_sprite); +} + +void draw_map_rect(sf::RenderWindow &window, int x, int y, uint32_t color) { + draw_sfml_rect(window, + {float(x * TILE_SIZE), float(y * TILE_SIZE)}, + {float(TILE_SIZE-1), float(TILE_SIZE-1)}, + color); +} + +void draw_map(sf::RenderWindow &window, Matrix &map) { + uint32_t light_grey = gray_color(191); + uint32_t dark_grey = gray_color(65); + + for(size_t y = 0; y < matrix::height(map); y++) { + for(size_t x = 0; x < matrix::width(map); x++) { + draw_map_rect(window, x, y, map[y][x] == 0 ? dark_grey : light_grey); + } + } +} + +void draw_line(sf::RenderWindow &window, Point start, Point end, uint32_t color) { + int x = int(start.x); + int y = int(start.y); + int x1 = int(end.x); + int y1 = int(end.y); + int dx = std::abs(x1 - x); + int sx = x < x1 ? 1 : -1; + int dy = std::abs(y1 - y) * -1; + int sy = y < y1 ? 1 : -1; + int error = dx + dy; + + while(x != x1 || y != y1) { + int e2 = 2 * error; + + if(e2 >= dy) { + error = error + dy; + x = x + sx; + } + + if(e2 <= dx) { + error = error + dx; + y = y + sy; + } + + pixels[pixcoord(x,y)] = color; + } +} + +void clear(sf::RenderWindow &window) { + std::fill_n(pixels, SCREEN_HEIGHT * SCREEN_HEIGHT, 0); + window.clear(); +} + +void draw_map_blocks(sf::RenderWindow &window, int col, int row) { + draw_map_rect(window, col, row, rgba_color(100, 20, 20, 255)); +} + +void ray_casting(sf::RenderWindow &window, Matrix& map) { + int w = THREED_VIEW_WIDTH; + int h = THREED_VIEW_HEIGHT; + + for(int x = 0; x < w; x++) { + // calculate ray position and direction + double cameraX = 2 * x / double(w) - 1; // x-coord in camera space + double rayDirX = dirX + planeX * cameraX; + double rayDirY = dirY + planeY * cameraX; + + // which box of the map we're in + int mapX = int(posX); + int mapY = int(posY); + + // length of ray from current pos to next x or y-side + double sideDistX; + double sideDistY; + + // length of ray from one x or y-side to next x or y-side + double deltaDistX = std::abs(1.0 / rayDirX); + double deltaDistY = std::abs(1.0 / rayDirY); + double perpWallDist; + + int stepX = 0; + int stepY = 0; + int hit = 0; + int side = 0; + + // calculate step and initial sideDist + if(rayDirX < 0) { + stepX = -1; + sideDistX = (posX - mapX) * deltaDistX; + } else { + stepX = 1; + sideDistX = (mapX + 1.0 - posX) * deltaDistX; + } + + if(rayDirY < 0) { + stepY = -1; + sideDistY = (posY - mapY) * deltaDistY; + } else { + stepY = 1; + sideDistY = (mapY + 1.0 - posY) * deltaDistY; + } + + // perform DDA + while(hit == 0) { + if(sideDistX < sideDistY) { + sideDistX += deltaDistX; + mapX += stepX; + side = 0; + } else { + sideDistY += deltaDistY; + mapY += stepY; + side = 1; + } + + if(map[mapY][mapX] > 0) hit = 1; + } + + if(side == 0) { + perpWallDist = (sideDistX - deltaDistX); + } else { + perpWallDist = (sideDistY - deltaDistY); + } + + draw_map_blocks(window, mapX, mapY); + + // TODO: player direction ray + + int lineHeight = int(h / perpWallDist); + + int drawStart = -lineHeight / 2 + h / 2 + PITCH; + if(drawStart < 0) drawStart = 0; + + int drawEnd = lineHeight / 2 + h / 2 + PITCH; + if(drawEnd >= h) drawEnd = h - 1; + + int texNum = MAP[mapY][mapX] - 1; + + // calculate value of wallX + double wallX; // where exactly the wall was hit + if(side == 0) { + wallX = posY + perpWallDist * rayDirY; + } else { + wallX = posX + perpWallDist * rayDirX; + } + wallX -= floor((wallX)); + + // x coorindate on the texture + int texX = int(wallX * double(texWidth)); + if(side == 0 && rayDirX > 0) texX = texWidth - texX - 1; + if(side == 1 && rayDirY < 0) texX = texWidth - texX - 1; + + // 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 + double step = 1.0 * texHeight / lineHeight; + // Starting texture coordinate + double texPos = (drawStart - PITCH - h / 2 + lineHeight / 2) * step; + + for(int y = drawStart; y < drawEnd; y++) { + // BUG? Why bitwise and here? + int texY = (int)texPos & (texHeight - 1); + texPos += step; + uint32_t color = texture[texNum][texHeight * texY + texX]; + + pixels[pixcoord(x, y)] = color; + } + } +} + +void draw_ceiling_floor(sf::RenderWindow &window) { + draw_pixel_rect(window, + {size_t(SCREEN_WIDTH / 2), size_t(SCREEN_HEIGHT / 2)}, + {size_t(SCREEN_WIDTH / 2), size_t(SCREEN_HEIGHT / 2)}, + gray_color(200)); + + draw_pixel_rect(window, + {size_t(SCREEN_WIDTH / 2), 0}, + {size_t(SCREEN_HEIGHT), size_t(SCREEN_HEIGHT / 2 + PITCH)}, + gray_color(100)); +} + +void draw_everything(sf::RenderWindow &window) { + clear(window); + draw_map(window, MAP); + draw_ceiling_floor(window); + ray_casting(window, MAP); + draw_pixel_buffer(window); + window.display(); +} + +bool empty_space(int new_x, int new_y) { + dbc::check((size_t)new_x < matrix::width(MAP), + format("x={} too wide={}", new_x, matrix::width(MAP))); + dbc::check((size_t)new_y < matrix::height(MAP), + format("y={} too high={}", new_y, matrix::height(MAP))); + + return MAP[new_y][new_x] == 0; +} + +int main() { + using KB = sf::Keyboard; + sf::RenderWindow window(sf::VideoMode(SCREEN_WIDTH, SCREEN_HEIGHT), "SFMLCaster"); + + window.setVerticalSyncEnabled(true); + view_texture.create(SCREEN_HEIGHT, SCREEN_HEIGHT); + view_sprite.setTexture(view_texture); + view_sprite.setPosition(THREED_VIEW_WIDTH, 0); + + load_textures(); + + double moveSpeed = 0.1; + double rotSpeed = 0.1; + + while(window.isOpen()) { + draw_everything(window); + + if(KB::isKeyPressed(KB::W)) { + if(empty_space(int(posX + dirX * moveSpeed), int(posY))) posX += dirX * moveSpeed; + if(empty_space(int(posX), int(posY + dirY * moveSpeed))) posY += dirY * moveSpeed; + } else if(KB::isKeyPressed(KB::S)) { + if(empty_space(int(posX - dirX * moveSpeed), int(posY))) posX -= dirX * moveSpeed; + if(empty_space(int(posX), int(posY - dirY * moveSpeed))) posY -= dirY * moveSpeed; + } + + if(KB::isKeyPressed(KB::D)) { + double oldDirX = dirX; + dirX = dirX * cos(-rotSpeed) - dirY * sin(-rotSpeed); + dirY = oldDirX * sin(-rotSpeed) + dirY * cos(-rotSpeed); + + double oldPlaneX = planeX; + planeX = planeX * cos(-rotSpeed) - planeY * sin(-rotSpeed); + planeY = oldPlaneX * sin(-rotSpeed) + planeY * cos(-rotSpeed); + } else if(KB::isKeyPressed(KB::A)) { + double oldDirX = dirX; + dirX = dirX * cos(rotSpeed) - dirY * sin(rotSpeed); + dirY = oldDirX * sin(rotSpeed) + dirY * cos(rotSpeed); + + double oldPlaneX = planeX; + planeX = planeX * cos(rotSpeed) - planeY * sin(rotSpeed); + planeY = oldPlaneX * sin(rotSpeed) + planeY * cos(rotSpeed); + } + + if(KB::isKeyPressed(KB::E)) { + PITCH = std::clamp(PITCH + 10, -60, 240); + } else if(KB::isKeyPressed(KB::Q)) { + PITCH = std::clamp(PITCH - 10, -60, 240); + } + + sf::Event event; + while(window.pollEvent(event)) { + if(event.type == sf::Event::Closed) { + window.close(); + } + } + + } + + return 0; +}