Persson-dev/Tower-Defense2
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

raylib-cpp progress

Browse Source
This commit is contained in:
Simon Pribylski
2026-01-30 13:18:01 +01:00
parent 44851099d4
commit 3db0afa2e2
25 changed files with 68 additions and 66 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
include/client/state/GameState.h
View File

@@ -16,7 +16,7 @@ class GameState : public ClientState {
public: public:
GameState(Client& a_Client, const game::WorldPtr& a_World, std::uint64_t a_StepTime, const std::vector<protocol::LockStep> a_FirstSteps); GameState(Client& a_Client, const game::WorldPtr& a_World, std::uint64_t a_StepTime, const std::vector<protocol::LockStep> a_FirstSteps);
~GameState() {} ~GameState();
virtual void Update(float a_Delta) override; virtual void Update(float a_Delta) override;

6
include/td/misc/Signal.h
View File

@@ -33,7 +33,7 @@ class SignalRaw : private NonCopyable {
void operator()(Args... args) const { void operator()(Args... args) const {
for (const CallBack& callback : m_Callbacks) { for (const CallBack& callback : m_Callbacks) {
callback->operator()(args...); callback->operator()(std::forward<Args>(args)...);
} }
} }
}; };
@@ -64,9 +64,9 @@ class Signal {
m_Signal->Connect(std::make_shared<CallBackRaw>(a_Callback)); m_Signal->Connect(std::make_shared<CallBackRaw>(a_Callback));
} }
[[nodiscard]] std::unique_ptr<ConnectionGuard> ConnectSafe(const CallBack& a_Callback) { [[nodiscard]] std::shared_ptr<ConnectionGuard> ConnectSafe(const CallBack& a_Callback) {
m_Signal->Connect(a_Callback); m_Signal->Connect(a_Callback);
return std::make_unique<ConnectionGuard>(*this, a_Callback); return std::make_shared<ConnectionGuard>(*this, a_Callback);
} }
void Disconnect(const CallBack& a_Callback) { void Disconnect(const CallBack& a_Callback) {

4
include/td/misc/SlotGuard.h
View File

@@ -12,7 +12,7 @@ namespace utils {
*/ */
class SlotGuard { class SlotGuard {
private: private:
std::vector<std::unique_ptr<Connection>> m_Connections; std::vector<std::shared_ptr<Connection>> m_Connections;
public: public:
/** /**
@@ -21,7 +21,7 @@ class SlotGuard {
template <typename... Args> template <typename... Args>
void Connect(Signal<Args...> a_Signal, const typename Signal<Args...>::CallBack::element_type& a_Callback) { void Connect(Signal<Args...> a_Signal, const typename Signal<Args...>::CallBack::element_type& a_Callback) {
auto ptr = std::make_shared<typename Signal<Args...>::CallBack::element_type>(a_Callback); auto ptr = std::make_shared<typename Signal<Args...>::CallBack::element_type>(a_Callback);
m_Connections.push_back(a_Signal.ConnectSafe(ptr)); m_Connections.emplace_back(a_Signal.ConnectSafe(ptr));
} }
void Disconnect() { void Disconnect() {

11
include/td/render/RayGui.h Normal file
View File

@@ -0,0 +1,11 @@
#pragma once
// extern "C" {
// #include <raygui.h>
// }
extern "C" {
#include <rlImGui.h>
}
#include <imgui.h>

10
include/td/render/Renderer.h
View File

@@ -1,7 +1,7 @@
#pragma once #pragma once
#include <memory> #include <memory>
#include <raylib.h> #include <raylib-cpp/Camera3D.hpp>
#include <td/render/loader/GLLoader.h> #include <td/render/loader/GLLoader.h>
#include <td/render/shader/CameraShaderProgram.h> #include <td/render/shader/CameraShaderProgram.h>
#include <td/misc/SlotGuard.h> #include <td/misc/SlotGuard.h>
@@ -21,10 +21,10 @@ template <typename TShader>
class Renderer : public BasicRenderer, private utils::SlotGuard { class Renderer : public BasicRenderer, private utils::SlotGuard {
protected: protected:
std::unique_ptr<TShader> m_Shader; std::unique_ptr<TShader> m_Shader;
Camera& m_Camera; raylib::Camera& m_Camera;
public: public:
Renderer(Camera& a_Camera); Renderer(raylib::Camera& a_Camera);
virtual ~Renderer() {} virtual ~Renderer() {}
template <typename T> template <typename T>
@@ -42,7 +42,7 @@ class RenderPipeline {
virtual ~RenderPipeline() {} virtual ~RenderPipeline() {}
template <typename T, typename... Args> template <typename T, typename... Args>
T& AddRenderer(Args&&... args) { T& AddRenderer(Args... args) {
auto ptr = std::make_unique<T>(args...); auto ptr = std::make_unique<T>(args...);
auto rawPtr = ptr.get(); auto rawPtr = ptr.get();
m_Renderers.push_back(std::move(ptr)); m_Renderers.push_back(std::move(ptr));
@@ -65,7 +65,7 @@ class RenderPipeline {
template <typename TShader> template <typename TShader>
Renderer<TShader>::Renderer(Camera& a_Camera) : m_Shader(std::make_unique<TShader>()), m_Camera(a_Camera) { Renderer<TShader>::Renderer(raylib::Camera& a_Camera) : m_Shader(std::make_unique<TShader>()), m_Camera(a_Camera) {
// Connect(a_Camera.OnPerspectiveChange, [this](){ // Connect(a_Camera.OnPerspectiveChange, [this](){
// // m_Shader->Start(); // // m_Shader->Start();
// m_Shader->SetProjectionMatrix(m_Camera.GetProjectionMatrix()); // m_Shader->SetProjectionMatrix(m_Camera.GetProjectionMatrix());

2
include/td/render/loader/WorldLoader.h
View File

@@ -1,7 +1,7 @@
#pragma once #pragma once
#include <td/game/World.h> #include <td/game/World.h>
#include <raylib.h> #include <raylib-cpp/Mesh.hpp>
namespace td { namespace td {
namespace render { namespace render {

6
include/td/render/renderer/EntityRenderer.h
View File

@@ -1,9 +1,9 @@
#pragma once #pragma once
#include <raylib.h>
#include <td/render/Renderer.h> #include <td/render/Renderer.h>
#include <td/render/shader/EntityShader.h> #include <td/render/shader/EntityShader.h>
#include <td/game/World.h> #include <td/game/World.h>
#include <raylib-cpp/Model.hpp>
namespace td { namespace td {
namespace render { namespace render {
@@ -11,11 +11,11 @@ namespace render {
class EntityRenderer : public Renderer<shader::EntityShader> { class EntityRenderer : public Renderer<shader::EntityShader> {
private: private:
game::WorldPtr m_World; game::WorldPtr m_World;
Model m_ZombieModel; raylib::Model m_ZombieModel;
Texture2D m_ZombieTexture; Texture2D m_ZombieTexture;
public: public:
EntityRenderer(Camera& a_Camera, const game::WorldPtr& a_World); EntityRenderer(raylib::Camera& a_Camera, const game::WorldPtr& a_World);
virtual ~EntityRenderer(); virtual ~EntityRenderer();
virtual void Render(float a_Lerp) override; virtual void Render(float a_Lerp) override;

9
include/td/render/renderer/TowerRenderer.h
View File

@@ -1,9 +1,10 @@
#pragma once #pragma once
#include <raylib.h>
#include <td/render/Renderer.h> #include <td/render/Renderer.h>
#include <td/render/shader/EntityShader.h> #include <td/render/shader/EntityShader.h>
#include <td/game/World.h> #include <td/game/World.h>
#include <raylib-cpp/Model.hpp>
#include <raylib-cpp/Texture.hpp>
namespace td { namespace td {
namespace render { namespace render {
@@ -11,11 +12,11 @@ namespace render {
class TowerRenderer : public Renderer<shader::EntityShader> { class TowerRenderer : public Renderer<shader::EntityShader> {
private: private:
game::WorldPtr m_World; game::WorldPtr m_World;
Model m_TowerModel; raylib::Model m_TowerModel;
Texture2D m_TowerTexture; raylib::Texture2D m_TowerTexture;
public: public:
TowerRenderer(Camera& a_Camera, const game::WorldPtr& a_World); TowerRenderer(raylib::Camera& a_Camera, const game::WorldPtr& a_World);
virtual ~TowerRenderer(); virtual ~TowerRenderer();
virtual void Render(float a_Lerp) override; virtual void Render(float a_Lerp) override;

5
include/td/render/renderer/WorldRenderer.h
View File

@@ -4,16 +4,17 @@
#include <td/render/Renderer.h> #include <td/render/Renderer.h>
#include <td/render/loader/GLLoader.h> #include <td/render/loader/GLLoader.h>
#include <td/render/shader/WorldShader.h> #include <td/render/shader/WorldShader.h>
#include <raylib-cpp/Model.hpp>
namespace td { namespace td {
namespace render { namespace render {
class WorldRenderer : public Renderer<shader::WorldShader> { class WorldRenderer : public Renderer<shader::WorldShader> {
private: private:
Model m_WorldModel; std::unique_ptr<raylib::Model> m_WorldModel;
public: public:
WorldRenderer(Camera& a_Camera, const game::WorldPtr& a_World); WorldRenderer(raylib::Camera& a_Camera, const game::WorldPtr& a_World);
virtual ~WorldRenderer(); virtual ~WorldRenderer();
virtual void Render(float a_Lerp) override; virtual void Render(float a_Lerp) override;

1
include/td/render/shader/CameraShaderProgram.h
View File

@@ -1,6 +1,5 @@
#pragma once #pragma once
#include <raylib.h>
#include <td/Maths.h> #include <td/Maths.h>
namespace td { namespace td {

6
src/client/state/GameState.cpp
View File

@@ -1,15 +1,19 @@
#include <client/state/GameState.h> #include <client/state/GameState.h>
namespace td { namespace td {
namespace client { namespace client {
GameState::GameState(Client& a_Client, const std::shared_ptr<game::World>& a_World, std::uint64_t a_StepTime, const std::vector<protocol::LockStep> a_FirstSteps) : GameState::GameState(Client& a_Client, const std::shared_ptr<game::World>& a_World, std::uint64_t a_StepTime,
const std::vector<protocol::LockStep> a_FirstSteps) :
ClientState(a_Client), m_World(a_World), m_Simulation(a_World, a_StepTime, a_FirstSteps) { ClientState(a_Client), m_World(a_World), m_Simulation(a_World, a_StepTime, a_FirstSteps) {
m_Simulation.OnMissingLockSteps.Connect([this](const std::vector<td::StepTime>& a_MissingSteps) { m_Simulation.OnMissingLockSteps.Connect([this](const std::vector<td::StepTime>& a_MissingSteps) {
SendPacket(protocol::packets::LockStepRequestPacket(a_MissingSteps)); SendPacket(protocol::packets::LockStepRequestPacket(a_MissingSteps));
}); });
} }
GameState::~GameState() {}
void GameState::Handle(const protocol::packets::LockStepsPacket& a_LockStep) { void GameState::Handle(const protocol::packets::LockStepsPacket& a_LockStep) {
m_Simulation.Handle(a_LockStep); m_Simulation.Handle(a_LockStep);
} }

5
src/td/display/Display.cpp
View File

@@ -4,9 +4,8 @@
#include <td/misc/Format.h> #include <td/misc/Format.h>
#include <td/misc/Log.h> #include <td/misc/Log.h>
#include <rlImGui.h> #include <raylib-cpp/raylib.hpp>
#include <imgui.h> #include <td/render/RayGui.h>
#include <raylib.h>
namespace td { namespace td {

3
src/td/display/ImGuiTheme.cpp
View File

@@ -1,11 +1,10 @@
#include <td/display/ImGuiTheme.h> #include <td/display/ImGuiTheme.h>
#include <imgui.h> #include <td/render/RayGui.h>
namespace td { namespace td {
void LoadTheme() { void LoadTheme() {
static const bool bStyleDark_ = true; static const bool bStyleDark_ = true;
static const float alpha_ = 0.8f; static const float alpha_ = 0.8f;

2
src/td/display/menu/CreatePartyMenu.cpp
View File

@@ -1,6 +1,6 @@
#include <td/display/menu/CreatePartyMenu.h> #include <td/display/menu/CreatePartyMenu.h>
#include <imgui.h> #include <td/render/RayGui.h>
namespace td { namespace td {

2
src/td/display/menu/JoinPartyMenu.cpp
View File

@@ -1,6 +1,6 @@
#include <td/display/menu/JoinPartyMenu.h> #include <td/display/menu/JoinPartyMenu.h>
#include <imgui.h> #include <td/render/RayGui.h>
namespace td { namespace td {

2
src/td/display/menu/MainMenu.cpp
View File

@@ -1,6 +1,6 @@
#include <td/display/menu/MainMenu.h> #include <td/display/menu/MainMenu.h>
#include <imgui.h> #include <td/render/RayGui.h>
#include <td/display/menu/CreatePartyMenu.h> #include <td/display/menu/CreatePartyMenu.h>
#include <td/display/menu/JoinPartyMenu.h> #include <td/display/menu/JoinPartyMenu.h>
#include <td/display/menu/SettingsMenu.h> #include <td/display/menu/SettingsMenu.h>

2
src/td/display/menu/SettingsMenu.cpp
View File

@@ -1,6 +1,6 @@
#include <td/display/menu/SettingsMenu.h> #include <td/display/menu/SettingsMenu.h>
#include <imgui.h> #include <td/render/RayGui.h>
namespace td { namespace td {

17
src/td/display/state/DebugWorldState.cpp
View File

@@ -19,11 +19,9 @@
#include <client/state/GameState.h> #include <client/state/GameState.h>
#include <client/state/LoggingState.h> #include <client/state/LoggingState.h>
#include <raylib.h>
namespace td { namespace td {
DebugWorldState::DebugWorldState(Display& a_Display) : DisplayState(a_Display) { DebugWorldState::DebugWorldState(Display& a_Display) : DisplayState(a_Display), m_ClientState(nullptr) {
// server // server
m_ServerSocket = std::make_shared<server::FakeSocket>(); m_ServerSocket = std::make_shared<server::FakeSocket>();
m_Server = std::make_unique<server::Server>(m_ServerSocket); m_Server = std::make_unique<server::Server>(m_ServerSocket);
@@ -37,12 +35,12 @@ DebugWorldState::DebugWorldState(Display& a_Display) : DisplayState(a_Display) {
if (auto gameState = dynamic_cast<client::GameState*>(&a_State)) { if (auto gameState = dynamic_cast<client::GameState*>(&a_State)) {
// render // render
auto clientWorld = gameState->GetWorld(); auto clientWorld = gameState->GetWorld();
m_Renderer.AddRenderer<render::WorldRenderer>(m_Camera, clientWorld); m_Renderer.AddRenderer<render::WorldRenderer>(static_cast<raylib::Camera&>(m_Camera), clientWorld);
m_Renderer.AddRenderer<render::EntityRenderer>(m_Camera, clientWorld); m_Renderer.AddRenderer<render::EntityRenderer>(static_cast<raylib::Camera&>(m_Camera), clientWorld);
m_Renderer.AddRenderer<render::TowerRenderer>(m_Camera, clientWorld); m_Renderer.AddRenderer<render::TowerRenderer>(static_cast<raylib::Camera&>(m_Camera), clientWorld);
m_Renderer.AddRenderer<render::TimerRenderer>(*gameState); m_Renderer.AddRenderer<render::TimerRenderer, client::GameState&>(*gameState);
auto& list = m_Renderer.AddRenderer<render::PlayerListRenderer>(m_Client->GetPlayers()); auto& list = m_Renderer.AddRenderer<render::PlayerListRenderer, const td::client::PlayerManager&>(m_Client->GetPlayers());
list.OnPlayerCreate.Connect([this]() { list.OnPlayerCreate.Connect([this]() {
auto newSocket = client::FakeSocket::Connect(m_ServerSocket); auto newSocket = client::FakeSocket::Connect(m_ServerSocket);
@@ -85,8 +83,9 @@ void DebugWorldState::Update(float a_Delta) {
UpdateCamera(&m_Camera, CAMERA_FREE); UpdateCamera(&m_Camera, CAMERA_FREE);
if (m_ClientState) { if (m_ClientState) {
float lerp = m_ClientState->GetCurrentLerp();
BeginMode3D(m_Camera); BeginMode3D(m_Camera);
m_Renderer.Render(m_ClientState->GetCurrentLerp()); m_Renderer.Render(lerp);
EndMode3D(); EndMode3D();
} }

2
src/td/display/state/MainMenuState.cpp
View File

@@ -1,6 +1,6 @@
#include <td/display/state/MainMenuState.h> #include <td/display/state/MainMenuState.h>
#include <imgui.h> #include <td/render/RayGui.h>
#include <td/display/menu/MainMenu.h> #include <td/display/menu/MainMenu.h>
#include <td/display/state/DebugWorldState.h> #include <td/display/state/DebugWorldState.h>

7
src/td/render/renderer/EntityRenderer.cpp
View File

@@ -1,5 +1,4 @@
#include <cassert> #include <cassert>
#include <raylib.h>
#include <td/render/renderer/EntityRenderer.h> #include <td/render/renderer/EntityRenderer.h>
#include <td/render/loader/WorldLoader.h> #include <td/render/loader/WorldLoader.h>
@@ -7,12 +6,10 @@
namespace td { namespace td {
namespace render { namespace render {
EntityRenderer::EntityRenderer(Camera& a_Camera, const game::WorldPtr& a_World) : Renderer(a_Camera), m_World(a_World) { EntityRenderer::EntityRenderer(raylib::Camera& a_Camera, const game::WorldPtr& a_World) : Renderer(a_Camera), m_World(a_World), m_ZombieModel("assets/zombie.glb") {
m_ZombieModel = LoadModel("assets/zombie.glb");
} }
EntityRenderer::~EntityRenderer() { EntityRenderer::~EntityRenderer() {
UnloadModel(m_ZombieModel);
} }
@@ -23,7 +20,7 @@ void EntityRenderer::Render(float a_Lerp) {
float x = Lerp<game::Mob>(*mob, a_Lerp, [](const game::Mob& a_Mob) { return static_cast<float>(a_Mob.m_Position.x); }); float x = Lerp<game::Mob>(*mob, a_Lerp, [](const game::Mob& a_Mob) { return static_cast<float>(a_Mob.m_Position.x); });
float z = Lerp<game::Mob>(*mob, a_Lerp, [](const game::Mob& a_Mob) { return static_cast<float>(a_Mob.m_Position.y); }); float z = Lerp<game::Mob>(*mob, a_Lerp, [](const game::Mob& a_Mob) { return static_cast<float>(a_Mob.m_Position.y); });
DrawModel(m_ZombieModel, {x, .001, z}, 1.0f, {255, 255, 255, 255}); m_ZombieModel.Draw({x, .001, z}, 1.0f, {255, 255, 255, 255});
} }
} }

2
src/td/render/renderer/PlayerListRenderer.cpp
View File

@@ -1,6 +1,6 @@
#include <td/render/renderer/PlayerListRenderer.h> #include <td/render/renderer/PlayerListRenderer.h>
#include <imgui.h> #include <td/render/RayGui.h>
#include <optional> #include <optional>
namespace td { namespace td {

2
src/td/render/renderer/TimerRenderer.cpp
View File

@@ -1,7 +1,7 @@
#include <client/state/GameState.h> #include <client/state/GameState.h>
#include <td/render/renderer/TimerRenderer.h> #include <td/render/renderer/TimerRenderer.h>
#include <imgui.h> #include <td/render/RayGui.h>
namespace td { namespace td {
namespace render { namespace render {

9
src/td/render/renderer/TowerRenderer.cpp
View File

@@ -1,4 +1,3 @@
#include <raylib.h>
#include <td/render/renderer/TowerRenderer.h> #include <td/render/renderer/TowerRenderer.h>
#include <td/render/loader/WorldLoader.h> #include <td/render/loader/WorldLoader.h>
@@ -6,22 +5,18 @@
namespace td { namespace td {
namespace render { namespace render {
TowerRenderer::TowerRenderer(Camera& a_Camera, const game::WorldPtr& a_World) : Renderer(a_Camera), m_World(a_World) { TowerRenderer::TowerRenderer(raylib::Camera& a_Camera, const game::WorldPtr& a_World) : Renderer(a_Camera), m_World(a_World), m_TowerModel("assets/turret.obj"), m_TowerTexture("assets/turret_diffuse.png") {
m_TowerModel = LoadModel("assets/turret.obj");
m_TowerTexture = LoadTexture("assets/turret_diffuse.png");
m_TowerModel.materials[0].maps[MATERIAL_MAP_DIFFUSE].texture = m_TowerTexture; m_TowerModel.materials[0].maps[MATERIAL_MAP_DIFFUSE].texture = m_TowerTexture;
} }
TowerRenderer::~TowerRenderer() { TowerRenderer::~TowerRenderer() {
UnloadModel(m_TowerModel);
UnloadTexture(m_TowerTexture);
} }
void TowerRenderer::Render(float a_Lerp) { void TowerRenderer::Render(float a_Lerp) {
for (const auto& tower : m_World->GetTowers()) { for (const auto& tower : m_World->GetTowers()) {
DrawModel(m_TowerModel, {tower->GetCenterX(), .001, tower->GetCenterY()}, 0.3f, {255, 255, 255, 255}); m_TowerModel.Draw({tower->GetCenterX(), .001, tower->GetCenterY()}, 0.3f, {255, 255, 255, 255});
} }
} }

12
src/td/render/renderer/WorldRenderer.cpp
View File

@@ -1,21 +1,19 @@
#include <raylib.h>
#include <td/Maths.h>
#include <td/render/renderer/WorldRenderer.h> #include <td/render/renderer/WorldRenderer.h>
#include <td/Maths.h>
#include <td/render/loader/WorldLoader.h> #include <td/render/loader/WorldLoader.h>
#include <imgui.h> #include <td/render/RayGui.h>
namespace td { namespace td {
namespace render { namespace render {
WorldRenderer::WorldRenderer(Camera& a_Camera, const game::WorldPtr& a_World) : Renderer(a_Camera) { WorldRenderer::WorldRenderer(raylib::Camera& a_Camera, const game::WorldPtr& a_World) : Renderer(a_Camera) {
Mesh mesh = WorldLoader::LoadWorldModel(a_World.get()); Mesh mesh = WorldLoader::LoadWorldModel(a_World.get());
m_WorldModel = LoadModelFromMesh(mesh); m_WorldModel = std::make_unique<raylib::Model>(mesh);
} }
WorldRenderer::~WorldRenderer() { WorldRenderer::~WorldRenderer() {
UnloadModel(m_WorldModel);
} }
void WorldRenderer::UpdateControls() { void WorldRenderer::UpdateControls() {
@@ -29,7 +27,7 @@ void WorldRenderer::UpdateControls() {
} }
void WorldRenderer::Render(float a_Lerp) { void WorldRenderer::Render(float a_Lerp) {
DrawModel(m_WorldModel, {}, 1.0f, {255, 255, 255, 255}); m_WorldModel->Draw({}, 1.0f, {255, 255, 255, 255});
} }
} // namespace render } // namespace render

5
xmake.lua
View File

@@ -2,8 +2,7 @@ add_rules("mode.debug", "mode.release")
add_repositories("persson-repo https://git.ale-pri.com/Persson-dev/xmake-repo.git") add_repositories("persson-repo https://git.ale-pri.com/Persson-dev/xmake-repo.git")
add_requires("rlimgui") add_requires("rlimgui", "raylib-cpp", "splib 2.3.2", "zlib", "fpm", "enet6")
add_requires("splib 2.3.2", "zlib", "fpm", "enet6")
set_languages("c++20") set_languages("c++20")
@@ -21,7 +20,7 @@ target("Tower-Defense2")
add_includedirs("include", {public = true}) add_includedirs("include", {public = true})
set_kind("binary") set_kind("binary")
add_files("src/**.cpp") add_files("src/**.cpp")
add_packages("raylib", "rlimgui", "splib", "zlib", "fpm", "enet6", {public = true}) add_packages("rlimgui", "raylib-cpp", "splib", "zlib", "fpm", "enet6", {public = true})
set_rundir(".") set_rundir(".")