added pipeline class, the renderer now takes a pipeline instead of modules, the camera is now held in the scene

features.todo

@@ -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

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)
+{
+
+}

src/pipeline.h

@@ -0,0 +1,79 @@
+#ifndef PIPELINE_H
+#define PIPELINE_H
+
+#include <vector>
+#include <cstddef>
+#include <string>
+
+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<Module*> modules;
+public:
+
+    /**
+     * @brief getModules is a getter used by the renderer to access the pipeline modules
+     */
+    std::vector<Module*>& 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

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<Light*>* getLights() = 0;
     virtual SceneIterator<GeometryNode*>* getGeometry() = 0;
 };
@@ -54,6 +62,8 @@ protected:
     std::vector<Light*> lights;
     std::vector<GeometryNode*> geometry;
 public:
+    ArrayScene() : Scene() {}
+
     void clearLights() {lights.clear();}
     void clearEntities() {geometry.clear();}
     void clearScene() {clearLights(); clearEntities();}

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<nbDefines; ++i)
-    {
-        if(str.compare(defines[i]) == 0)
-            return true;
-    }
-    return false;
-}
-
 std::string ShaderSource::preprocess(std::string source, int nbDefines, const char** defines, const char* version)
 {
     std::string header = "#version "+std::string(version);
@@ -61,41 +51,3 @@ std::string ShaderSource::preprocess(std::string source, int nbDefines, const ch
         header += "\n#define "+std::string(defines[i]);
     return header+"\n#line 1\n"+source;
 }
-/*
-std::string ShaderSource::preprocess(std::string source, int nbDefines, const char** defines)
-{
-    std::string compiled = "";
-    std::istringstream ss(source);
-    std::string line;
-    std::vector<bool> 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;
-}
-*/

src/sparrowrenderer.cpp

@@ -10,8 +10,12 @@
 #include <chrono>
 #include <string.h>
 #include <iostream>
+#include "pipeline.h"
+#include "scene.h"
 // main methods
 
+std::vector<Module*> SparrowRenderer::NO_MODULES = std::vector<Module*>();
+
 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)
-    {
-        if(m.isEnabled)
+
+    for(Module *m : modules)
     {
         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::duration<double>>(std::chrono::high_resolution_clock::now() - t).count();
-        }
+        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

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<ModuleNode> modules;
+    std::vector<Module*> &modules;
+
     static bool modernOpenglAvailable;
+
     glm::vec3 clearColor;
 
-    std::vector<ModuleNode>::iterator getModuleNode(std::string name);
+private:
+    static std::vector<Module*> NO_MODULES;
 };
 
 #endif // SPARROWRENDERER_H