1
0
Fork 0

Clean-up: Change indentation to tabs

This commit is contained in:
Teo-CD 2024-01-28 22:08:35 +00:00
parent 66ec111f5d
commit 41437cd259
6 changed files with 301 additions and 301 deletions

View file

@ -8,31 +8,31 @@ set(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake_modules" ${CMAKE_MODULE_PATH})
find_package(SFML COMPONENTS system window graphics network audio REQUIRED)
if(NOT SFML_FOUND)
message(FATAL_ERROR "SFML could not be found")
message(FATAL_ERROR "SFML could not be found")
endif()
set(LIBS
sfml-window
sfml-graphics)
sfml-window
sfml-graphics)
find_package(ImGui QUIET)
find_package(ImGui-SFML QUIET)
if(NOT ImGui_FOUND OR NOT ImGui-SFML_FOUND OR NO_IMGUI)
message("*Not* building with ImGui")
message("*Not* building with ImGui")
else ()
message("Building with ImGui")
add_compile_definitions(IMGUI)
set(LIBS ${LIBS}
ImGui-SFML::ImGui-SFML)
message("Building with ImGui")
add_compile_definitions(IMGUI)
set(LIBS ${LIBS}
ImGui-SFML::ImGui-SFML)
endif()
add_compile_options(-Wall -Wextra)
add_executable(raycasting
main.cpp
Player.cpp
World.cpp
)
main.cpp
Player.cpp
World.cpp
)
target_link_libraries(raycasting ${LIBS})

View file

@ -10,21 +10,21 @@ Player::Player(float x, float y, float alpha) : x(x), y(y), orientation(alpha)
void Player::move(float dx, float dy)
{
x += dx;
y += dy;
x += dx;
y += dy;
}
void Player::rotate(float alpha)
{
orientation += fmodf(alpha, 360);
if(orientation > 360)
{
orientation -= 360;
}
else if(orientation < 0)
{
orientation += 360;
}
orientation += fmodf(alpha, 360);
if(orientation > 360)
{
orientation -= 360;
}
else if(orientation < 0)
{
orientation += 360;
}
/*
* Rotate the movement vector along the new angle, assumes that the only
@ -33,9 +33,9 @@ void Player::rotate(float alpha)
float prevSpeedX = currentMoveSpeedX;
float prevSpeedY = currentMoveSpeedY;
currentMoveSpeedX = cosf(-alpha * deg_to_rad) * prevSpeedX
- sinf(-alpha * deg_to_rad) * prevSpeedY;
- sinf(-alpha * deg_to_rad) * prevSpeedY;
currentMoveSpeedY = sinf(-alpha * deg_to_rad) * prevSpeedX
+ cosf(-alpha * deg_to_rad) * prevSpeedY;
+ cosf(-alpha * deg_to_rad) * prevSpeedY;
}
void Player::updateSpeed(float localX, float localY) {

View file

@ -11,28 +11,28 @@ static constexpr float deg_to_rad = 3.14159265/180;
class Player {
public:
Player(float x, float y, float alpha);
Player(float x, float y, float alpha);
float x;
float y;
float orientation;
float x;
float y;
float orientation;
float moveSpeed = 5;
float rotationSpeed = 180;
float moveSpeed = 5;
float rotationSpeed = 180;
float currentMoveSpeedX = 0;
float currentMoveSpeedY = 0;
float currentMoveSpeedX = 0;
float currentMoveSpeedY = 0;
float currentRotationSpeed = 0;
float currentRotationSpeed = 0;
/* View properties. */
float fov = 70;
float sensorSize = 0.035; /* 35mm, about equivalent to human eye ? */
float focalLength = sensorSize / (2*tanf((fov*deg_to_rad)/2));
/* View properties. */
float fov = 70;
float sensorSize = 0.035; /* 35mm, about equivalent to human eye ? */
float focalLength = sensorSize / (2*tanf((fov*deg_to_rad)/2));
void move(float dx, float dy);
void rotate(float alpha);
void updateSpeed(float localX, float localY);
void move(float dx, float dy);
void rotate(float alpha);
void updateSpeed(float localX, float localY);
};

