brammie15/dae16-VerhulstBram-GameProject
1
0
Fork 0
mirror of https://github.com/HowestDAE/dae16-VerhulstBram.git synced 2025-12-15 13:31:48 +01:00
Code Issues Packages Projects Releases Wiki Activity

Add Imgui Navbar

Browse Source
This commit is contained in:
Bram Verhulst
2024-03-18 23:47:13 +01:00
parent 964a1a42f6
commit 6f2a6ead37
8 changed files with 95 additions and 152 deletions
Download Patch File Download Diff File Expand all files Collapse all files

BIN
ComicSans.ttf Normal file
View File

Binary file not shown.

4
Engine/BaseGame.cpp
View File

@@ -101,6 +101,10 @@ void BaseGame::InitializeGameEngine()
IMGUI_CHECKVERSION(); IMGUI_CHECKVERSION();
ImGui::CreateContext(); ImGui::CreateContext();
//ImGuiIO& io = ImGui::GetIO(); (void)io;
//io.Fonts->AddFontFromFileTTF("ComicSans.ttf", 18.0f, NULL, NULL);
// Setup Dear ImGui style // Setup Dear ImGui style
ImGui::StyleColorsDark(); ImGui::StyleColorsDark();
//ImGui::StyleColorsLight(); //ImGui::StyleColorsLight();

4
Engine/Collision.cpp
View File

