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

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

Browse Source
master
Zed A. Shaw 7 hours ago
parent 75c28cd764
commit ab1a415b55
7 changed files with 83 additions and 89 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. 56
      camera.cpp
  2. 14
      camera.hpp
  3. 23
      gui/main_ui.cpp
  4. 2
      gui/main_ui.hpp
  5. 1
      meson.build
  6. 60
      raycaster.cpp
  7. 16
      raycaster.hpp

56
camera.cpp
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape View File

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

60
raycaster.cpp
Unescape 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
Unescape 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();
};

Write Preview
Loading…
Cancel
Save