games/raycaster
1
0
Fork 0
Code Issues 30 Pull requests Projects Releases 2 Packages Wiki Activity Actions

Refactored the CameraLOL to be inside the rayview instead of a convolute main_ui->camera->rayview and back. Closes #16.

Browse source
This commit is contained in:
Zed A. Shaw 2025-06-29 11:11:12 -04:00
parent 75c28cd764
commit ab1a415b55
7 changed files with 83 additions and 89 deletions
Download patch file Download diff file Expand all files Collapse all files

56
camera.cpp
View file

@ -1,56 +0,0 @@
#include "camera.hpp"
#include <numbers>
#include <cmath>
Point CameraLOL::plan_move(int dir, bool strafe) {
t = 0.0;
if(strafe) {
target_x = rayview.$pos_x + int(-rayview.$dir_y * 1.5 * dir);
target_y = rayview.$pos_y + int(rayview.$dir_x * 1.5 * dir);
} else {
target_x = rayview.$pos_x + int(rayview.$dir_x * 1.5 * dir);
target_y = rayview.$pos_y + int(rayview.$dir_y * 1.5 * dir);
}
return {size_t(target_x), size_t(target_y)};
}
void CameraLOL::plan_rotate(int dir, float amount) {
t = 0.0;
double angle_dir = std::numbers::pi * amount * float(dir);
target_dir_x = rayview.$dir_x * cos(angle_dir) - rayview.$dir_y * sin(angle_dir);
target_dir_y = rayview.$dir_x * sin(angle_dir) + rayview.$dir_y * cos(angle_dir);
target_plane_x = rayview.$plane_x * cos(angle_dir) - rayview.$plane_y * sin(angle_dir);
target_plane_y = rayview.$plane_x * sin(angle_dir) + rayview.$plane_y * cos(angle_dir);
}
bool CameraLOL::play_rotate() {
t += rot_speed;
rayview.$dir_x = std::lerp(rayview.$dir_x, target_dir_x, t);
rayview.$dir_y = std::lerp(rayview.$dir_y, target_dir_y, t);
rayview.$plane_x = std::lerp(rayview.$plane_x, target_plane_x, t);
rayview.$plane_y = std::lerp(rayview.$plane_y, target_plane_y, t);
return t >= 1.0;
}
bool CameraLOL::play_move() {
t += move_speed;
rayview.$pos_x = std::lerp(rayview.$pos_x, target_x, t);
rayview.$pos_y = std::lerp(rayview.$pos_y, target_y, t);
return t >= 1.0;
}
void CameraLOL::abort_plan() {
target_x = rayview.$pos_x;
target_y = rayview.$pos_y;
}
Point CameraLOL::aimed_at() {
return {
size_t(rayview.$pos_x + rayview.$dir_x),
size_t(rayview.$pos_y + rayview.$dir_y)
};
}

14
camera.hpp
View file