368
World.cpp
View file

@ -14,22 +14,22 @@ World::World(int w, int h, sf::Color groundColor, sf::Color ceilingColor, std::v
player(0,0,0), w(w), h(h), map(std::move(worldMap)),
groundColor(groundColor), ceilingColor(ceilingColor)
{
map.resize(w*h,BlockType::WALL);
map.resize(w*h,BlockType::WALL);
}
int World::getW() const
{
return w;
return w;
}
int World::getH() const
{
return h;
return h;
}
BlockType World::getBlock(int x, int y) const
{
return map[x + w*y];
return map[x + w*y];
}
BlockType World::getBlock(float x, float y) const
@ -39,176 +39,176 @@ BlockType World::getBlock(float x, float y) const
void World::setBlock(BlockType block, int x, int y, int width, int height)
{
for(int i = 0;i<height;i++)
{
for(int j = 0;j<width;j++)
{
if(x+j<w && y+i < h)
{
map.at((y+i)*w+x+j) = block;
}
}
}
for(int i = 0;i<height;i++)
{
for(int j = 0;j<width;j++)
{
if(x+j<w && y+i < h)
{
map.at((y+i)*w+x+j) = block;
}
}
}
}
std::ostream& operator<<(std::ostream& ostream, World const& world)
{
for(int i = 0;i<world.w*world.h;i++)
{
if(i%world.w == 0)
{
ostream << std::endl;
}
switch(world.getBlock(i%world.w,i/world.w))
{
case BlockType::AIR:
{
if(static_cast<int>(world.player.x) == i%world.w && static_cast<int>(world.player.y) == i/world.h)
{
ostream << "P";
}
else
{
ostream << " ";
}
break;
}
case BlockType::WALL:
{
ostream << "W";
break;
}
case BlockType::DOOR:
{
ostream << "D";
break;
}
case BlockType::WINDOW:
{
ostream << "W";
break;
}
}
}
return(ostream);
for(int i = 0;i<world.w*world.h;i++)
{
if(i%world.w == 0)
{
ostream << std::endl;
}
switch(world.getBlock(i%world.w,i/world.w))
{
case BlockType::AIR:
{
if(static_cast<int>(world.player.x) == i%world.w && static_cast<int>(world.player.y) == i/world.h)
{
ostream << "P";
}
else
{
ostream << " ";
}
break;
}
case BlockType::WALL:
{
ostream << "W";
break;
}
case BlockType::DOOR:
{
ostream << "D";
break;
}
case BlockType::WINDOW:
{
ostream << "W";
break;
}
}
}
return(ostream);
}
float World::castRay(float originX, float originY, float orientation) const
{
/*
* Reference used for ray intersection computations :
* https://web.archive.org/web/20220628034315/https://yunes.informatique.univ-paris-diderot.fr/wp-content/uploads/cours/INFOGRAPHIE/08-Raycasting.pdf
* The logic is as follows :
* - This computes one set of point per edge crossings (horizontal/vertical)
* - The origin not being confined to the grid, offsets are computed to
* align the intersections properly
* - The intersections are at multiples of the tangent of the relevant
* angle for the axis of interest, and simply on successive edges of
* the grid for the other one
* - Depending on the orientation, signs must be taken into account
* to work 360°
* - Those formulas consider regular axes (x,y), however the world is
* built around left-handed axes (x,y), so the rendered world is
* mirrored. This also explains some weird signs for rotations.
*/
/* Offsets to get back on the grid from the ray's origin. */
float hOffsetX;
float hOffsetY;
float vOffsetX;
float vOffsetY;
/*
* Reference used for ray intersection computations :
* https://web.archive.org/web/20220628034315/https://yunes.informatique.univ-paris-diderot.fr/wp-content/uploads/cours/INFOGRAPHIE/08-Raycasting.pdf
* The logic is as follows :
* - This computes one set of point per edge crossings (horizontal/vertical)
* - The origin not being confined to the grid, offsets are computed to
* align the intersections properly
* - The intersections are at multiples of the tangent of the relevant
* angle for the axis of interest, and simply on successive edges of
* the grid for the other one
* - Depending on the orientation, signs must be taken into account
* to work 360°
* - Those formulas consider regular axes (x,y), however the world is
* built around left-handed axes (x,y), so the rendered world is
* mirrored. This also explains some weird signs for rotations.
*/
/* Offsets to get back on the grid from the ray's origin. */
float hOffsetX;
float hOffsetY;
float vOffsetX;
float vOffsetY;
/* Signs controlling the direction of travel. */
float hDir;
float vDir;
/* Need offset for rounding in the right direction ? */
float hRound;
float vRound;
/* Signs controlling the direction of travel. */
float hDir;
float vDir;
/* Need offset for rounding in the right direction ? */
float hRound;
float vRound;
float rads = orientation * deg_to_rad;
/* Used for vertical intersections. */
float rads_offset = (90 - orientation) * deg_to_rad;
float rads = orientation * deg_to_rad;
/* Used for vertical intersections. */
float rads_offset = (90 - orientation) * deg_to_rad;
/* Tangents used for the different axes. */
float hTan = tanf(rads);
float vTan = tanf(rads_offset);
/* Tangents used for the different axes. */
float hTan = tanf(rads);
float vTan = tanf(rads_offset);
/* Check if cos > 0 for horizontal hits formulas. */
if (orientation < 90 || orientation > 270) {
hOffsetX = ceilf(originY) - originY;
hOffsetY = ceilf(originY);
hDir = +1;
hRound = 0;
} else {
hOffsetX = originY - floorf(originY);
hOffsetY = floorf(originY);
hDir = -1;
hRound = -1;
}
hTan *= hDir;
hOffsetX *= hTan;
/* Check if cos > 0 for horizontal hits formulas. */
if (orientation < 90 || orientation > 270) {
hOffsetX = ceilf(originY) - originY;
hOffsetY = ceilf(originY);
hDir = +1;
hRound = 0;
} else {
hOffsetX = originY - floorf(originY);
hOffsetY = floorf(originY);
hDir = -1;
hRound = -1;
}
hTan *= hDir;
hOffsetX *= hTan;
/* Check if sin > 0 for vertical hits formulas. */
if (orientation < 180) {
vOffsetX = ceilf(originX);
vOffsetY = ceilf(originX) - originX;
vDir = 1;
vRound = 0;
} else {
vOffsetX = floorf(originX);
vOffsetY = originX - floorf(originX);
vDir = -1;
vRound = -1;
}
vTan *= vDir;
vOffsetY *= vTan;
/* Check if sin > 0 for vertical hits formulas. */
if (orientation < 180) {
vOffsetX = ceilf(originX);
vOffsetY = ceilf(originX) - originX;
vDir = 1;
vRound = 0;
} else {
vOffsetX = floorf(originX);
vOffsetY = originX - floorf(originX);
vDir = -1;
vRound = -1;
}
vTan *= vDir;
vOffsetY *= vTan;
/*
* Now we have all the constants and deltas to work with, cast the ray.
* Generated points follow the formulas :
* - h-intersect : (originX + hOffsetX + hTan*i, hOffsetY + hDir*i)
* - v-intersect : (vOffsetX + vDir*i, originY + vOffsetY + vTan*i)
*/
int i = 0;
float hCheckX = originX + hOffsetX;
float hCheckY = hOffsetY;
/* Bounds + sanity check. */
while (hCheckX >= 0 && hCheckX <= static_cast<float>(w) &&
/*
* Now we have all the constants and deltas to work with, cast the ray.
* Generated points follow the formulas :
* - h-intersect : (originX + hOffsetX + hTan*i, hOffsetY + hDir*i)
* - v-intersect : (vOffsetX + vDir*i, originY + vOffsetY + vTan*i)
*/
int i = 0;
float hCheckX = originX + hOffsetX;
float hCheckY = hOffsetY;
/* Bounds + sanity check. */
while (hCheckX >= 0 && hCheckX <= static_cast<float>(w) &&
hCheckY >= 0 && hCheckY <= static_cast<float>(h) && i < h) {
if (getBlock(floorf(hCheckX), floorf(hCheckY) + hRound) == BlockType::WALL) {
break;
}
if (getBlock(floorf(hCheckX), floorf(hCheckY) + hRound) == BlockType::WALL) {
break;
}
hCheckX += hTan;
hCheckY += hDir;
i++;
}
hCheckX += hTan;
hCheckY += hDir;
i++;
}
i = 0;
float vCheckX = vOffsetX;
float vCheckY = originY + vOffsetY;
i = 0;
float vCheckX = vOffsetX;
float vCheckY = originY + vOffsetY;
/* Bounds + sanity check. */
while (vCheckX >= 0 && vCheckX < static_cast<float>(w) &&
/* Bounds + sanity check. */
while (vCheckX >= 0 && vCheckX < static_cast<float>(w) &&
vCheckY >= 0 && vCheckY < static_cast<float>(h) && i < w) {
if (getBlock(floorf(vCheckX) + vRound, floorf(vCheckY)) == BlockType::WALL) {
break;
}
if (getBlock(floorf(vCheckX) + vRound, floorf(vCheckY)) == BlockType::WALL) {
break;
}
vCheckX += vDir;
vCheckY += vTan;
i++;
}
vCheckX += vDir;
vCheckY += vTan;
i++;
}
/*
* We may or may not have hit something. Check which coordinates are closest
* and use those for computing the apparent size on screen.
*/
float hDist = sqrtf((originX - hCheckX)*(originX - hCheckX) +
(originY - hCheckY)*(originY - hCheckY));
float vDist = sqrtf((originX - vCheckX)*(originX - vCheckX) +
(originY - vCheckY)*(originY - vCheckY));
/*
* We may or may not have hit something. Check which coordinates are closest
* and use those for computing the apparent size on screen.
*/
float hDist = sqrtf((originX - hCheckX)*(originX - hCheckX) +
(originY - hCheckY)*(originY - hCheckY));
float vDist = sqrtf((originX - vCheckX)*(originX - vCheckX) +
(originY - vCheckY)*(originY - vCheckY));
return hDist > vDist ? vDist : hDist;
return hDist > vDist ? vDist : hDist;
}
void World::fillColumn(sf::RenderWindow& window, unsigned int column,
@ -227,51 +227,51 @@ void World::render(sf::RenderWindow& window) const
{
float windowX = static_cast<float>(window.getSize().x);
float windowY = static_cast<float>(window.getSize().y);
/*
* Draw ground and sky planes through half of the screen, as the walls
* will get drawn over them.
* This doesn't work if we support textures/levels.
*/
sf::RectangleShape ground = sf::RectangleShape(sf::Vector2f(windowX,windowY/2.0f));
ground.setFillColor(groundColor);
ground.setPosition(0,windowY/2.0f);
/*
* Draw ground and sky planes through half of the screen, as the walls
* will get drawn over them.
* This doesn't work if we support textures/levels.
*/
sf::RectangleShape ground = sf::RectangleShape(sf::Vector2f(windowX,windowY/2.0f));
ground.setFillColor(groundColor);
ground.setPosition(0,windowY/2.0f);
sf::RectangleShape ceiling = sf::RectangleShape(sf::Vector2f(windowX,windowY/2.0f));
ceiling.setFillColor(ceilingColor);
sf::RectangleShape ceiling = sf::RectangleShape(sf::Vector2f(windowX,windowY/2.0f));
ceiling.setFillColor(ceilingColor);
window.draw(ground);
window.draw(ceiling);
window.draw(ground);
window.draw(ceiling);
const float worldToCamera = (player.focalLength*2)/player.sensorSize;
/*
* Throw rays and draw walls over the ceiling and ground.
* Only throws in the plane, which doesn't work for levels/3D.
*/
for(unsigned int i = 0 ; i < window.getSize().x ; i++)
{
float deltaAngle = (player.fov/windowX) * (static_cast<float>(i)-windowX/2.0f);
float rayAngle = player.orientation + deltaAngle;
if (rayAngle < 0) {
rayAngle += 360;
} else if (rayAngle > 360) {
rayAngle -= 360;
}
float obstacleScale = worldToCamera / castRay(player.x, player.y, rayAngle);
/* 2 Is wall height in meters. */
fillColumn(window, i, obstacleScale);
}
/*
* Throw rays and draw walls over the ceiling and ground.
* Only throws in the plane, which doesn't work for levels/3D.
*/
for(unsigned int i = 0 ; i < window.getSize().x ; i++)
{
float deltaAngle = (player.fov/windowX) * (static_cast<float>(i)-windowX/2.0f);
float rayAngle = player.orientation + deltaAngle;
if (rayAngle < 0) {
rayAngle += 360;
} else if (rayAngle > 360) {
rayAngle -= 360;
}
float obstacleScale = worldToCamera / castRay(player.x, player.y, rayAngle);
/* 2 Is wall height in meters. */
fillColumn(window, i, obstacleScale);
}
}
void World::step(const float& stepTime) {
player.move(player.currentMoveSpeedX*stepTime,
player.currentMoveSpeedY*stepTime);
player.move(player.currentMoveSpeedX*stepTime,
player.currentMoveSpeedY*stepTime);
/* Undo last move if the player would end up in a wall. */
if (getBlock(player.x, player.y) != BlockType::AIR) {
player.move(-player.currentMoveSpeedX*stepTime,
-player.currentMoveSpeedY*stepTime);
}
player.rotate(player.currentRotationSpeed*stepTime);
player.rotate(player.currentRotationSpeed*stepTime);
#ifdef IMGUI
if (ImGui::Begin("MapEdit")) {

66
World.h
View file

@ -14,54 +14,54 @@
#include "Player.h"
enum class BlockType {
AIR,
WALL,
DOOR,
WINDOW,
AIR,
WALL,
DOOR,
WINDOW,
};
class World {
public:
Player player;
Player player;
World(int w, int h,
sf::Color groundColor = Colors::Ground,
sf::Color ceilingColor = Colors::Ceiling,
std::vector<BlockType> worldMap = {});
int getW() const;
int getH() const;
World(int w, int h,
sf::Color groundColor = Colors::Ground,
sf::Color ceilingColor = Colors::Ceiling,
std::vector<BlockType> worldMap = {});
int getW() const;
int getH() const;
inline BlockType getBlock(int x, int y) const;
inline BlockType getBlock(float x, float y) const;
void setBlock(BlockType block, int x, int y, int width = 1, int height = 1);
void render(sf::RenderWindow&) const;
void render(sf::RenderWindow&) const;
/**
* Move the world one step forward.
* @param stepTime delta time since last step, in seconds
*/
void step(const float& stepTime);
/**
* Move the world one step forward.
* @param stepTime delta time since last step, in seconds
*/
void step(const float& stepTime);
friend std::ostream& operator<<(std::ostream& ostream, World const & world);
friend std::ostream& operator<<(std::ostream& ostream, World const & world);
private:
int w;
int h;
std::vector<BlockType> map;
int w;
int h;
std::vector<BlockType> map;
sf::Color groundColor;
sf::Color ceilingColor;
sf::Color groundColor;
sf::Color ceilingColor;
void fillColumn(sf::RenderWindow&, unsigned int column, float scale,
sf::Color fillColor = Colors::Wall) const;
/**
* Cast a ray from a given position and return its distance to the origin.
* @param originX Ray X origin, strictly positive
* @param originY Ray Y origin, strictly positive
* @param orientation Angle to cast to, in degrees between 0 and 360
* @return Distance of the hit to the origin.
*/
float castRay(float originX, float originY, float orientation) const;
void fillColumn(sf::RenderWindow&, unsigned int column, float scale,
sf::Color fillColor = Colors::Wall) const;
/**
* Cast a ray from a given position and return its distance to the origin.
* @param originX Ray X origin, strictly positive
* @param originY Ray Y origin, strictly positive
* @param orientation Angle to cast to, in degrees between 0 and 360
* @return Distance of the hit to the origin.
*/
float castRay(float originX, float originY, float orientation) const;
};

View file

@ -12,13 +12,13 @@
int main()
{
World world(32,32);
world.setBlock(BlockType::AIR,1,1,30,30);
world.setBlock(BlockType::WALL,4,4,2,2);
world.player.move(2,2);
std::cout << world << std::endl;
World world(32,32);
world.setBlock(BlockType::AIR,1,1,30,30);
world.setBlock(BlockType::WALL,4,4,2,2);
world.player.move(2,2);
std::cout << world << std::endl;
sf::RenderWindow window(sf::VideoMode(1000,1000),"Da raycasting");
sf::RenderWindow window(sf::VideoMode(1000,1000),"Da raycasting");
#ifdef IMGUI
if (!ImGui::SFML::Init(window)) {
std::cout << "Failed to init Dear ImGui SFML" << std::endl;
@ -31,12 +31,12 @@ int main()
// window.setFramerateLimit(60);
sf::Event event{};
sf::Clock frameTime;
while (window.isOpen())
{
while (window.pollEvent(event))
{
sf::Event event{};
sf::Clock frameTime;
while (window.isOpen())
{
while (window.pollEvent(event))
{
if (event.type == sf::Event::Closed) {
window.close();
continue;
@ -56,43 +56,43 @@ int main()
if (io.WantCaptureMouse || io.WantCaptureKeyboard)
continue;
#endif
if (event.type == sf::Event::KeyPressed) {
switch (event.key.code) {
case sf::Keyboard::Key::Escape:
window.close();
break;
case sf::Keyboard::Key::Left:
world.player.currentRotationSpeed = -world.player.rotationSpeed;
break;
case sf::Keyboard::Key::Right:
world.player.currentRotationSpeed = world.player.rotationSpeed;
break;
if (event.type == sf::Event::KeyPressed) {
switch (event.key.code) {
case sf::Keyboard::Key::Escape:
window.close();
break;
case sf::Keyboard::Key::Left:
world.player.currentRotationSpeed = -world.player.rotationSpeed;
break;
case sf::Keyboard::Key::Right:
world.player.currentRotationSpeed = world.player.rotationSpeed;
break;
case sf::Keyboard::Key::Up:
world.player.updateSpeed(1, 0);
break;
case sf::Keyboard::Key::Down:
world.player.updateSpeed(-1, 0);
break;
default:
break;
}
}
else if (event.type == sf::Event::KeyReleased) {
switch (event.key.code) {
case sf::Keyboard::Key::Left:
case sf::Keyboard::Key::Right:
world.player.currentRotationSpeed = 0;
break;
default:
break;
}
}
else if (event.type == sf::Event::KeyReleased) {
switch (event.key.code) {
case sf::Keyboard::Key::Left:
case sf::Keyboard::Key::Right:
world.player.currentRotationSpeed = 0;
break;
case sf::Keyboard::Key::Up:
case sf::Keyboard::Key::Down:
world.player.updateSpeed(0, 0);
break;
default:
break;
}
}
}
window.clear();
default:
break;
}
}
}
window.clear();
const sf::Time& deltaT = frameTime.restart();
#ifdef IMGUI
@ -100,7 +100,7 @@ int main()
#endif
world.step(deltaT.asSeconds());
world.render(window);
world.render(window);
#ifdef IMGUI
// ImGui::ShowDemoWindow();
@ -126,11 +126,11 @@ int main()
ImGui::SFML::Render(window);
#endif
window.display();
}
window.display();
}
#ifdef IMGUI
ImGui::SFML::Shutdown();
#endif
return 0;
return 0;
}