From 8ceca758e9da9d02d787f6b85f5a54fc3e98a903 Mon Sep 17 00:00:00 2001 From: Anselme Date: Thu, 10 Mar 2016 22:49:44 +0100 Subject: [PATCH] added pipeline class, the renderer now takes a pipeline instead of modules, the camera is now held in the scene --- features.todo | 18 --------- src/pipeline.cpp | 40 +++++++++++++++++++ src/pipeline.h | 79 +++++++++++++++++++++++++++++++++++++ src/scene.h | 10 +++++ src/shadersource.cpp | 48 ----------------------- src/sparrowrenderer.cpp | 86 +++++++++-------------------------------- src/sparrowrenderer.h | 38 ++++++------------ 7 files changed, 158 insertions(+), 161 deletions(-) delete mode 100644 features.todo create mode 100644 src/pipeline.cpp create mode 100644 src/pipeline.h diff --git a/features.todo b/features.todo deleted file mode 100644 index da1487a..0000000 --- a/features.todo +++ /dev/null @@ -1,18 +0,0 @@ - -basic features : - - mipmaps - pipeline class - configurable bloom - billboards - 2D rendering - cubemap framebuffer - point light shadows - dynamic HDR - deferred shading - -advanced features : - - water shader - ssao - mesh animation diff --git a/src/pipeline.cpp b/src/pipeline.cpp new file mode 100644 index 0000000..5ac585a --- /dev/null +++ b/src/pipeline.cpp @@ -0,0 +1,40 @@ +#include "pipeline.h" +#include "forwardmodule.h" +#include "crappymodule.h" +#include "shadersource.h" +#include "sparrowrenderer.h" +#include "scene.h" + +Pipeline::~Pipeline() +{ + for(Module *m : modules) + delete m; +} + +SimplePipeline::SimplePipeline(ShaderSource *forwardSource) +{ + isCrappy = forwardSource != NULL && SparrowRenderer::isModernOpenGLAvailable(); + if(!isCrappy) + { + ForwardModule *forward = new ForwardModule(); + forward->setShaderSource(forwardSource); + forward->setClearBeforeDrawing(false); + modules.push_back(forward); + } + else + modules.push_back(new CrappyModule()); +} + +void SimplePipeline::refreshScene(Scene *scene) +{ + if(!isCrappy) + { + ForwardModule *forward = (ForwardModule*)(modules[0]); + forward->compileShaders(scene); + } +} + +DefaultPipeline::DefaultPipeline(const Settings &mySettings, const SourcePack &mySourcePack) +{ + +} diff --git a/src/pipeline.h b/src/pipeline.h new file mode 100644 index 0000000..a64d78a --- /dev/null +++ b/src/pipeline.h @@ -0,0 +1,79 @@ +#ifndef PIPELINE_H +#define PIPELINE_H + +#include +#include +#include + +class ShaderSource; +class Module; +class Scene; + +class Pipeline +{ +protected: + /** + * @brief every module in this vector will be used by the renderer for resizing, and rendering + */ + std::vector modules; +public: + + /** + * @brief getModules is a getter used by the renderer to access the pipeline modules + */ + std::vector& getModules() {return modules;} + + /** + * the destructor deletes all the modules + */ + ~Pipeline(); +}; + +/** + * @brief The SimplePipeline class creates a simple graphic pipeline able to render 3D meshes + * it is compatible with crappy rendering + */ +class SimplePipeline : public Pipeline +{ + bool isCrappy; + +public: + SimplePipeline(ShaderSource *forwardSource = NULL); + + void refreshScene(Scene *scene); +}; + +class DefaultPipeline : public Pipeline +{ +public: + struct Settings + { + bool usesDeferred; + bool hasSkybox; + bool hasPicking; + bool hasBloom; + }; + + struct SourcePack + { + std::string forward_frag; + std::string forward_vert; + + std::string gbuffer_frag; + std::string gbuffer_vert; + std::string deferred_frag; + std::string deferred_vert; + + std::string bloom_frag; + std::string blur_frag; + std::string hdr_frag; + std::string luminance_frag; + std::string reduction_frag; + }; + + DefaultPipeline(const Settings &mySettings, const SourcePack &mySourcePack); + + void refreshScene(Scene *scene); +}; + +#endif // PIPELINE_H diff --git a/src/scene.h b/src/scene.h index f93641f..247f586 100644 --- a/src/scene.h +++ b/src/scene.h @@ -29,7 +29,15 @@ struct GeometryNode class Scene { +protected: + Camera *camera; + public: + Scene() : camera(NULL) {} + + void setCamera(Camera* myCamera) {camera = myCamera;} + Camera* getCamera() {return camera;} + virtual SceneIterator* getLights() = 0; virtual SceneIterator* getGeometry() = 0; }; @@ -54,6 +62,8 @@ protected: std::vector lights; std::vector geometry; public: + ArrayScene() : Scene() {} + void clearLights() {lights.clear();} void clearEntities() {geometry.clear();} void clearScene() {clearLights(); clearEntities();} diff --git a/src/shadersource.cpp b/src/shadersource.cpp index a60793a..4f18f90 100644 --- a/src/shadersource.cpp +++ b/src/shadersource.cpp @@ -44,16 +44,6 @@ Shader* ShaderSource::compile(int nbDefines, const char** defines) return new Shader(compiledSources[VERTEX], compiledSources[FRAGMENT]); } -bool isDefined(const std::string &str, int nbDefines, const char** defines) -{ - for(int i=0; i allowedStack; - while (std::getline(ss, line)) { - if(line.size() > 0 && line.at(0) == '#') - { - if(line.compare(0, 8, "#version") == 0) - compiled.append(line+'\n'); - else if(line.compare(0, 7, "#ifdef ") == 0) - allowedStack.push_back(isDefined(line.substr(7), nbDefines, defines)); - else if(line.compare(0, 8, "#ifndef ") == 0) - allowedStack.push_back(!isDefined(line.substr(8), nbDefines, defines)); - else if(line.compare("#endif") == 0) - allowedStack.pop_back(); - else if(line.compare("#else") == 0) - allowedStack.back() = !allowedStack.back(); - } - else - { - bool ok = true; - for(bool allowed : allowedStack) - { - if(!allowed) - { - ok = false; break; - } - } - if(ok) - compiled.append(line+'\n'); - } - } - return compiled; -} -*/ diff --git a/src/sparrowrenderer.cpp b/src/sparrowrenderer.cpp index d36ea8e..a96e206 100644 --- a/src/sparrowrenderer.cpp +++ b/src/sparrowrenderer.cpp @@ -10,8 +10,12 @@ #include #include #include +#include "pipeline.h" +#include "scene.h" // main methods +std::vector SparrowRenderer::NO_MODULES = std::vector(); + bool SparrowRenderer::modernOpenglAvailable = false; void SparrowRenderer::initGL(int w, int h, bool forceCrappy) @@ -48,22 +52,14 @@ void SparrowRenderer::initGL(int w, int h, bool forceCrappy) resizeGL(w, h); } -void SparrowRenderer::destroyGL() -{ - for(ModuleNode &m : modules) - delete m.module; - modules.clear(); -} - void SparrowRenderer::resizeGL(int w, int h) { width = w; height = h; - glAssert(glViewport(0, 0, width, height)); - if(camera != NULL) - camera->resize(width, height); - for(ModuleNode &mn : modules) - mn.module->resize(w, h); + if(scene != NULL && scene->getCamera() != NULL) + scene->getCamera()->resize(width, height); + for(Module *m : modules) + m->resize(w, h); } void SparrowRenderer::renderGL() @@ -71,15 +67,11 @@ void SparrowRenderer::renderGL() glAssert(glViewport(0, 0, width, height)); glAssert(glClearColor(clearColor.r, clearColor.g, clearColor.b, 1)); glAssert(glClearDepth(1.0)); - for(ModuleNode &m : modules) + + for(Module *m : modules) { - if(m.isEnabled) - { - glFinish(); - std::chrono::high_resolution_clock::time_point t = std::chrono::high_resolution_clock::now(); - m.module->renderGL(getCamera(), scene); - m.seconds = std::chrono::duration_cast>(std::chrono::high_resolution_clock::now() - t).count(); - } + glFinish(); + m->renderGL(scene == NULL ? NULL : scene->getCamera(), scene); } glFinish(); } @@ -89,56 +81,14 @@ bool SparrowRenderer::isModernOpenGLAvailable() return modernOpenglAvailable; } -// clock methods +// pipeline methods -double SparrowRenderer::getFPS() +void SparrowRenderer::setPipeline(Pipeline* pipeline) { - double totalTime = 0; - for(ModuleNode &m : modules) - { - if(m.isEnabled) - totalTime += m.seconds; - } - return 1./totalTime; -} - -double SparrowRenderer::getModuleTime(int moduleId) -{ - return modules[moduleId].seconds; -} - -// module methods - -void SparrowRenderer::addModule(Module* myModule, std::string name) -{ - if(modernOpenglAvailable || !myModule->requiresModernOpenGL()) - modules.push_back(ModuleNode(myModule, name)); -} - -int SparrowRenderer::getNbModules() -{ - return modules.size(); -} - -void SparrowRenderer::setModuleEnabled(std::string module, bool isEnabled) -{ - for(ModuleNode &node : modules) - { - if(node.name.compare(module) == 0) - node.isEnabled = isEnabled; - } -} - -// camera methods - -void SparrowRenderer::setCamera(Camera* myCamera) -{ - camera = myCamera; -} - -Camera* SparrowRenderer::getCamera() -{ - return camera; + if(pipeline != NULL) + modules = pipeline->getModules(); + else + modules = NO_MODULES; } // scene methods diff --git a/src/sparrowrenderer.h b/src/sparrowrenderer.h index 1e50445..7cbfcbc 100644 --- a/src/sparrowrenderer.h +++ b/src/sparrowrenderer.h @@ -9,61 +9,45 @@ class Camera; class Module; class Scene; +class Pipeline; class SparrowRenderer { public: SparrowRenderer() : - camera(NULL), scene(NULL), + modules(NO_MODULES), clearColor(0) {} // main methods void initGL(int w, int h, bool forceCrappy = false); - void destroyGL(); void resizeGL(int w, int h); void renderGL(); + static bool isModernOpenGLAvailable(); void setClearColor(glm::vec3 color) {clearColor=color;} - // clock methods - double getFPS(); - double getModuleTime(int moduleId); - - // modules methods - void addModule(Module* myModule, std::string name); - int getNbModules(); - - void setModuleEnabled(std::string module, bool isEnabled); - - // camera methods - void setCamera(Camera* myCamera); - Camera* getCamera(); + // pipeline methods + void setPipeline(Pipeline* pipeline); // scene methods void setScene(Scene* myScene); Scene* getScene(); protected: - typedef struct s_moduleNode{ - Module* module; - std::string name; - bool isEnabled; - double seconds; - - s_moduleNode(Module* myModule, const std::string &myName) : module(myModule), name(myName), isEnabled(true) {} - } ModuleNode; - int width; int height; - Camera* camera; + Scene* scene; - std::vector modules; + std::vector &modules; + static bool modernOpenglAvailable; + glm::vec3 clearColor; - std::vector::iterator getModuleNode(std::string name); +private: + static std::vector NO_MODULES; }; #endif // SPARROWRENDERER_H