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

refactor rendering

Browse Source
This commit is contained in:
Simon Pribylski
2025-07-16 13:38:02 +02:00
parent 1bee6aed9c
commit 9667454811
14 changed files with 130 additions and 105 deletions
Download Patch File Download Diff File Expand all files Collapse all files

36
include/td/misc/ObjectNotifier.h
View File

@@ -1,36 +0,0 @@
#pragma once
#include <algorithm>
#include <functional>
#include <vector>
namespace td {
namespace utils {
template <typename Listener>
class ObjectNotifier {
protected:
std::vector<Listener*> m_Listeners;
public:
void BindListener(Listener* listener) {
m_Listeners.push_back(listener);
}
void UnbindListener(Listener* listener) {
auto iter = std::find(m_Listeners.begin(), m_Listeners.end(), listener);
if (iter == m_Listeners.end()) return;
m_Listeners.erase(iter);
}
template <typename Func, typename... Args>
void NotifyListeners(Func function, Args... args) {
for (Listener* listener : m_Listeners)
std::bind(function, listener, args...)();
}
};
} // namespace utils
} // namespace td

31
include/td/misc/Signal.h Normal file
View File

@@ -0,0 +1,31 @@
#pragma once
#include <algorithm>
#include <functional>
#include <td/common/NonCopyable.h>
#include <vector>
namespace td {
namespace utils {
template <typename... Args>
class Signal : private NonCopyable {
private:
using CallBack = std::function<void(Args...)>;
std::vector<CallBack> m_Callbacks;
public:
void Connect(CallBack&& a_Callback) {
m_Callbacks.push_back(std::move(a_Callback));
}
void operator()(Args... args) const {
for (const CallBack& callback : m_Callbacks) {
callback(args...);
}
}
};
} // namespace utils
} // namespace td

15
include/td/render/Camera.h
View File

