added render pipeline panel

basicmodule.cpp

@@ -13,7 +13,7 @@ void BasicModule::render(Camera* myCamera)
     shader->bind();
     bindModule();
     for(Entity* e : entities)
-        e->draw(myCamera->getViewMatrix(), myCamera->getProjectionMatrix(), NULL);
+        e->draw(myCamera->getViewMatrix(), myCamera->getProjectionMatrix());
 }
 
 

entity.cpp

@@ -6,15 +6,9 @@
 
 Entity::Entity(Mesh* myMesh, Material* myMat) : mesh(myMesh), mat(myMat) {}
 
-Entity::Entity(Entity* myParent, Mesh* myMesh, Material* myMat) : mesh(myMesh), mat(myMat)
+void Entity::draw(const glm::mat4 viewMatrix, const glm::mat4 projectionMatrix)
 {
-    myParent->addChild(this);
+    glm::mat4 modelViewMatrix = viewMatrix * modelMatrix;
-}
-
-void Entity::draw(const glm::mat4 viewMatrix, const glm::mat4 projectionMatrix, const glm::mat4* parentMatrix)
-{
-    glm::mat4 worldMatrix = parentMatrix == NULL ? modelMatrix : modelMatrix * *parentMatrix;
-    glm::mat4 modelViewMatrix = viewMatrix * worldMatrix;
     glm::mat4 mvp = projectionMatrix * modelViewMatrix;
     glm::mat4 normalMatrix = glm::transpose(glm::inverse(modelViewMatrix));
     mat->bindAttributes();
@@ -24,8 +18,6 @@ void Entity::draw(const glm::mat4 viewMatrix, const glm::mat4 projectionMatrix,
     shader->bindMatrix(shader->getLocation("normalMatrix"), normalMatrix);
     shader->bindMatrix(shader->getLocation("MVP"), mvp);
     mesh->draw();
-    for(Entity* e : children)
-        e->draw(viewMatrix, projectionMatrix, &worldMatrix);
 }
 
 glm::mat4* Entity::getTransform()
@@ -43,7 +35,3 @@ Material* Entity::getMaterial()
     return mat;
 }
 
-void Entity::addChild(Entity* child)
-{
-    children.push_back(child);
-}

entity.h

@@ -11,21 +11,15 @@ class Shader;
 class Entity
 {
 protected:
-    std::vector<Entity*> children;
     Mesh* mesh;
     Material* mat;
     glm::mat4 modelMatrix;
 public:
     Entity(Mesh* myMesh, Material* myMat);
-    /**
+    virtual void draw(const glm::mat4 viewMatrix, const glm::mat4 projectionMatrix);
-     * NULL Material is acceptable for this constructor
-     */
-    Entity(Entity* myParent, Mesh* myMesh, Material* myMat);
-    virtual void draw(const glm::mat4 viewMatrix, const glm::mat4 projectionMatrix, const glm::mat4* parentMatrix);
     glm::mat4* getTransform();
     Shader* getShader();
     Material* getMaterial();
-    void addChild(Entity* child);
 };
 
 #endif // ENTITY_H

mainwindow.cpp

@@ -1,5 +1,6 @@
 #include "mainwindow.h"
 #include "ui_mainwindow.h"
+#include "sparrowrenderer.h"
 
 MainWindow::MainWindow(QWidget *parent) :
     QMainWindow(parent),
@@ -12,3 +13,33 @@ MainWindow::~MainWindow()
 {
     delete ui;
 }
+
+void MainWindow::dockWidgetClosed()
+{
+    emit(ui->dockWidget->setVisible(true));
+}
+
+void MainWindow::updateTree()
+{
+    QTreeWidget* tree = ui->treeWidget;
+    SparrowRenderer* renderer = ui->openGLWidget->getRenderer();
+    tree->clear();
+    for(int i=0; i<renderer->getNbModules(); ++i)
+    {
+        std::string moduleName = renderer->getModuleName(i);
+        QTreeWidgetItem* item = new QTreeWidgetItem();
+        item->setText(0, QString(moduleName.c_str()));
+        tree->addTopLevelItem(item);
+    }
+}
+
+void MainWindow::moduleSetEnabled(QTreeWidgetItem* item, int button)
+{
+    SparrowRenderer* renderer = ui->openGLWidget->getRenderer();
+    std::string name = item->text(0).toStdString();
+    if(renderer->isModuleEnabled(name))
+        renderer->disableModule(name);
+    else
+        renderer->enableModule(name);
+    ui->openGLWidget->updateGL();
+}

