From acc9d798cb9fe5914f557b2e5174b324495ad17b Mon Sep 17 00:00:00 2001 From: Dominic Masters Date: Wed, 19 Oct 2022 19:44:47 -0700 Subject: [PATCH] Fixed all my pointers --- src/dawn/CMakeLists.txt | 1 + src/dawn/display/CMakeLists.txt | 10 ++++ src/dawn/display/RenderPipeline.cpp | 26 +++++++++ src/dawn/display/RenderPipeline.hpp | 24 ++++++++ src/dawn/display/_RenderManager.hpp | 19 ++++++- src/dawn/display/mesh/TriangleMesh.hpp | 2 +- src/dawn/game/DawnGame.hpp | 14 ++--- src/dawn/host/DawnHost.hpp | 12 ++-- src/dawn/scene/Scene.cpp | 5 +- src/dawn/scene/Scene.hpp | 33 ++++++++--- src/dawn/scene/SceneItem.cpp | 6 +- src/dawn/scene/SceneItem.hpp | 10 ++-- src/dawn/scene/SceneItemComponent.cpp | 11 ++-- src/dawn/scene/SceneItemComponent.hpp | 8 +-- src/dawn/scene/components/DummyComponent.hpp | 4 +- src/dawn/scene/components/display/Camera.cpp | 15 ++--- src/dawn/scene/components/display/Camera.hpp | 4 +- .../scene/components/display/MeshRenderer.cpp | 2 +- .../scene/components/display/MeshRenderer.hpp | 2 +- src/dawnglfw/host/DawnGLFWHost.cpp | 46 +++++++--------- src/dawnglfw/host/DawnGLFWHost.hpp | 3 - .../display/BackBufferRenderTarget.cpp | 7 +-- .../display/BackBufferRenderTarget.hpp | 9 +-- src/dawnopengl/display/CMakeLists.txt | 1 + src/dawnopengl/display/RenderManager.cpp | 25 +++++---- src/dawnopengl/display/RenderManager.hpp | 22 ++++---- .../display/StandardRenderPipeline.cpp | 55 +++++++++++++++++++ .../display/StandardRenderPipeline.hpp | 18 ++++++ src/dawnopengl/display/mesh/TriangleMesh.cpp | 10 ++-- src/dawnpokergame/game/DawnPokerGame.cpp | 18 ++---- src/dawnwin32/host/DawnHostWin32.cpp | 8 +-- 31 files changed, 289 insertions(+), 141 deletions(-) create mode 100644 src/dawn/display/CMakeLists.txt create mode 100644 src/dawn/display/RenderPipeline.cpp create mode 100644 src/dawn/display/RenderPipeline.hpp create mode 100644 src/dawnopengl/display/StandardRenderPipeline.cpp create mode 100644 src/dawnopengl/display/StandardRenderPipeline.hpp diff --git a/src/dawn/CMakeLists.txt b/src/dawn/CMakeLists.txt index 552e57b5..69bf7cab 100644 --- a/src/dawn/CMakeLists.txt +++ b/src/dawn/CMakeLists.txt @@ -16,4 +16,5 @@ target_include_directories(${DAWN_TARGET_NAME} ) # Subdirs +add_subdirectory(display) add_subdirectory(scene) \ No newline at end of file diff --git a/src/dawn/display/CMakeLists.txt b/src/dawn/display/CMakeLists.txt new file mode 100644 index 00000000..cbd492b6 --- /dev/null +++ b/src/dawn/display/CMakeLists.txt @@ -0,0 +1,10 @@ +# Copyright (c) 2022 Dominic Masters +# +# This software is released under the MIT License. +# https://opensource.org/licenses/MIT + +# Sources +target_sources(${DAWN_TARGET_NAME} + PRIVATE + RenderPipeline.cpp +) \ No newline at end of file diff --git a/src/dawn/display/RenderPipeline.cpp b/src/dawn/display/RenderPipeline.cpp new file mode 100644 index 00000000..aba318a9 --- /dev/null +++ b/src/dawn/display/RenderPipeline.cpp @@ -0,0 +1,26 @@ +// Copyright (c) 2022 Dominic Masters +// +// This software is released under the MIT License. +// https://opensource.org/licenses/MIT + +#include "RenderPipeline.hpp" +#include "game/DawnGame.hpp" + +using namespace Dawn; + +RenderPipeline::RenderPipeline(RenderManager &renderManager) : + renderManager(renderManager) +{ +} + +void RenderPipeline::init() { + +} + +void RenderPipeline::render() { + this->renderScene(*this->renderManager.game.scene); +} + +RenderPipeline::~RenderPipeline() { + +} \ No newline at end of file diff --git a/src/dawn/display/RenderPipeline.hpp b/src/dawn/display/RenderPipeline.hpp new file mode 100644 index 00000000..423ee967 --- /dev/null +++ b/src/dawn/display/RenderPipeline.hpp @@ -0,0 +1,24 @@ +// Copyright (c) 2022 Dominic Masters +// +// This software is released under the MIT License. +// https://opensource.org/licenses/MIT + +#pragma once +#include "dawnlibs.hpp" +#include "display/RenderManager.hpp" +#include "scene/Scene.hpp" +#include "scene/components/Components.hpp" + +namespace Dawn { + class RenderPipeline { + public: + RenderManager &renderManager; + + RenderPipeline(RenderManager &renderManager); + virtual void init(); + void render(); + virtual void renderScene(Scene &scene) = 0; + virtual void renderSceneCamera(Scene &scene, Camera &camera) = 0; + virtual ~RenderPipeline(); + }; +} \ No newline at end of file diff --git a/src/dawn/display/_RenderManager.hpp b/src/dawn/display/_RenderManager.hpp index 8b95a66a..23bac126 100644 --- a/src/dawn/display/_RenderManager.hpp +++ b/src/dawn/display/_RenderManager.hpp @@ -8,10 +8,19 @@ namespace Dawn { class DawnGame; + class RenderPipeline; class IRenderManager { public: - std::weak_ptr game; + DawnGame &game; + std::shared_ptr renderPipeline; + + /** + * Default constructor for a render manager instance. + * + * @param game Game that this render manager belongs to. + */ + IRenderManager(DawnGame &game) : game(game) {} /** * Returns the primary render target (the backbuffer) that draws directly @@ -19,10 +28,14 @@ namespace Dawn { * * @return Shared pointer to the backbuffer render target. */ - virtual std::shared_ptr getBackBuffer() = 0; + virtual RenderTarget & getBackBuffer() = 0; + + virtual RenderPipeline & getRenderPipeline() = 0; /** - * Initialize this render manager. + * Initialize / Start the Render Manager. + * + * @param game Game instance this render manager belongs to. */ virtual void init() = 0; diff --git a/src/dawn/display/mesh/TriangleMesh.hpp b/src/dawn/display/mesh/TriangleMesh.hpp index dc94703c..4b0bf2cf 100644 --- a/src/dawn/display/mesh/TriangleMesh.hpp +++ b/src/dawn/display/mesh/TriangleMesh.hpp @@ -14,6 +14,6 @@ namespace Dawn { * * @param mesh Mesh to initialize as a triangle. */ - static void createTriangleMesh(std::shared_ptr mesh); + static void createTriangleMesh(Mesh &mesh); }; } \ No newline at end of file diff --git a/src/dawn/game/DawnGame.hpp b/src/dawn/game/DawnGame.hpp index 5f901a23..85ec456d 100644 --- a/src/dawn/game/DawnGame.hpp +++ b/src/dawn/game/DawnGame.hpp @@ -15,22 +15,17 @@ namespace Dawn { class DawnHost; - class DawnGame : - public std::enable_shared_from_this - { - private: - std::shared_ptr scene; - + class DawnGame { public: - std::weak_ptr host; + std::shared_ptr scene; + DawnHost &host; RenderManager renderManager; /** * Construct a new instance of the DawnGame. * - * @param host Weak pointer to the host that is running this game. */ - DawnGame(std::weak_ptr host); + DawnGame(DawnHost &host); /** * Initialize the game. This is performed by the host at a time that is @@ -38,6 +33,7 @@ namespace Dawn { * return an initialize result, where DAWN_GAME_INIT_RESULT_SUCCESS is * the only "successful" result, anything else is deemed a failure state. * + * @param host Pointer to the host that is running this game. * @return The game initialize result. */ int32_t init(); diff --git a/src/dawn/host/DawnHost.hpp b/src/dawn/host/DawnHost.hpp index 639e94a8..c21c789e 100644 --- a/src/dawn/host/DawnHost.hpp +++ b/src/dawn/host/DawnHost.hpp @@ -29,7 +29,9 @@ namespace Dawn { */ class DawnHostData; - class DawnHost { + class DawnHost : + public std::enable_shared_from_this + { public: std::unique_ptr data; @@ -49,7 +51,7 @@ namespace Dawn { * @param game Game instance that this host is running for. * @return A status code, where DAWN_HOST_INIT_RESULT_SUCCESS is success. */ - int32_t init(std::weak_ptr game); + int32_t init(DawnGame &game); /** * Request to start the main loop. This method may not exist and may not @@ -61,7 +63,7 @@ namespace Dawn { * @param game Game instance that this host is running for. * @return A status code, refer to DAWN_HOST_START_RESULT_{} definitions. */ - virtual int32_t start(std::weak_ptr game); + virtual int32_t start(DawnGame &game); /** * Requests the host to perform a main-thread update. @@ -70,7 +72,7 @@ namespace Dawn { * @param delta How much time has passed (in seconds) since the last tick. * @return A status code, refer to DAWN_HOST_UPDATE_RESULT_{} definitions. */ - int32_t update(std::weak_ptr game, float_t delta); + int32_t update(DawnGame &game, float_t delta); /** * Request the host to be unloaded. This is a bit different from dispose @@ -79,7 +81,7 @@ namespace Dawn { * * @param game Game instance that this host is running for. */ - void unload(std::weak_ptr game); + void unload(DawnGame &game); /** * Destroy (and unload) all of the DawnHost data from memory. diff --git a/src/dawn/scene/Scene.cpp b/src/dawn/scene/Scene.cpp index 3ceaeaf4..9b52ab16 100644 --- a/src/dawn/scene/Scene.cpp +++ b/src/dawn/scene/Scene.cpp @@ -8,8 +8,7 @@ using namespace Dawn; -Scene::Scene(std::weak_ptr game) { - this->game = game; +Scene::Scene(DawnGame &game) : game(game) { this->nextId = 0; } @@ -30,7 +29,7 @@ void Scene::update() { std::shared_ptr Scene::createSceneItem() { sceneitemid_t id = this->nextId++; - auto item = std::make_shared(weak_from_this(), id); + auto item = std::make_shared(*this, id); this->itemsNotInitialized[id] = item; return item; } diff --git a/src/dawn/scene/Scene.hpp b/src/dawn/scene/Scene.hpp index 44a05344..d28703d3 100644 --- a/src/dawn/scene/Scene.hpp +++ b/src/dawn/scene/Scene.hpp @@ -9,23 +9,21 @@ namespace Dawn { class DawnGame; - class Scene : - public std::enable_shared_from_this - { + class Scene { private: sceneitemid_t nextId; - std::map> items; - std::map> itemsNotInitialized; + std::map> items; + std::map> itemsNotInitialized; public: - std::weak_ptr game; + DawnGame &game; /** * Construct a new Scene instance. * - * @param game Weak pointer to the game that this scene belongs to. + * @param game Reference to the game that this scene belongs to. */ - Scene(std::weak_ptr game); + Scene(DawnGame &game); /** * Perform a one frame synchronous tick on the current scene. This may @@ -59,6 +57,25 @@ namespace Dawn { return nullptr; } + /** + * Finds all exisitng components on the scene (Root Level Only) that has a + * matching component of the given component type. + * + * @tparam Component type to look for. + * @return List of matching compnoents. + */ + template + std::vector> findComponents() { + std::vector> components; + auto it = this->items.begin(); + while(it != this->items.end()) { + auto component = it->second->getComponent(); + if(component != nullptr) components.push_back(component); + ++it; + } + return components; + } + /** * Destroys a previously initialized Scene. */ diff --git a/src/dawn/scene/SceneItem.cpp b/src/dawn/scene/SceneItem.cpp index f6453618..dbbe555f 100644 --- a/src/dawn/scene/SceneItem.cpp +++ b/src/dawn/scene/SceneItem.cpp @@ -8,8 +8,10 @@ using namespace Dawn; -SceneItem::SceneItem(std::weak_ptr, sceneitemid_t id) { - this->scene = scene; +SceneItem::SceneItem(Scene &scene, sceneitemid_t id) : + scene(scene), + id(id) +{ this->id = id; } diff --git a/src/dawn/scene/SceneItem.hpp b/src/dawn/scene/SceneItem.hpp index 199eb56e..4499e852 100644 --- a/src/dawn/scene/SceneItem.hpp +++ b/src/dawn/scene/SceneItem.hpp @@ -11,14 +11,12 @@ namespace Dawn { class Scene; - class SceneItem : - public std::enable_shared_from_this - { + class SceneItem { private: std::vector> components; public: - std::weak_ptr scene; + Scene &scene; sceneitemid_t id; /** @@ -28,7 +26,7 @@ namespace Dawn { * @param scene Weak pointer to the Scene that this SceneItem belongs to. * @param id Scene Item ID that the Scene assigned this SceneItem. */ - SceneItem(std::weak_ptr scene, sceneitemid_t id); + SceneItem(Scene &scene, sceneitemid_t id); /** * Called by the Scene the frame after we were constructed so we can begin @@ -48,7 +46,7 @@ namespace Dawn { */ template std::shared_ptr addComponent() { - auto component = std::make_shared(weak_from_this()); + auto component = std::make_shared(*this); this->components.push_back(component); return component; } diff --git a/src/dawn/scene/SceneItemComponent.cpp b/src/dawn/scene/SceneItemComponent.cpp index d8cf952d..9fc4f74b 100644 --- a/src/dawn/scene/SceneItemComponent.cpp +++ b/src/dawn/scene/SceneItemComponent.cpp @@ -10,16 +10,15 @@ using namespace Dawn; -SceneItemComponent::SceneItemComponent(std::weak_ptr item) { - this->item = item; +SceneItemComponent::SceneItemComponent(SceneItem &item) : item(item) { } -std::shared_ptr SceneItemComponent::getScene() { - return this->item.lock()->scene.lock(); +Scene & SceneItemComponent::getScene() { + return this->item.scene; } -std::shared_ptr SceneItemComponent::getGame() { - return this->item.lock()->scene.lock()->game.lock(); +DawnGame & SceneItemComponent::getGame() { + return this->item.scene.game; } SceneItemComponent::~SceneItemComponent() { diff --git a/src/dawn/scene/SceneItemComponent.hpp b/src/dawn/scene/SceneItemComponent.hpp index c7587a97..0a1aa723 100644 --- a/src/dawn/scene/SceneItemComponent.hpp +++ b/src/dawn/scene/SceneItemComponent.hpp @@ -13,14 +13,14 @@ namespace Dawn { class SceneItemComponent { public: - std::weak_ptr item; + SceneItem &item; - SceneItemComponent(std::weak_ptr item); + SceneItemComponent(SceneItem &item); virtual void start() = 0; - std::shared_ptr getScene(); - std::shared_ptr getGame(); + Scene & getScene(); + DawnGame & getGame(); virtual ~SceneItemComponent(); }; diff --git a/src/dawn/scene/components/DummyComponent.hpp b/src/dawn/scene/components/DummyComponent.hpp index 98f55b8a..8f6eb64a 100644 --- a/src/dawn/scene/components/DummyComponent.hpp +++ b/src/dawn/scene/components/DummyComponent.hpp @@ -9,7 +9,9 @@ namespace Dawn { class DummyComponent : public SceneItemComponent { public: - DummyComponent(std::weak_ptr item) : SceneItemComponent(item) { + DummyComponent(SceneItem &item) : + SceneItemComponent(item) + { std::cout << "Dummy Component Initialized" << std::endl; }; diff --git a/src/dawn/scene/components/display/Camera.cpp b/src/dawn/scene/components/display/Camera.cpp index 3fa5684c..7fd9828c 100644 --- a/src/dawn/scene/components/display/Camera.cpp +++ b/src/dawn/scene/components/display/Camera.cpp @@ -9,7 +9,9 @@ using namespace Dawn; -Camera::Camera(std::weak_ptr item) : SceneItemComponent(item) { +Camera::Camera(SceneItem &item) : + SceneItemComponent(item) +{ } void Camera::updateProjection() { @@ -36,17 +38,16 @@ void Camera::updateProjection() { } } -std::shared_ptr Camera::getRenderTarget() { +RenderTarget & Camera::getRenderTarget() { if(this->target == nullptr) { - return this->getGame()->renderManager.getBackBuffer(); + return this->getGame().renderManager.getBackBuffer(); } - - return this->target; + return *this->target; } float_t Camera::getAspect() { - auto target = this->getRenderTarget(); - return target->getWidth() / target->getHeight(); + RenderTarget &target = this->getRenderTarget(); + return target.getWidth() / target.getHeight(); } void Camera::start() { diff --git a/src/dawn/scene/components/display/Camera.hpp b/src/dawn/scene/components/display/Camera.hpp index 0ffad9e9..6513a0ad 100644 --- a/src/dawn/scene/components/display/Camera.hpp +++ b/src/dawn/scene/components/display/Camera.hpp @@ -37,14 +37,14 @@ namespace Dawn { * * @param item SceneItem that this component belongs to. */ - Camera(std::weak_ptr item); + Camera(SceneItem &item); /** * Updates the projection matrix. */ void updateProjection(); - std::shared_ptr getRenderTarget(); + RenderTarget & getRenderTarget(); /** * Returs the aspect ratio of the camera. diff --git a/src/dawn/scene/components/display/MeshRenderer.cpp b/src/dawn/scene/components/display/MeshRenderer.cpp index 0905104f..af72d9ff 100644 --- a/src/dawn/scene/components/display/MeshRenderer.cpp +++ b/src/dawn/scene/components/display/MeshRenderer.cpp @@ -7,7 +7,7 @@ using namespace Dawn; -MeshRenderer::MeshRenderer(std::weak_ptr item) : +MeshRenderer::MeshRenderer(SceneItem &item) : SceneItemComponent(item) { diff --git a/src/dawn/scene/components/display/MeshRenderer.hpp b/src/dawn/scene/components/display/MeshRenderer.hpp index 24a879ee..47792062 100644 --- a/src/dawn/scene/components/display/MeshRenderer.hpp +++ b/src/dawn/scene/components/display/MeshRenderer.hpp @@ -12,7 +12,7 @@ namespace Dawn { public: std::shared_ptr mesh = nullptr; - MeshRenderer(std::weak_ptr item); + MeshRenderer(SceneItem &item); void start() override; }; diff --git a/src/dawnglfw/host/DawnGLFWHost.cpp b/src/dawnglfw/host/DawnGLFWHost.cpp index 1ad63329..55ef8c76 100644 --- a/src/dawnglfw/host/DawnGLFWHost.cpp +++ b/src/dawnglfw/host/DawnGLFWHost.cpp @@ -25,7 +25,7 @@ DawnHost::DawnHost() { this->data->window = nullptr; } -int32_t DawnHost::init(std::weak_ptr game) { +int32_t DawnHost::init(DawnGame &game) { // Init GLFW if(!glfwInit()) return DAWN_GLFW_INIT_RESULT_INIT_FAILED; @@ -51,22 +51,18 @@ int32_t DawnHost::init(std::weak_ptr game) { gladLoadGLLoader((GLADloadproc)glfwGetProcAddress); // Initialize the game - if(auto g = game.lock()) { - auto result = g->init(); - if(result != DAWN_GAME_INIT_RESULT_SUCCESS) return result; + auto result = game.init(); + if(result != DAWN_GAME_INIT_RESULT_SUCCESS) return result; - g->renderManager.renderTarget->setSize( - DAWN_GLFW_WINDOW_WIDTH_DEFAULT, - DAWN_GLFW_WINDOW_HEIGHT_DEFAULT - ); - } else { - return DAWN_GLFW_INIT_RESULT_GAME_LOCK_FAILED; - } + game.renderManager.backBuffer.setSize( + DAWN_GLFW_WINDOW_WIDTH_DEFAULT, + DAWN_GLFW_WINDOW_HEIGHT_DEFAULT + ); return DAWN_HOST_INIT_RESULT_SUCCESS; } -int32_t DawnHost::start(std::weak_ptr game) { +int32_t DawnHost::start(DawnGame &game) { double_t time, newTime; float_t fDelta; int32_t updateResult; @@ -99,25 +95,21 @@ int32_t DawnHost::start(std::weak_ptr game) { return DAWN_HOST_START_RESULT_EXIT_SUCCESS; } -int32_t DawnHost::update(std::weak_ptr game, float_t delta) { - if(auto g = game.lock()) { - auto ret = g->update(delta); - switch(ret) { - case DAWN_GAME_UPDATE_RESULT_SUCCESS: - return DAWN_HOST_UPDATE_RESULT_SUCCESS; - - case DAWN_GAME_UPDATE_RESULT_EXIT: - return DAWN_HOST_UPDATE_RESULT_EXIT; +int32_t DawnHost::update(DawnGame &game, float_t delta) { + auto ret = game.update(delta); + switch(ret) { + case DAWN_GAME_UPDATE_RESULT_SUCCESS: + return DAWN_HOST_UPDATE_RESULT_SUCCESS; + + case DAWN_GAME_UPDATE_RESULT_EXIT: + return DAWN_HOST_UPDATE_RESULT_EXIT; - default: - return ret; - } + default: + return ret; } - - return DAWN_GLFW_UPDATE_RESULT_GAME_LOCK_FAILED; } -void DawnHost::unload(std::weak_ptr game) { +void DawnHost::unload(DawnGame &game) { glfwDestroyWindow(this->data->window); this->data->window = nullptr; glfwTerminate(); diff --git a/src/dawnglfw/host/DawnGLFWHost.hpp b/src/dawnglfw/host/DawnGLFWHost.hpp index cc8f2602..da8c4209 100644 --- a/src/dawnglfw/host/DawnGLFWHost.hpp +++ b/src/dawnglfw/host/DawnGLFWHost.hpp @@ -14,12 +14,9 @@ #define DAWN_GLFW_INIT_RESULT_INIT_FAILED -1 #define DAWN_GLFW_INIT_RESULT_WINDOW_CREATE_FAILED -2 -#define DAWN_GLFW_INIT_RESULT_GAME_LOCK_FAILED -3 #define DAWN_GLFW_START_RESULT_UPDATE_FAILED -1 -#define DAWN_GLFW_UPDATE_RESULT_GAME_LOCK_FAILED -1 - namespace Dawn { class DawnHostData { public: diff --git a/src/dawnopengl/display/BackBufferRenderTarget.cpp b/src/dawnopengl/display/BackBufferRenderTarget.cpp index 6fb5b4be..298c5891 100644 --- a/src/dawnopengl/display/BackBufferRenderTarget.cpp +++ b/src/dawnopengl/display/BackBufferRenderTarget.cpp @@ -7,10 +7,9 @@ using namespace Dawn; -BackBufferRenderTarget::BackBufferRenderTarget( - std::weak_ptr renderManager -) { - this->renderManager = renderManager; +BackBufferRenderTarget::BackBufferRenderTarget(RenderManager &renderManager) : + renderManager(renderManager) +{ } float_t BackBufferRenderTarget::getWidth() { diff --git a/src/dawnopengl/display/BackBufferRenderTarget.hpp b/src/dawnopengl/display/BackBufferRenderTarget.hpp index b0c23cef..d3e28f7e 100644 --- a/src/dawnopengl/display/BackBufferRenderTarget.hpp +++ b/src/dawnopengl/display/BackBufferRenderTarget.hpp @@ -6,18 +6,19 @@ #pragma once #include "dawnopengl.hpp" #include "display/RenderTarget.hpp" -#include "display/RenderManager.hpp" namespace Dawn { + class RenderManager; + class BackBufferRenderTarget : public RenderTarget { private: - std::weak_ptr renderManager; + RenderManager &renderManager; float_t width = 1; - float_t height = 1; + float_t height = 1; struct Color clearColor = COLOR_CORNFLOWER_BLUE; public: - BackBufferRenderTarget(std::weak_ptr renderManager); + BackBufferRenderTarget(RenderManager &renderManager); float_t getWidth() override; float_t getHeight() override; diff --git a/src/dawnopengl/display/CMakeLists.txt b/src/dawnopengl/display/CMakeLists.txt index 6b7df8f7..65aef970 100644 --- a/src/dawnopengl/display/CMakeLists.txt +++ b/src/dawnopengl/display/CMakeLists.txt @@ -8,6 +8,7 @@ target_sources(${DAWN_TARGET_NAME} PRIVATE RenderManager.cpp BackBufferRenderTarget.cpp + StandardRenderPipeline.cpp ) # Subdirs diff --git a/src/dawnopengl/display/RenderManager.cpp b/src/dawnopengl/display/RenderManager.cpp index 60a98c36..79ec7699 100644 --- a/src/dawnopengl/display/RenderManager.cpp +++ b/src/dawnopengl/display/RenderManager.cpp @@ -6,28 +6,31 @@ #include "dawnopengl.hpp" #include "game/DawnGame.hpp" #include "display/RenderManager.hpp" -#include "display/BackBufferRenderTarget.hpp" +#include "display/StandardRenderPipeline.hpp" using namespace Dawn; -RenderManager::RenderManager(std::weak_ptr game) { - this->game = game; - this->renderTarget=std::make_shared(weak_from_this()); +RenderManager::RenderManager(DawnGame &game) : + IRenderManager(game), + backBuffer(*this) +{ + this->standardRenderPipeline=std::make_shared(*this); } void RenderManager::init() { + this->standardRenderPipeline->init(); } -std::shared_ptr RenderManager::getBackBuffer() { - return this->renderTarget; +RenderTarget & RenderManager::getBackBuffer() { + return this->backBuffer; +} + +RenderPipeline & RenderManager::getRenderPipeline() { + return *this->standardRenderPipeline; } void RenderManager::update() { - this->getBackBuffer()->bind(); - this->getBackBuffer()->clear( - RENDER_TARGET_CLEAR_FLAG_COLOR | - RENDER_TARGET_CLEAR_FLAG_DEPTH - ); + this->getRenderPipeline().render(); } RenderManager::~RenderManager() { diff --git a/src/dawnopengl/display/RenderManager.hpp b/src/dawnopengl/display/RenderManager.hpp index 61e41772..4be522e9 100644 --- a/src/dawnopengl/display/RenderManager.hpp +++ b/src/dawnopengl/display/RenderManager.hpp @@ -5,26 +5,24 @@ #pragma once #include "display/_RenderManager.hpp" +#include "display/BackBufferRenderTarget.hpp" namespace Dawn { - class BackBufferRenderTarget; + class StandardRenderPipeline; - class RenderManager : - public IRenderManager, - public std::enable_shared_from_this - { + class RenderManager : public IRenderManager { + private: + std::shared_ptr standardRenderPipeline; public: - std::shared_ptr renderTarget; - + BackBufferRenderTarget backBuffer; + /** * Construct a new RenderManager for a game instance. - * - * @param game Game instance this render manager belongs to. */ - RenderManager(std::weak_ptr game); - - std::shared_ptr getBackBuffer() override; + RenderManager(DawnGame &game); + RenderTarget & getBackBuffer() override; + RenderPipeline & getRenderPipeline() override; void init() override; void update() override; diff --git a/src/dawnopengl/display/StandardRenderPipeline.cpp b/src/dawnopengl/display/StandardRenderPipeline.cpp new file mode 100644 index 00000000..7ac24997 --- /dev/null +++ b/src/dawnopengl/display/StandardRenderPipeline.cpp @@ -0,0 +1,55 @@ +// Copyright (c) 2022 Dominic Masters +// +// This software is released under the MIT License. +// https://opensource.org/licenses/MIT + +#include "StandardRenderPipeline.hpp" +#include "scene/components/Components.hpp" + +using namespace Dawn; + +StandardRenderPipeline::StandardRenderPipeline(RenderManager &renderManager) : + RenderPipeline(renderManager) +{ +} + +void StandardRenderPipeline::renderScene(Scene &scene) { + RenderTarget &backBuffer = this->renderManager.getBackBuffer(); + auto cameras = scene.findComponents(); + std::shared_ptr backBufferCamera = nullptr; + + // First, render all non-backbuffer cameras. + auto it = cameras.begin(); + while(it != cameras.end()) { + RenderTarget &cameraTarget = (*it)->getRenderTarget(); + + // Leave the backbuffer camera(s) to last, so we skip them. + if(&cameraTarget == &backBuffer) { + backBufferCamera = *it; + } else { + this->renderSceneCamera(scene, **it); + } + + ++it; + } + + // Now render the backbuffer camera. + if(backBufferCamera == nullptr) return; + this->renderSceneCamera(scene, *backBufferCamera); +} + +void StandardRenderPipeline::renderSceneCamera(Scene &scene, Camera &camera) { + RenderTarget &renderTarget = camera.getRenderTarget(); + renderTarget.bind(); + renderTarget.clear( + RENDER_TARGET_CLEAR_FLAG_DEPTH | + RENDER_TARGET_CLEAR_FLAG_COLOR + ); + + auto meshes = scene.findComponents(); + auto it = meshes.begin(); + while(it != meshes.end()) { + (*it)->mesh->draw(MESH_DRAW_MODE_TRIANGLES, 0, -1); + ++it; + } +} \ No newline at end of file diff --git a/src/dawnopengl/display/StandardRenderPipeline.hpp b/src/dawnopengl/display/StandardRenderPipeline.hpp new file mode 100644 index 00000000..1f159cad --- /dev/null +++ b/src/dawnopengl/display/StandardRenderPipeline.hpp @@ -0,0 +1,18 @@ +// Copyright (c) 2022 Dominic Masters +// +// This software is released under the MIT License. +// https://opensource.org/licenses/MIT + +#pragma once +#include "dawnopengl.hpp" +#include "display/RenderPipeline.hpp" + +namespace Dawn { + class StandardRenderPipeline : public RenderPipeline { + public: + StandardRenderPipeline(RenderManager &renderManager); + + void renderScene(Scene &scene) override; + void renderSceneCamera(Scene &scene, Camera &camera) override; + }; +} \ No newline at end of file diff --git a/src/dawnopengl/display/mesh/TriangleMesh.cpp b/src/dawnopengl/display/mesh/TriangleMesh.cpp index e70377eb..2e62bd7a 100644 --- a/src/dawnopengl/display/mesh/TriangleMesh.cpp +++ b/src/dawnopengl/display/mesh/TriangleMesh.cpp @@ -8,19 +8,19 @@ using namespace Dawn; -void TriangleMesh::createTriangleMesh(std::shared_ptr mesh) { - mesh->createBuffers(3, 3); - mesh->bufferPositions(0, std::array{{ +void TriangleMesh::createTriangleMesh(Mesh &mesh) { + mesh.createBuffers(3, 3); + mesh.bufferPositions(0, std::array{{ glm::vec3(-1, 0, 0), glm::vec3(0, 1, 0), glm::vec3(1, 0, 0) }}); - mesh->bufferCoordinates(0, std::array{{ + mesh.bufferCoordinates(0, std::array{{ glm::vec2(0, 0), glm::vec2(0, 1), glm::vec2(1, 0) }}); - mesh->bufferIndices(0, std::array{{ + mesh.bufferIndices(0, std::array{{ 0, 1, 2 }}); } \ No newline at end of file diff --git a/src/dawnpokergame/game/DawnPokerGame.cpp b/src/dawnpokergame/game/DawnPokerGame.cpp index 0bcf3121..8b35bb3c 100644 --- a/src/dawnpokergame/game/DawnPokerGame.cpp +++ b/src/dawnpokergame/game/DawnPokerGame.cpp @@ -7,16 +7,16 @@ using namespace Dawn; -DawnGame::DawnGame(std::weak_ptr host) : - renderManager(weak_from_this()) +DawnGame::DawnGame(DawnHost &host) : + host(host), + renderManager(*this) { - this->host = host; } int32_t DawnGame::init() { this->renderManager.init(); - this->scene = std::make_shared(weak_from_this()); + this->scene = std::make_shared(*this); auto cameraObject = this->scene->createSceneItem(); auto camera = cameraObject->addComponent(); @@ -24,20 +24,14 @@ int32_t DawnGame::init() { auto cubeObject = this->scene->createSceneItem(); auto cubeMeshRenderer = cubeObject->addComponent(); cubeMeshRenderer->mesh = std::make_shared(); - TriangleMesh::createTriangleMesh(cubeMeshRenderer->mesh); + TriangleMesh::createTriangleMesh(*cubeMeshRenderer->mesh); return DAWN_GAME_INIT_RESULT_SUCCESS; } int32_t DawnGame::update(float_t delta) { - this->renderManager.update(); if(this->scene != nullptr) this->scene->update(); - - auto meshRenderer = this->scene->findComponent(); - if(meshRenderer != nullptr) { - meshRenderer->mesh->draw(MESH_DRAW_MODE_TRIANGLES, 0, -1); - } - + this->renderManager.update(); return DAWN_GAME_UPDATE_RESULT_SUCCESS; } diff --git a/src/dawnwin32/host/DawnHostWin32.cpp b/src/dawnwin32/host/DawnHostWin32.cpp index 4e27786f..bdea201b 100644 --- a/src/dawnwin32/host/DawnHostWin32.cpp +++ b/src/dawnwin32/host/DawnHostWin32.cpp @@ -12,10 +12,10 @@ int32_t main(int32_t argc, char **args) { // Create the host auto host = std::make_shared(); - auto game = std::make_shared(host); + auto game = std::make_shared(*host); // Initialize the host and error check - result = host->init(std::weak_ptr(game)); + result = host->init(*game); switch(result) { case DAWN_HOST_INIT_RESULT_SUCCESS: break; @@ -24,7 +24,7 @@ int32_t main(int32_t argc, char **args) { } // Request the main loop to start running. - result = host->start(std::weak_ptr(game)); + result = host->start(*game); switch(result) { case DAWN_HOST_START_RESULT_SUCCESS: break; @@ -35,7 +35,7 @@ int32_t main(int32_t argc, char **args) { } // Main loop finished without errors, cleanup - host->unload(std::weak_ptr(game)); + host->unload(*game); // Success return 0;