@@ -1,20 +1,12 @@
#pragma once
#include <td/Maths.h>
#include <td/misc/ObjectNotifier.h>
#include <td/misc/Signal.h>
namespace td {
namespace render {
class ICameraListener {
public:
virtual void OnPerspectiveChange() {}
virtual void OnViewChange() {}
};
using CameraNotifier = utils::ObjectNotifier<ICameraListener>;
class Camera : public CameraNotifier {
class Camera {
private:
Mat4f m_ViewMatrix;
Mat4f m_ProjectionMatrix;
@@ -29,6 +21,9 @@ class Camera : public CameraNotifier {
float m_Pitch = -PI / 2.0f + 0.0000001f;
public:
utils::Signal<> OnPerspectiveChange;
utils::Signal<> OnViewChange;
const Mat4f& GetViewMatrix() const {
return m_ViewMatrix;
}

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

@@ -1,35 +1,42 @@
#pragma once
#include <memory>
#include <td/render/Camera.h>
#include <td/render/loader/GLLoader.h>
#include <memory>
#include <td/render/shader/CameraShaderProgram.h>
namespace td {
namespace render {
class Renderer {
protected:
Camera& m_Camera;
class BasicRenderer {
public:
Renderer(Camera& a_Camera) : m_Camera(a_Camera) {}
virtual ~Renderer() {}
virtual void Render() = 0;
void Render(const GL::VertexArray& a_Vao);
};
class Renderer : public BasicRenderer {
protected:
std::unique_ptr<shader::CameraShaderProgram> m_Shader;
Camera& m_Camera;
public:
Renderer(std::unique_ptr<shader::CameraShaderProgram>&& a_Shader, Camera& a_Camera);
virtual ~Renderer() {}
};
class RenderPipeline {
private:
std::vector<std::unique_ptr<Renderer>> m_Renderers;
std::vector<std::unique_ptr<BasicRenderer>> m_Renderers;
public:
RenderPipeline();
~RenderPipeline() = default;
void AddRenderer(std::unique_ptr<Renderer>&& a_Renderer) {
m_Renderers.push_back(std::move(a_Renderer));
template<typename T, typename... Args>
void AddRenderer(Args&&... args) {
m_Renderers.push_back(std::make_unique<T>(args ...));
}
void Clear() {

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

@@ -2,16 +2,15 @@
#include <td/game/World.h>
#include <td/render/Renderer.h>
#include <td/render/shader/WorldShader.h>
#include <td/render/loader/GLLoader.h>
#include <td/render/shader/WorldShader.h>
namespace td {
namespace render {
class WorldRenderer : public Renderer, public ICameraListener {
class WorldRenderer : public Renderer {
private:
const game::World& m_World;
shader::WorldShader m_Shader;
std::unique_ptr<GL::VertexArray> m_WorldVao;
public:
@@ -19,9 +18,6 @@ class WorldRenderer : public Renderer, public ICameraListener {
virtual ~WorldRenderer();
virtual void Render() override;
virtual void OnPerspectiveChange() override;
virtual void OnViewChange() override;
};
} // namespace render

23
include/td/render/shader/CameraShaderProgram.h Normal file
View File

@@ -0,0 +1,23 @@
#pragma once
#include <td/render/shader/ShaderProgram.h>
namespace td {
namespace shader {
class CameraShaderProgram : public ShaderProgram {
private:
unsigned int m_LocationProjection = 0, m_LocationView = 0;
public:
CameraShaderProgram() {}
void SetProjectionMatrix(const Mat4f& proj) const;
void SetViewMatrix(const Mat4f& view) const;
virtual void GetAllUniformLocation();
};
} // namespace shader
} // namespace td

9
include/td/render/shader/ShaderProgram.h
View File

@@ -1,10 +1,15 @@
#pragma once
#include <string>
#include <td/Maths.h>
#include <td/render/OpenGL.h>
#include <string>
namespace td {
namespace render {
class Renderer;
} // namespace render
namespace shader {
class ShaderProgram {
@@ -15,10 +20,10 @@ class ShaderProgram {
void Start() const;
void Stop() const;
protected:
void LoadProgramFile(const std::string& vertexFile, const std::string& fragmentFile);
void LoadProgram(const std::string& vertexSource, const std::string& fragmentSource);
protected:
virtual void GetAllUniformLocation() = 0;
int GetUniformLocation(const std::string& uniformName) const;

11
include/td/render/shader/WorldShader.h
View File

@@ -1,20 +1,13 @@
#pragma once
#include <td/render/shader/ShaderProgram.h>
#include <td/render/shader/CameraShaderProgram.h>
namespace td {
namespace shader {
class WorldShader : public ShaderProgram {
private:
unsigned int m_LocationProjection = 0, m_LocationView = 0;
protected:
void GetAllUniformLocation();
class WorldShader : public CameraShaderProgram {
public:
WorldShader();
void SetProjectionMatrix(const Mat4f& proj) const;
void SetViewMatrix(const Mat4f& view) const;
};
} // namespace shader

2
src/main.cpp
View File

@@ -196,7 +196,7 @@ int main(int argc, char** argv) {
td::render::Camera cam;
td::render::RenderPipeline renderer;
renderer.AddRenderer(std::make_unique<td::render::WorldRenderer>(cam, w));
renderer.AddRenderer<td::render::WorldRenderer>(cam, w);
cam.SetCamPos({77, 25, 13});
cam.UpdatePerspective(display.GetAspectRatio());

4
src/td/render/Camera.cpp
View File

@@ -8,7 +8,7 @@ namespace render {
void Camera::UpdatePerspective(float a_AspectRatio) {
m_ProjectionMatrix = maths::Perspective(80.0f / 180.0f * PI, a_AspectRatio, 0.1f, 160.0f);
m_InvProjectionMatrix = maths::Inverse(m_ProjectionMatrix);
NotifyListeners(&ICameraListener::OnPerspectiveChange);
OnPerspectiveChange();
}
void Camera::SetCamPos(const Vec3f& a_NewPos) {
@@ -21,7 +21,7 @@ void Camera::SetCamPos(const Vec3f& a_NewPos) {
m_CamPos = a_NewPos;
m_ViewMatrix = maths::Look(m_CamPos, front, { 0, 1, 0 });
m_InvViewMatrix = maths::Transpose(maths::Inverse(m_ViewMatrix)); // why transpose ? I don't know
NotifyListeners(&ICameraListener::OnViewChange);
OnViewChange();
}
} // namespace render

16
src/td/render/Renderer.cpp
View File

@@ -5,13 +5,27 @@
namespace td {
namespace render {
void Renderer::Render(const GL::VertexArray& a_Vao) {
void BasicRenderer::Render(const GL::VertexArray& a_Vao) {
a_Vao.Bind();
glDrawArrays(GL_TRIANGLES, 0, a_Vao.GetVertexCount());
// glDrawElements(GL_TRIANGLES, a_Vao.GetVertexCount(), GL_UNSIGNED_INT, nullptr);
a_Vao.Unbind();
}
Renderer::Renderer(std::unique_ptr<shader::CameraShaderProgram>&& a_Shader, Camera& a_Camera) :
m_Shader(std::move(a_Shader)), m_Camera(a_Camera) {
a_Camera.OnPerspectiveChange.Connect([this]() {
m_Shader->Start();
m_Shader->SetProjectionMatrix(m_Camera.GetProjectionMatrix());
});
a_Camera.OnViewChange.Connect([this]() {
m_Shader->Start();
m_Shader->SetViewMatrix(m_Camera.GetViewMatrix());
});
}
RenderPipeline::RenderPipeline() {
glEnable(GL_TEXTURE_2D);
glEnable(GL_BLEND);

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

@@ -7,28 +7,17 @@
namespace td {
namespace render {
WorldRenderer::WorldRenderer(Camera& a_Camera, const game::World& a_World) : Renderer(a_Camera), m_World(a_World) {
WorldRenderer::WorldRenderer(Camera& a_Camera, const game::World& a_World) : Renderer(std::make_unique<shader::WorldShader>(), a_Camera), m_World(a_World) {
m_WorldVao = std::make_unique<GL::VertexArray>(std::move(WorldLoader::LoadWorldModel(&a_World)));
a_Camera.BindListener(this);
}
WorldRenderer::~WorldRenderer() {}
void WorldRenderer::Render() {
m_Shader.Start();
m_Shader->Start();
Renderer::Render(*m_WorldVao);
ImGui::ShowDemoWindow();
}
void WorldRenderer::OnPerspectiveChange() {
m_Shader.Start();
m_Shader.SetProjectionMatrix(m_Camera.GetProjectionMatrix());
}
void WorldRenderer::OnViewChange() {
m_Shader.Start();
m_Shader.SetViewMatrix(m_Camera.GetViewMatrix());
}
} // namespace render
} // namespace td

21
src/td/render/shader/CameraShaderProgram.cpp Normal file
View File

@@ -0,0 +1,21 @@
#include <td/render/shader/CameraShaderProgram.h>
namespace td {
namespace shader {
void CameraShaderProgram::SetProjectionMatrix(const Mat4f& proj) const {
LoadMat4(m_LocationProjection, proj);
}
void CameraShaderProgram::SetViewMatrix(const Mat4f& view) const {
LoadMat4(m_LocationView, view);
}
void CameraShaderProgram::GetAllUniformLocation() {
m_LocationProjection = static_cast<unsigned int>(GetUniformLocation("projectionMatrix"));
m_LocationView = static_cast<unsigned int>(GetUniformLocation("viewMatrix"));
}
} // namespace shader
} // namespace td

15
src/td/render/shader/WorldShader.cpp
View File

@@ -81,22 +81,9 @@ void main(void){
)";
#endif
WorldShader::WorldShader() : ShaderProgram() {
WorldShader::WorldShader() : CameraShaderProgram() {
ShaderProgram::LoadProgram(vertexSource, fragmentSource);
}
void WorldShader::GetAllUniformLocation() {
m_LocationProjection = static_cast<unsigned int>(GetUniformLocation("projectionMatrix"));
m_LocationView = static_cast<unsigned int>(GetUniformLocation("viewMatrix"));
}
void WorldShader::SetProjectionMatrix(const Mat4f& proj) const {
LoadMat4(m_LocationProjection, proj);
}
void WorldShader::SetViewMatrix(const Mat4f& view) const {
LoadMat4(m_LocationView, view);
}
} // namespace shader
} // namespace td