@@ -2,11 +2,12 @@
#include "utils.h" #include "utils.h"
#include "../Game/Player.h" #include "../Game/Player.h"
#include "../Game/WorldTile.h"
namespace Collision namespace Collision
{ {
TileCollisionRect::TileCollisionRect(const Point2f& pos, const Point2f& size, WorldTile* tile): pos(pos), size(size), tile(tile) TileCollisionRect::TileCollisionRect(const Point2f& pos, const Point2f& size, WorldTile* tile): CollisionRect(pos, size), tile(tile)
{} {}
bool PointVsRect(const Point2f p, const Collision::CollisionRect& r) { bool PointVsRect(const Point2f p, const Collision::CollisionRect& r) {
return ( p.x >= r.pos.x && p.y >= r.pos.y && p.x < r.pos.x + r.size.x && p.y < r.pos.y + r.size.y ); return ( p.x >= r.pos.x && p.y >= r.pos.y && p.x < r.pos.x + r.size.x && p.y < r.pos.y + r.size.y );
@@ -125,6 +126,7 @@ namespace Collision
bool ResolvePlayerVsRect(Player& player, float ElapsedTime, Collision::CollisionRect* staticRectangle) { bool ResolvePlayerVsRect(Player& player, float ElapsedTime, Collision::CollisionRect* staticRectangle) {
CollisionRect rect = player.GetCollisionRect(); CollisionRect rect = player.GetCollisionRect();
Collision::ResolveDynamicRectVsRect(rect, ElapsedTime, staticRectangle); Collision::ResolveDynamicRectVsRect(rect, ElapsedTime, staticRectangle);
//dynamic_cast<TileCollisionRect*>(rect.ContactMap[CollisionDirection::Bottom])->tile->SetTileType(GroundTileTypes::Air);
// std::map<CollisionDirection, TileCollisionRect*> test = rect.ContactMap; // std::map<CollisionDirection, TileCollisionRect*> test = rect.ContactMap;
// player.SetContactMap(test); // player.SetContactMap(test);
player.SetPosition(rect.pos); player.SetPosition(rect.pos);

6
Engine/Collision.h
View File

@@ -31,14 +31,10 @@ namespace Collision
std::map<CollisionDirection, CollisionRect*> ContactMap{}; std::map<CollisionDirection, CollisionRect*> ContactMap{};
}; };
struct TileCollisionRect struct TileCollisionRect : virtual public CollisionRect
{ {
Point2f pos;
Point2f size;
Point2f vel;
TileCollisionRect(const Point2f& pos, const Point2f& size, WorldTile* tile); TileCollisionRect(const Point2f& pos, const Point2f& size, WorldTile* tile);
WorldTile* tile; WorldTile* tile;
std::map<CollisionDirection, TileCollisionRect*> ContactMap;
bool Contains(Point2f point2_f) { bool Contains(Point2f point2_f) {
return utils::IsPointInRect(point2_f, Rectf{ pos.x, pos.y, size.x, size.y }); return utils::IsPointInRect(point2_f, Rectf{ pos.x, pos.y, size.x, size.y });

31
Game/Game.cpp
View File

@@ -2,12 +2,15 @@
#include "pch.h" #include "pch.h"
#include "Game.h" #include "Game.h"
#include <iostream>
#include <ostream>
#include "colors.h" #include "colors.h"
#include "utils.h" #include "utils.h"
#include "WorldLevel.h" #include "WorldLevel.h"
Game::Game(const Window& window) Game::Game(const Window& window)
: BaseGame { window }, m_Camera(Camera()), m_WorldLevel(WorldLevel(&m_Camera)) : BaseGame { window }, m_Camera(Camera()), m_WorldLevel(WorldLevel(&m_Camera, GetViewPort()))
{ {
Initialize(); Initialize();
} }
@@ -60,7 +63,6 @@ void Game::ProcessKeyDownEvent(const SDL_KeyboardEvent& e) {
} }
void Game::ProcessKeyUpEvent(const SDL_KeyboardEvent& e) { void Game::ProcessKeyUpEvent(const SDL_KeyboardEvent& e) {
} }
void Game::ProcessMouseMotionEvent(const SDL_MouseMotionEvent& e) { void Game::ProcessMouseMotionEvent(const SDL_MouseMotionEvent& e) {
@@ -71,26 +73,10 @@ void Game::ProcessMouseMotionEvent(const SDL_MouseMotionEvent& e) {
void Game::ProcessMouseDownEvent(const SDL_MouseButtonEvent& e) { void Game::ProcessMouseDownEvent(const SDL_MouseButtonEvent& e) {
m_IsRightMouseDown = e.button == SDL_BUTTON_RIGHT; m_IsRightMouseDown = e.button == SDL_BUTTON_RIGHT;
m_MouseOffset = Point2f{m_Camera.GetPosition().x - m_MousePos.x, m_Camera.GetPosition().y - m_MousePos.y}; m_MouseOffset = Point2f{m_Camera.GetPosition().x - m_MousePos.x, m_Camera.GetPosition().y - m_MousePos.y};
//std::cout << "MOUSEBUTTONDOWN event: ";
//switch ( e.button )
//{
//case SDL_BUTTON_LEFT:
// std::cout << " left button " << std::endl;
// break;
//case SDL_BUTTON_RIGHT:
// std::cout << " right button " << std::endl;
// break;
//case SDL_BUTTON_MIDDLE:
// std::cout << " middle button " << std::endl;
// break;
//}
} }
void Game::ProcessMouseUpEvent(const SDL_MouseButtonEvent& e) { void Game::ProcessMouseUpEvent(const SDL_MouseButtonEvent& e) {
m_IsRightMouseDown = e.button == SDL_BUTTON_RIGHT; m_IsRightMouseDown = e.button == SDL_BUTTON_RIGHT ? false : m_IsRightMouseDown;
//std::cout << "MOUSEBUTTONUP event: "; //std::cout << "MOUSEBUTTONUP event: ";
//switch ( e.button ) //switch ( e.button )
//{ //{
@@ -106,11 +92,8 @@ void Game::ProcessMouseUpEvent(const SDL_MouseButtonEvent& e) {
//} //}
} }
void Game::ProcessImGui() { void Game::ProcessImGui() {
ImGui::Begin("Hello world", nullptr, ImGuiWindowFlags_AlwaysAutoResize);
ImGui::Text("Texture loading Count:");
ImGui::SameLine();
ImGui::TextColored(ImVec4(1.0f, 0.0f, 1.0f, 1.0f), std::to_string(Texture::m_TextureCounter).c_str());
ImGui::End();
m_WorldLevel.ProcessImGui(); m_WorldLevel.ProcessImGui();
} }

18
Game/Player.cpp
View File

@@ -7,7 +7,7 @@
#include "utils.h" #include "utils.h"
#include "WorldLevel.h" #include "WorldLevel.h"
Player::Player(const Point2f& Position) : m_Position(Position), m_Size(Point2f{50, 20}) Player::Player(const Point2f& Position) : m_Position(Position), m_Size(Point2f{40, 40})
{} {}
Collision::CollisionRect Player::GetCollisionRect() { Collision::CollisionRect Player::GetCollisionRect() {
Collision::CollisionRect rect = {m_Position, m_Size, m_Vel}; Collision::CollisionRect rect = {m_Position, m_Size, m_Vel};
@@ -46,9 +46,13 @@ void Player::Update(float elapsedTime, WorldLevel& level) {
std::vector<std::pair<int, float>> contactTimes{}; std::vector<std::pair<int, float>> contactTimes{};
for (size_t i { 0 }; i < level.m_Rects.size(); ++i) { for (size_t x { 0 }; x < level.WORLD_WIDTH; ++x) {
if(Collision::DynamicRectVsRect(this->GetCollisionRect(), elapsedTime, level.m_Rects[i], intersectionPoint, normal, t)) { for(size_t y { 0 }; y < level.WORLD_HEIGHT; ++y) {
contactTimes.push_back(std::pair<int, float>{i, t}); if(level.GetTileAt(Point2f{(float)x,(float)y})->GetTileType() == GroundTileTypes::Dirt) {
if(Collision::DynamicRectVsRect(this->GetCollisionRect(), elapsedTime, level.GetTileAt(Point2f{(float)x, (float)y})->GetCollisionRect().getCollisionRect(), intersectionPoint, normal, t)) {
contactTimes.push_back(std::pair<int, float>{x + y * level.WORLD_WIDTH, t});
}
}
} }
} }
@@ -57,7 +61,11 @@ void Player::Update(float elapsedTime, WorldLevel& level) {
}); });
for (std::pair<int, float> contact_time : contactTimes) { for (std::pair<int, float> contact_time : contactTimes) {
Collision::ResolvePlayerVsRect(*this, elapsedTime, &level.m_Rects[contact_time.first]); int x = contact_time.first % level.WORLD_WIDTH;
int y = contact_time.first / level.WORLD_WIDTH;
WorldTile* tile2 = level.GetTileAt(Point2f{(float) x, (float) y});
Collision::CollisionRect rect = tile2->GetCollisionRect().getCollisionRect(); //TODO: fix this mess
Collision::ResolvePlayerVsRect(*this, elapsedTime, &rect);
} }
m_Position = m_Position + m_Vel * elapsedTime; m_Position = m_Position + m_Vel * elapsedTime;

173
Game/WorldLevel.cpp
View File

@@ -11,7 +11,12 @@
#include "utils.h" #include "utils.h"
WorldLevel::WorldLevel(Camera* camera) : Level(camera), m_mousePos{ 0, 0 }, m_player(Player{ Point2f{ 0, 100 } }) { WorldLevel::WorldLevel(Camera* camera, Rectf viewport):
Level(camera),
m_player(Player { Point2f { 0, 100 } }),
m_mousePos { 0, 0 },
m_viewport(viewport)
{
// The grid is 34 x 50 big, the top center is 0,0 in world coords // The grid is 34 x 50 big, the top center is 0,0 in world coords
for (size_t x { 0 }; x < WORLD_WIDTH; ++x) { for (size_t x { 0 }; x < WORLD_WIDTH; ++x) {
for (size_t y { 0 }; y < WORLD_HEIGHT; ++y) { for (size_t y { 0 }; y < WORLD_HEIGHT; ++y) {
@@ -19,22 +24,7 @@ WorldLevel::WorldLevel(Camera* camera) : Level(camera), m_mousePos{ 0, 0 }, m_pl
m_worldTiles[x][y] = new WorldTile{ Point2f{ float(actualX * TILE_WIDTH), -float(y * TILE_HEIGHT) - TILE_HEIGHT}, GroundTileTypes::Dirt, TextureManager::GetInstance()}; m_worldTiles[x][y] = new WorldTile{ Point2f{ float(actualX * TILE_WIDTH), -float(y * TILE_HEIGHT) - TILE_HEIGHT}, GroundTileTypes::Dirt, TextureManager::GetInstance()};
} }
} }
m_Rects.push_back(Collision::CollisionRect{ Point2f{0.0f, 10.0f}, Point2f{40.0f, 40.0f} });
m_Rects.push_back(Collision::CollisionRect{ Point2f{170.0f, 70.0f}, Point2f{10.0f, 40.0f} });
m_Rects.push_back(Collision::CollisionRect{ Point2f{150.0f, 50.0f}, Point2f{20.0f, 20.0f} });
m_Rects.push_back(Collision::CollisionRect{ Point2f{150.0f, 150.0f}, Point2f{75.0f, 20.0f} });
m_Rects.push_back(Collision::CollisionRect{ Point2f{170.0f, 50.0f}, Point2f{20.0f, 20.0f} });
m_Rects.push_back(Collision::CollisionRect{ Point2f{190.0f, 50.0f}, Point2f{20.0f, 20.0f} });
m_Rects.push_back(Collision::CollisionRect{ Point2f{110.0f, 50.0f}, Point2f{20.0f, 20.0f} });
m_Rects.push_back(Collision::CollisionRect{ Point2f{50.0f, 130.0f}, Point2f{20.0f, 20.0f} });
m_Rects.push_back(Collision::CollisionRect{ Point2f{50.0f, 150.0f}, Point2f{20.0f, 20.0f} });
m_Rects.push_back(Collision::CollisionRect{ Point2f{50.0f, 170.0f}, Point2f{20.0f, 20.0f} });
m_Rects.push_back(Collision::CollisionRect{ Point2f{150.0f, 100.0f}, Point2f{10.0f, 1.0f} });
m_Rects.push_back(Collision::CollisionRect{ Point2f{200.0f, 100.0f}, Point2f{20.0f, 60.0f} });
// std::string dirtPath = + "tiles/dirt/dirt" + std::to_string(utils::randRange(1, 5)) + ".png";
// m_pTextTexture = new Texture(dirtPath);
} }
WorldLevel::~WorldLevel() { WorldLevel::~WorldLevel() {
//delete m_pTextTexture; //delete m_pTextTexture;
@@ -58,82 +48,12 @@ void WorldLevel::Update(float elapsedSec) {
} }
} }
if(selectedTile != nullptr) { if(selectedTile != nullptr) {
selectedTile->SetTileType(GroundTileTypes::Air); if(utils::isMouseDown(SDL_BUTTON_LEFT)) {
selectedTile->SetTileType(GroundTileTypes::Air);
}
} }
Point2f RayPoint = Point2f{m_pCamera->Viewport.width, m_pCamera->Viewport.height};
Point2f RayDir = Point2f{m_mousePos.x - RayPoint.x, m_mousePos.y - RayPoint.y};
//wasd movement
if(utils::isKeyDown(SDL_SCANCODE_W)) {
m_Rects[0].vel.y += 20;
}
if(utils::isKeyDown(SDL_SCANCODE_S)) {
m_Rects[0].vel.y += -10;
}
if(utils::isKeyDown(SDL_SCANCODE_A)) {
m_Rects[0].vel.x += -10;
}
if(utils::isKeyDown(SDL_SCANCODE_D)) {
m_Rects[0].vel.x += 10;
}
if(utils::isKeyDown(SDL_SCANCODE_SPACE)) {
//check if the player is on the ground
m_Rects[0].ContactMap[Collision::CollisionDirection::Bottom]->pos.y += 100;
}
m_Rects[0].vel.y -= 9.81f;
m_Rects[0].ContactMap.clear();
float t = 0, min_t = INFINITY;
Point2f intersectionPoint, normal;
std::vector<std::pair<int, float>> contactTimes{};
m_player.Update(elapsedSec, *this); m_player.Update(elapsedSec, *this);
// for (size_t i { 1 }; i < m_Rects.size(); ++i) {
// if(Collision::DynamicRectVsRect(m_Rects[0], elapsedSec, m_Rects[i], intersectionPoint, normal, t)) {
// contactTimes.push_back(std::pair<int, float>{i, t});
// }
// }
//
// std::sort(contactTimes.begin(), contactTimes.end(), [](const std::pair<int, float>& a, const std::pair<int, float>& b) {
// return a.second < b.second;
// });
//
// for (std::pair<int, float> contact_time : contactTimes) {
// Collision::ResolveDynamicRectVsRect(m_Rects[0], elapsedSec, &m_Rects[contact_time.first]);
// }
//contactTimes.clear();
// //loop over the worldTiles
// for (int x {0} ; x < WORLD_WIDTH; ++x) {
// for (int y {0}; y < WORLD_HEIGHT; ++y) {
// if(m_worldTiles[x][y]->GetTileType() == GroundTileTypes::Dirt) {
// if(Collision::DynamicRectVsRect(m_Rects[0], elapsedSec, m_worldTiles[x][y]->GetCollisionRect().getCollisionRect(), intersectionPoint, normal, t)) {
// contactTimes.push_back(std::pair<int, float>{x + y * WORLD_WIDTH, t});
// }
// }
// }
// }
//
// std::sort(contactTimes.begin(), contactTimes.end(), [](const std::pair<int, float>& a, const std::pair<int, float>& b) {
// return a.second < b.second;
// });
//
// for (std::pair<int, float> contact_time : contactTimes) {
// WorldTile* tile = m_worldTiles[contact_time.first % WORLD_WIDTH][contact_time.first / WORLD_WIDTH];
// Collision::CollisionRect rect = tile->GetCollisionRect().getCollisionRect();
// Collision::ResolveDynamicRectVsRect(m_Rects[0], elapsedSec, &rect);
// //delete tile;
// //WorldTile* tileRect = tile->GetCollisionRect().tile;
// //tileRect->SetTileType(GroundTileTypes::Air);
// }
//
// m_Rects[0].pos = m_Rects[0].pos + m_Rects[0].vel * elapsedSec;
} }
void WorldLevel::Draw() const { void WorldLevel::Draw() const {
m_pCamera->BeginRendering(); m_pCamera->BeginRendering();
@@ -167,21 +87,6 @@ void WorldLevel::Draw() const {
} }
} }
for (size_t i { 0 }; i < 4; ++i) {
if(m_Rects[0].ContactMap.find(static_cast<Collision::CollisionDirection>(i)) != m_Rects[0].ContactMap.end()) {
utils::SetColor(Colors::RED);
Collision::CollisionRect* rect = m_Rects[0].ContactMap.at(static_cast<Collision::CollisionDirection>(i));
utils::FillRect(rect->pos, rect->size.x, rect->size.y);
}
}
// utils::SetColor(Colors::WHITE);
// for (int x { -100 }; x < 100; ++x) {
// for (int y { -100 }; y < 100; ++y) {
// utils::DrawLine(x * 50, -5000, x * 50, 50000);
// utils::DrawLine(-5000, y * 50, 50000, y * 50);
// }
// }
utils::SetColor(Colors::MAGENTA); utils::SetColor(Colors::MAGENTA);
utils::FillEllipse(0, 0, 5, 5); utils::FillEllipse(0, 0, 5, 5);
@@ -191,21 +96,57 @@ void WorldLevel::Draw() const {
void WorldLevel::MouseMove(const Point2f& mousePos) { void WorldLevel::MouseMove(const Point2f& mousePos) {
m_mousePos = mousePos; m_mousePos = mousePos;
} }
void WorldLevel::ProcessImGui() { void WorldLevel::ProcessImGui() {
ImGui::Begin("Player Info", nullptr, ImGuiWindowFlags_AlwaysAutoResize); if (ImGui::BeginMainMenuBar()) {
ImGui::Text("Player Position: (%f, %f)", m_player.GetPosition().x, m_player.GetPosition().y); if (ImGui::BeginMenu("Properties")) {
ImGui::Text("Player Velocity: (%f, %f)", m_player.GetVelocity().x, m_player.GetVelocity().y); if (ImGui::MenuItem("TextureManager Info")) {
//PLAYER COLLISIONS m_ShowTextureManagerWindow = !m_ShowTextureManagerWindow;
ImGui::Text("Player Collisions:"); }
// for (std::pair<Collision::CollisionDirection, Collision::CollisionRect*> contact : m_player.GetContactMap()) { if (ImGui::MenuItem("Camera Info")) {
// ImGui::Text("Direction: %d", contact.first); m_ShowCameraWindow = !m_ShowCameraWindow;
// ImGui::Text("Position: (%f, %f)", contact.second->pos.x, contact.second->pos.y); }
// ImGui::Text("Size: (%f, %f)", contact.second->size.x, contact.second->size.y); if(ImGui::MenuItem("Player Info")) {
// } m_ShowPlayerInfo = !m_ShowPlayerInfo;
ImGui::End(); }
ImGui::EndMenu();
}
ImGui::EndMainMenuBar();
}
if(m_ShowTextureManagerWindow) {
ImGui::Begin("Texture Manager", &m_ShowTextureManagerWindow, ImGuiWindowFlags_AlwaysAutoResize);
ImGui::Text("Texture loading Count:");
ImGui::SameLine();
ImGui::TextColored(ImVec4(1.0f, 0.0f, 1.0f, 1.0f), std::to_string(Texture::m_TextureCounter).c_str());
ImGui::End();
}
if(m_ShowCameraWindow) {
ImGui::Begin("Camera", &m_ShowCameraWindow, ImGuiWindowFlags_AlwaysAutoResize);
ImGui::Text("Camera Position: (%f, %f)", m_pCamera->GetPosition().x, m_pCamera->GetPosition().y);
if(ImGui::Button("Reset Camera")) {
m_pCamera->SetPosition(Point2f{m_viewport.width / 2, m_viewport.height / 2});
}
ImGui::End();
}
if(m_ShowPlayerInfo) {
ImGui::Begin("Player Info", &m_ShowPlayerInfo, ImGuiWindowFlags_AlwaysAutoResize);
ImGui::Text("Player Position: (%f, %f)", m_player.GetPosition().x, m_player.GetPosition().y);
ImGui::Text("Player Velocity: (%f, %f)", m_player.GetVelocity().x, m_player.GetVelocity().y);
//PLAYER COLLISIONS
ImGui::Text("Player Collisions:");
// for (std::pair<Collision::CollisionDirection, Collision::CollisionRect*> contact : m_player.GetContactMap()) {
// ImGui::Text("Direction: %d", contact.first);
// ImGui::Text("Position: (%f, %f)", contact.second->pos.x, contact.second->pos.y);
// ImGui::Text("Size: (%f, %f)", contact.second->size.x, contact.second->size.y);
// }
ImGui::End();
}
} }
WorldTile* WorldLevel::GetTileAt(const Point2f& pos) const { WorldTile* WorldLevel::GetTileAt(const Point2f& pos) const {
return nullptr; return m_worldTiles[pos.x][pos.y];
} }
void WorldLevel::SetTileAt(const Point2f& pos, WorldTile* tile) { void WorldLevel::SetTileAt(const Point2f& pos, WorldTile* tile) {
} }

11
Game/WorldLevel.h
View File

@@ -18,7 +18,7 @@ public:
static const int TILE_WIDTH = 50; static const int TILE_WIDTH = 50;
static const int TILE_HEIGHT = 50; static const int TILE_HEIGHT = 50;
WorldLevel(Camera* camera); WorldLevel(Camera* camera, Rectf viewport);
~WorldLevel() override; ~WorldLevel() override;
void Update(float elapsedSec) override; void Update(float elapsedSec) override;
@@ -34,6 +34,8 @@ public:
std::vector<Collision::CollisionRect> m_Rects; std::vector<Collision::CollisionRect> m_Rects;
std::array<std::array<WorldTile*, WORLD_WIDTH>, WORLD_HEIGHT> GetWorldTiles() const { return m_worldTiles; }
private: private:
@@ -43,4 +45,11 @@ private:
Player m_player; Player m_player;
Point2f m_mousePos{}; Point2f m_mousePos{};
Rectf m_viewport;
// ImGui Vars
bool m_ShowTextureManagerWindow{ false };
bool m_ShowCameraWindow{ false };
bool m_ShowPlayerInfo{ false };
}; };