@ -1,8 +1,6 @@
#pragma once
#include "raycaster.hpp"
struct CameraLOL {
Raycaster& rayview;
double t = 0.0;
double move_speed = 0.1;
double rot_speed = 0.06;
@ -12,16 +10,4 @@ struct CameraLOL {
double target_dir_y = 0.0;
double target_plane_x = 0.0;
double target_plane_y = 0.0;
CameraLOL(Raycaster& rv) :
rayview(rv) {}
Point plan_move(int dir, bool strafe);
void plan_rotate(int dir, float amount);
bool play_rotate();
bool play_move();
void abort_plan();
Point aimed_at();
};

23
gui/main_ui.cpp
View file

@ -9,8 +9,7 @@ namespace gui {
MainUI::MainUI(sf::RenderWindow& window) :
$window(window),
$rayview(RAY_VIEW_WIDTH, RAY_VIEW_HEIGHT),
$camera($rayview)
$rayview(RAY_VIEW_WIDTH, RAY_VIEW_HEIGHT)
{
$window.setVerticalSyncEnabled(VSYNC);
$window.setFramerateLimit(FRAME_LIMIT);
@ -32,7 +31,7 @@ namespace gui {
}
DinkyECS::Entity MainUI::camera_aim() {
auto aimed_at = $camera.aimed_at();
auto aimed_at = $rayview.aimed_at();
if($level.collision->occupied(aimed_at)) {
return $level.collision->get(aimed_at);
@ -42,7 +41,6 @@ namespace gui {
}
void MainUI::render() {
$rayview.aiming_at = camera_aim();
if($needs_render) $rayview.render();
$rayview.draw($window);
@ -59,20 +57,17 @@ namespace gui {
}
bool MainUI::play_rotate() {
bool done = $camera.play_rotate();
bool done = $rayview.play_rotate();
$needs_render = !done;
return done;
}
// this could be an optional that returs a Point
std::optional<Point> MainUI::play_move() {
if($camera.play_move()) {
if($rayview.play_move()) {
$needs_render = false;
Point pos{
size_t($camera.target_x),
size_t($camera.target_y)};
return std::make_optional<Point>(pos);
return std::make_optional<Point>(
$rayview.camera_target());
} else {
$needs_render = true;
return std::nullopt;
@ -83,15 +78,15 @@ namespace gui {
// -1 is left, 1 is right
int extra = (amount == 0.5) * dir;
$compass_dir = ($compass_dir + dir + extra) % COMPASS.size();
$camera.plan_rotate(dir, amount);
$rayview.plan_rotate(dir, amount);
}
Point MainUI::plan_move(int dir, bool strafe) {
return $camera.plan_move(dir, strafe);
return $rayview.plan_move(dir, strafe);
}
void MainUI::abort_plan() {
$camera.abort_plan();
$rayview.abort_plan();
}
void MainUI::dead_entity(DinkyECS::Entity entity) {

2
gui/main_ui.hpp
View file

@ -7,7 +7,6 @@
#include "gui/overlay_ui.hpp"
#include "gui/debug_ui.hpp"
#include "raycaster.hpp"
#include "camera.hpp"
#include <optional>
namespace gui {
@ -21,7 +20,6 @@ namespace gui {
GameLevel $level;
OverlayUI $overlay_ui;
Raycaster $rayview;
CameraLOL $camera;
MainUI(sf::RenderWindow& window);

1
meson.build
View file

@ -86,7 +86,6 @@ sources = [
'autowalker.cpp',
'backend.cpp',
'battle.cpp',
'camera.cpp',
'combat.cpp',
'components.cpp',
'config.cpp',

60
raycaster.cpp
View file

@ -442,3 +442,63 @@ void Raycaster::update_level(GameLevel level) {
void Raycaster::init_shaders() {
$brightness = shaders::get("rayview_sprites");
}
Point Raycaster::plan_move(int dir, bool strafe) {
$camera.t = 0.0;
if(strafe) {
$camera.target_x = $pos_x + int(-$dir_y * 1.5 * dir);
$camera.target_y = $pos_y + int($dir_x * 1.5 * dir);
} else {
$camera.target_x = $pos_x + int($dir_x * 1.5 * dir);
$camera.target_y = $pos_y + int($dir_y * 1.5 * dir);
}
return {size_t($camera.target_x), size_t($camera.target_y)};
}
void Raycaster::plan_rotate(int dir, float amount) {
$camera.t = 0.0;
double angle_dir = std::numbers::pi * amount * float(dir);
$camera.target_dir_x = $dir_x * cos(angle_dir) - $dir_y * sin(angle_dir);
$camera.target_dir_y = $dir_x * sin(angle_dir) + $dir_y * cos(angle_dir);
$camera.target_plane_x = $plane_x * cos(angle_dir) - $plane_y * sin(angle_dir);
$camera.target_plane_y = $plane_x * sin(angle_dir) + $plane_y * cos(angle_dir);
}
bool Raycaster::play_rotate() {
$camera.t += $camera.rot_speed;
$dir_x = std::lerp($dir_x, $camera.target_dir_x, $camera.t);
$dir_y = std::lerp($dir_y, $camera.target_dir_y, $camera.t);
$plane_x = std::lerp($plane_x, $camera.target_plane_x, $camera.t);
$plane_y = std::lerp($plane_y, $camera.target_plane_y, $camera.t);
return $camera.t >= 1.0;
}
bool Raycaster::play_move() {
$camera.t += $camera.move_speed;
$pos_x = std::lerp($pos_x, $camera.target_x, $camera.t);
$pos_y = std::lerp($pos_y, $camera.target_y, $camera.t);
return $camera.t >= 1.0;
}
void Raycaster::abort_plan() {
$camera.target_x = $pos_x;
$camera.target_y = $pos_y;
}
Point Raycaster::aimed_at() {
return {
size_t($pos_x + $dir_x),
size_t($pos_y + $dir_y)
};
}
Point Raycaster::camera_target() {
return {
size_t($camera.target_x),
size_t($camera.target_y)};
}

16
raycaster.hpp
View file

@ -5,6 +5,7 @@
#include "spatialmap.hpp"
#include "levelmanager.hpp"
#include "textures.hpp"
#include "camera.hpp"
using matrix::Matrix;
using RGBA = uint32_t;
@ -26,6 +27,7 @@ struct Raycaster {
sf::Texture $view_texture;
sf::Sprite $view_sprite;
DinkyECS::Entity aiming_at = 0;
CameraLOL $camera;
std::unique_ptr<RGBA[]> $pixels = nullptr;
@ -50,8 +52,6 @@ struct Raycaster {
void draw(sf::RenderTarget& target);
void sort_sprites(std::vector<int>& order, std::vector<double>& dist, int amount);
void position_camera(float player_x, float player_y);
void set_position(int x, int y);
inline size_t pixcoord(int x, int y) {
@ -62,4 +62,16 @@ struct Raycaster {
void update_sprite(DinkyECS::Entity ent, components::Sprite& sprite);
void init_shaders();
void apply_sprite_effect(shared_ptr<sf::Shader> effect, float width, float height);
// camera things?
void position_camera(float player_x, float player_y);
Point plan_move(int dir, bool strafe);
void plan_rotate(int dir, float amount);
bool play_rotate();
bool play_move();
void abort_plan();
Point aimed_at();
Point camera_target();
};