mainwindow.h

@@ -3,6 +3,8 @@
 
 #include <QMainWindow>
 
+class QTreeWidgetItem;
+
 namespace Ui {
 class MainWindow;
 }
@@ -17,6 +19,11 @@ public:
 
 private:
     Ui::MainWindow *ui;
+
+public slots:
+    void dockWidgetClosed();
+    void updateTree();
+    void moduleSetEnabled(QTreeWidgetItem* item, int button);
 };
 
 #endif // MAINWINDOW_H

mainwindow.ui

@@ -6,8 +6,8 @@
    <rect>
     <x>0</x>
     <y>0</y>
-    <width>400</width>
+    <width>854</width>
-    <height>300</height>
+    <height>510</height>
    </rect>
   </property>
   <property name="windowTitle">
@@ -40,11 +40,65 @@
     <rect>
      <x>0</x>
      <y>0</y>
-     <width>400</width>
+     <width>854</width>
-     <height>20</height>
+     <height>21</height>
     </rect>
    </property>
+   <widget class="QMenu" name="menuMenu">
+    <property name="title">
+     <string>menu</string>
+    </property>
+    <addaction name="actionShow_control_panel"/>
+    <addaction name="actionExit"/>
    </widget>
+   <addaction name="menuMenu"/>
+  </widget>
+  <widget class="QDockWidget" name="dockWidget">
+   <attribute name="dockWidgetArea">
+    <number>1</number>
+   </attribute>
+   <widget class="QWidget" name="dockWidgetContents">
+    <layout class="QVBoxLayout" name="verticalLayout">
+     <property name="spacing">
+      <number>0</number>
+     </property>
+     <property name="leftMargin">
+      <number>0</number>
+     </property>
+     <property name="topMargin">
+      <number>0</number>
+     </property>
+     <property name="rightMargin">
+      <number>0</number>
+     </property>
+     <property name="bottomMargin">
+      <number>0</number>
+     </property>
+     <item>
+      <widget class="QTreeWidget" name="treeWidget">
+       <column>
+        <property name="text">
+         <string notr="true">rendering pipeline</string>
+        </property>
+       </column>
+      </widget>
+     </item>
+    </layout>
+   </widget>
+  </widget>
+  <action name="actionExit">
+   <property name="text">
+    <string>exit</string>
+   </property>
+  </action>
+  <action name="actionShow_control_panel">
+   <property name="enabled">
+    <bool>false</bool>
+   </property>
+   <property name="text">
+    <string>show control panel</string>
+   </property>
+  </action>
  </widget>
  <layoutdefault spacing="6" margin="11"/>
  <customwidgets>
@@ -52,8 +106,97 @@
    <class>MyGLWidget</class>
    <extends>QOpenGLWidget</extends>
    <header>myglwidget.h</header>
+   <slots>
+    <signal>modulesChanged()</signal>
+   </slots>
   </customwidget>
  </customwidgets>
  <resources/>
- <connections/>
+ <connections>
+  <connection>
+   <sender>actionExit</sender>
+   <signal>triggered()</signal>
+   <receiver>MainWindow</receiver>
+   <slot>close()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>-1</x>
+     <y>-1</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>426</x>
+     <y>254</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>dockWidget</sender>
+   <signal>visibilityChanged(bool)</signal>
+   <receiver>actionShow_control_panel</receiver>
+   <slot>setDisabled(bool)</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>127</x>
+     <y>265</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>-1</x>
+     <y>-1</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>actionShow_control_panel</sender>
+   <signal>triggered()</signal>
+   <receiver>MainWindow</receiver>
+   <slot>dockWidgetClosed()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>-1</x>
+     <y>-1</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>426</x>
+     <y>254</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>openGLWidget</sender>
+   <signal>modulesChanged()</signal>
+   <receiver>MainWindow</receiver>
+   <slot>updateTree()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>555</x>
+     <y>265</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>426</x>
+     <y>254</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>treeWidget</sender>
+   <signal>itemClicked(QTreeWidgetItem*,int)</signal>
+   <receiver>MainWindow</receiver>
+   <slot>moduleSetEnabled(QTreeWidgetItem*,int)</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>127</x>
+     <y>276</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>426</x>
+     <y>254</y>
+    </hint>
+   </hints>
+  </connection>
+ </connections>
+ <slots>
+  <slot>dockWidgetClosed()</slot>
+  <slot>updateTree()</slot>
+  <slot>moduleSetEnabled(QTreeWidgetItem*,int)</slot>
+ </slots>
 </ui>

modules.todo

@@ -0,0 +1,15 @@
+Modules :
+
+- bump mapping module
+
+- particles module
+
+- text/gui module
+
+- shadowmap module
+
+- heat wave module
+- mirror module
+- wave + mirror = water module
+
+- ssao module

myglwidget.cpp

@@ -34,6 +34,11 @@ MyGLWidget::~MyGLWidget()
         delete(controller);
 }
 
+SparrowRenderer* MyGLWidget::getRenderer()
+{
+    return renderer;
+}
+
 void MyGLWidget::loadResources()
 {
     std::string filenames[6] = {
@@ -63,7 +68,7 @@ void MyGLWidget::buildScene()
 
     // create skybox module
     SkyboxModule* skybox = new SkyboxModule(ResourceBase::getTexture("skybox"));
-    renderer->addModule(skybox);
+    renderer->addModule(skybox, "skybox");
 
     // create phong module
     Lights* directionnalLights = new Lights();
@@ -71,7 +76,7 @@ void MyGLWidget::buildScene()
     directionnalLights->addLight(glm::vec3(6, 4, -4), glm::vec3(0.7f, 0.6f, 0.4f)); // sun
 
     PhongModule* myPhongModule = new PhongModule(directionnalLights, pointLights, ResourceBase::getShader("phong"));
-    renderer->addModule(myPhongModule);
+    renderer->addModule(myPhongModule, "phong");
 
     // create a material
     PhongMaterial* mat = new PhongMaterial(glm::vec3(1), glm::vec3(1), 20.0f);
@@ -83,8 +88,10 @@ void MyGLWidget::buildScene()
     myMesh->initGL();
     Entity* myEntity = new Entity(myMesh, ResourceBase::getMaterial("basicMat"));
     glm::mat4* transform = myEntity->getTransform();
-    *transform = glm::rotate(*transform, 100.0f, glm::vec3(0, 1, 0));
+    *transform = glm::rotate(*transform, 3.14f, glm::vec3(0, 1, 0));
     myPhongModule->addEntity(myEntity);
+
+    emit modulesChanged();
 }
 
 void MyGLWidget::initializeGL()

myglwidget.h

@@ -22,6 +22,8 @@ public:
     explicit MyGLWidget(QWidget *parent = 0);
     ~MyGLWidget();
 
+    SparrowRenderer* getRenderer();
+
 protected:
     void initializeGL();
     void loadResources();
@@ -37,6 +39,9 @@ private:
     void wheelEvent(QWheelEvent *e);
     void keyPressEvent(QKeyEvent *e);
     void keyReleaseEvent(QKeyEvent *e);
+
+signals:
+    void modulesChanged();
 };
 
 #endif // MYGLWIDGET_H

sparrowRenderer.pro

@@ -68,4 +68,7 @@ HEADERS += mainwindow.h \
 
 FORMS   += mainwindow.ui
 
-OTHER_FILES += *.frag *.vert *.glsl
+OTHER_FILES += *.frag *.vert *.glsl *.todo
+
+DISTFILES += \
+    modules.todo

sparrowrenderer.cpp

@@ -5,6 +5,8 @@
 #include "camera.h"
 #include "basicmodule.h"
 
+// main methods
+
 SparrowRenderer::SparrowRenderer(int width, int height) : camera(width, height)
 {
     glewExperimental = GL_TRUE;
@@ -31,16 +33,6 @@ SparrowRenderer::SparrowRenderer(int width, int height) : camera(width, height)
     glAssert(glViewport(0, 0, width, height));
 }
 
-void SparrowRenderer::addModule(Module* myModule)
-{
-    modules.push_back(myModule);
-}
-
-Camera* SparrowRenderer::getCamera()
-{
-    return &camera;
-}
-
 void SparrowRenderer::resize(int width, int height)
 {
     glAssert(glViewport(0, 0, width, height));
@@ -51,6 +43,119 @@ void SparrowRenderer::render()
 {
     glAssert(glClearColor(0.60, 0.65, 0.75, 1.0));
     glAssert(glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT));
-    for(Module* m : modules)
+    for(ModuleNode &m : modules)
-        m->render(getCamera());
+    {
+        if(m.isEnabled)
+            m.module->render(getCamera());
+    }
 }
+
+// module methods
+
+void SparrowRenderer::addModule(Module* myModule, std::string name)
+{
+    modules.push_back(ModuleNode(myModule, name));
+}
+
+void SparrowRenderer::addModule(Module* myModule, std::string name, int index)
+{
+    if(index < 0)
+        index = 0;
+    if(index > modules.size())
+        modules.push_back(ModuleNode(myModule, name));
+    else
+    {
+        auto it = modules.begin();
+        std::advance(it, index);
+        modules.insert(it, ModuleNode(myModule, name));
+    }
+}
+
+void SparrowRenderer::removeModule(int index)
+{
+    auto it = modules.begin();
+    std::advance(it, index);
+    modules.erase(it);
+}
+
+void SparrowRenderer::removeModule(std::string name)
+{
+    modules.erase(getModuleNode(name));
+}
+
+Module* SparrowRenderer::getModule(int index)
+{
+    auto it = modules.begin();
+    std::advance(it, index);
+    return (*it).module;
+}
+
+Module* SparrowRenderer::getModule(std::string name)
+{
+    return (*getModuleNode(name)).module;
+}
+
+std::list<SparrowRenderer::ModuleNode>::iterator SparrowRenderer::getModuleNode(std::string name)
+{
+    for(auto iterator = modules.begin(); iterator != modules.end(); ++iterator)
+    {
+        if(iterator->name == name)
+            return iterator;
+    }
+}
+
+int SparrowRenderer::getNbModules()
+{
+    return modules.size();
+}
+
+std::string SparrowRenderer::getModuleName(int index)
+{
+    auto it = modules.begin();
+    std::advance(it, index);
+    return (*it).name;
+}
+
+void SparrowRenderer::enableModule(std::string name)
+{
+    (*getModuleNode(name)).isEnabled = true;
+}
+
+void SparrowRenderer::enableModule(int index)
+{
+    auto it = modules.begin();
+    std::advance(it, index);
+    (*it).isEnabled = true;
+}
+
+void SparrowRenderer::disableModule(std::string name)
+{
+    (*getModuleNode(name)).isEnabled = false;
+}
+
+void SparrowRenderer::disableModule(int index)
+{
+    auto it = modules.begin();
+    std::advance(it, index);
+    (*it).isEnabled = false;
+}
+
+bool SparrowRenderer::isModuleEnabled(std::string name)
+{
+    return (*getModuleNode(name)).isEnabled;
+}
+
+bool SparrowRenderer::isModuleEnabled(int index)
+{
+    auto it = modules.begin();
+    std::advance(it, index);
+    return (*it).isEnabled;
+}
+
+// camera methods
+
+Camera* SparrowRenderer::getCamera()
+{
+    return &camera;
+}
+

sparrowrenderer.h

@@ -1,21 +1,51 @@
 #ifndef SPARROWRENDERER_H
 #define SPARROWRENDERER_H
 
-#include <vector>
+#include <list>
+#include <string>
 #include "camera.h"
 
 class Module;
 
 class SparrowRenderer
 {
+    typedef struct s_moduleNode{
+        Module* module;
+        std::string name;
+        bool isEnabled;
+
+        s_moduleNode(Module* myModule, const std::string &myName) : module(myModule), name(myName), isEnabled(true) {}
+    } ModuleNode;
+
+    std::list<ModuleNode>::iterator getModuleNode(std::string name);
+
     Camera camera;
-    std::vector<Module*> modules;
+    std::list<ModuleNode> modules;
 public:
+
+    // main methods
     SparrowRenderer(int width, int height);
-    void addModule(Module* myModule);
-    Camera* getCamera();
     void resize(int width, int height);
     void render();
+
+    // modules methods
+    void addModule(Module* myModule, std::string name);
+    void addModule(Module* myModule, std::string name, int index);
+    void removeModule(std::string name);
+    void removeModule(int index);
+    Module* getModule(std::string name);
+    Module* getModule(int index);
+    int getNbModules();
+    std::string getModuleName(int index);
+    void enableModule(std::string name);
+    void enableModule(int index);
+    void disableModule(std::string name);
+    void disableModule(int index);
+    bool isModuleEnabled(std::string name);
+    bool isModuleEnabled(int index);
+
+    // camera methods
+    Camera* getCamera();
 };
 
 #endif // SPARROWRENDERER_H