added trackball camera, light, and 3D terrain mesh nodes

src/scene/cameranode.cpp

@@ -1 +1,20 @@
 #include "cameranode.h"
+
+CameraNode::CameraNode(Input *input) :
+    m_input(input),
+    m_action_move(NO_ACTION),
+    m_action_rotate(NO_ACTION)
+{}
+
+void CameraNode::update()
+{
+    sf::Vector2i diff = m_input->getDeltaPosition();
+    for(int action : m_input->getActions())
+    {
+        if(action == m_action_move)
+            moveCamera(diff.x, diff.y);
+        else if(action == m_action_move)
+            rotateCamera(diff.x, diff.y);
+    }
+    zoom(m_input->getDeltaVerticalScroll());
+}

src/scene/cameranode.h

@@ -3,14 +3,27 @@
 
 #include "scenenode.h"
 #include "trackballcamera.h"
+#include "input.h"
 
 /**
  * @brief The CameraNode class is a scene node that can be used by the renderer
  */
-class CameraNode : public TrackBallCamera, SceneNode
+class CameraNode : public TrackBallCamera, public SceneNode
 {
+    Input *m_input;
+    int m_action_move;
+    int m_action_rotate;
+
 public:
-    CameraNode() {}
+    CameraNode(Input *input);
+
+    void setInputs(int action_move, int action_rotate)
+    {
+        m_action_move = action_move;
+        m_action_rotate = action_rotate;
+    }
+
+    virtual void update();
 };
 
 #endif // CAMERANODE_H

src/scene/lightnode.cpp

@@ -0,0 +1,17 @@
+#include "lightnode.h"
+#include "scenetree.h"
+#include <light.h>
+
+void LightNode::setSceneTree(SceneTree *tree){
+    SceneNode::setSceneTree(tree);
+    tree->addToIndex(this);
+}
+
+void LightNode::toggleVisibility(){
+    m_visible = !m_visible;
+    if(m_visible){
+        m_scene->addToIndex(this);
+    }else{
+        m_scene->removeFromIndex(this);
+    }
+}

src/scene/lightnode.h

@@ -0,0 +1,27 @@
+#ifndef LIGHTNODE_H
+#define LIGHTNODE_H
+
+#include "scenenode.h"
+#include "glm/mat4x4.hpp"
+#include "scene.h"
+
+class LightNode : public SceneNode
+{
+    Light *m_light;
+    bool m_visible;
+public:
+    LightNode(Light* light) : m_light(light), m_visible(true) {}
+
+    virtual void update()
+    {
+
+    }
+
+    virtual void setSceneTree(SceneTree *tree);
+
+    void toggleVisibility();
+
+    virtual Light* getLight() { return m_light; }
+};
+
+#endif // LIGHTNODE_H

src/scene/meshnode.cpp

@@ -3,7 +3,7 @@
 #include "scenetree.h"
 
 void MeshNode::setDepth(float depth){
-    geometry.mesh->setDepth(depth);
+    m_geometry.mesh->setDepth(depth);
 }
 
 void MeshNode::setSceneTree(SceneTree *tree){

src/scene/meshnode.h

@@ -11,30 +11,30 @@
 
 class MeshNode : public SceneNode
 {
-    GeometryNode geometry;
+    GeometryNode m_geometry;
     bool m_visible;
 public:
     // temp
     glm::mat4 m_movement;
     glm::mat4 m_acceleration;
 
-    MeshNode(Mesh* mesh) : geometry(mesh, glm::mat4()) {}
+    MeshNode(Mesh* mesh) : m_geometry(mesh, glm::mat4()), m_visible(true) {}
 
     virtual void update()
     {
         m_movement = m_acceleration * m_movement;
-        geometry.modelMatrix = m_movement * geometry.modelMatrix;
+        m_geometry.modelMatrix = m_movement * m_geometry.modelMatrix;
     }
 
-    void setSceneTree(SceneTree *tree);
+    virtual void setSceneTree(SceneTree *tree);
 
-    void setTransform(const glm::mat4 &transform) { geometry.modelMatrix = transform; }
-    const glm::mat4& getTransform() { return geometry.modelMatrix; }
+    void setTransform(const glm::mat4 &transform) { m_geometry.modelMatrix = transform; }
+    const glm::mat4& getTransform() { return m_geometry.modelMatrix; }
     void setDepth(float depth);
 
     void toggleVisibility();
 
-    GeometryNode* getGeometryNode() { return &geometry; }
+    virtual GeometryNode* getGeometryNode() { return &m_geometry; }
 };
 
 #endif // MESHNODE_H

src/scene/scenetree.cpp

@@ -24,7 +24,7 @@ SceneTree::~SceneTree()
 
 void SceneTree::setMainCamera(CameraNode *camera)
 {
-    //m_pipeline->setCamera(camera);
+    ((DeferredPipeline*)m_pipeline)->setCamera((Camera*)camera);
 }
 
 SceneIterator<Light*>* SceneTree::getLights()
@@ -45,7 +45,6 @@ void SceneTree::update()
 void SceneTree::addObject(ContainerNode *parent, SceneNode *node)
 {
     parent->addChild(node);
-    addToIndex(node);
     node->setSceneTree(this);
     ((DeferredPipeline*) m_pipeline)->refreshScene(this);
 }

src/test/main.cpp

@@ -7,9 +7,12 @@
 #include <resourcemanager.h>
 #include <sparrowrenderer.h>
 #include <texture.h>
-
+#include <chunk.h>
 
 #include <scene/scenetree.h>
+#include <scene/textnode.h>
+#include <scene/cameranode.h>
+#include <scene/lightnode.h>
 #include <tools/graph.h>
 #include <tools/pathfinder.h>
 #include <tools/loader.h>
@@ -19,21 +22,99 @@
 
 #include <sparrowshell.h>
 
+#include <glm/ext.hpp>
 
 class myKeysMap : public IKeysMap{
 public:
-    enum{TOGGLE_CONSOLE = 15};
+    enum{ROTATE_CAMERA, MOVE_CAMERA, TOGGLE_CONSOLE = 15};
 
     myKeysMap(){
         Binding b;
+
         b.action = TOGGLE_CONSOLE;
         b.key = sf::Keyboard::F3;
         b.type = IKeysMap::PRESSED;
+        keys.push_back(b);
 
+        b.action = ROTATE_CAMERA;
+        b.type = IKeysMap::HOLD;
+        b.key = sf::Keyboard::KeyCount + sf::Mouse::Left;
+        keys.push_back(b);
+
+        b.action = MOVE_CAMERA;
+        b.type = IKeysMap::HOLD;
+        b.key = sf::Keyboard::KeyCount + sf::Mouse::Right;
         keys.push_back(b);
     }
 };
 
+class TestGen : public TerrainGenerator
+{
+    float map[64*64];
+public:
+    TestGen()
+    {
+        for(int i=0; i<64*64; ++i)
+            map[i] = (rand()%64)/64.f;
+    }
+
+    float getHeight(float x, float z, float zoom)
+    {
+        x /= zoom;
+        z /= zoom;
+        int i1 = int(floor(x)+64)%64;
+        int j1 = int(floor(z)+64)%64;
+        int i2 = (i1+1)%64;
+        int j2 = (j1+1)%64;
+        float v1 = map[i1*64+j1];
+        float v2 = map[i2*64+j1];
+        float v3 = map[i1*64+j2];
+        float v4 = map[i2*64+j2];
+        float ph = x - floor(x);
+        float pv = z - floor(z);
+        ph = 0.5f-cos(3.1416*ph)/2;
+        pv = 0.5f-cos(3.1416*pv)/2;
+        float v5 = v1*(1-ph) + v2*ph;
+        float v6 = v3*(1-ph) + v4*ph;
+        return (v5*(1-pv) + v6*pv)*zoom;
+    }
+
+    virtual float func(float x, float y, float z)
+    {
+        float height = getHeight(x+6.7, z+15.7, 2.5f);
+        height += getHeight(x+5.76, z+2.14, 5.4f);
+        height += getHeight(x, z, 10.f);
+        return y - height;
+    }
+};
+
+void generateTerrain(SceneTree *scene)
+{
+    ContainerNode* terrainContainer = new ContainerNode();
+    scene->addObject(scene->getRootObject(), terrainContainer);
+    TestGen gen;
+    PhongMaterial *mat = new PhongMaterial();
+    mat->emission = glm::vec3(0.5f, 0.1f, 0.1f);
+    for(int x=-8; x<8; ++x)
+    for(int y=-4; y<4; ++y)
+    for(int z=-8; z<8; ++z)
+    {
+        Chunk *chunk = new Chunk(&gen); // ! WARNING ! : chunk pointer is lost and never deleted
+        glm::vec3 pos(x, y, z);
+        chunk->generate(pos);
+        if(chunk->mesh->positions3D.empty())
+            delete chunk;
+        else
+        {
+            chunk->mesh->setMaterial(mat);
+            chunk->mesh->initGL();
+            MeshNode *node = new MeshNode(chunk->mesh);
+            node->setTransform(glm::translate(glm::mat4(), pos));
+            scene->addObject(terrainContainer, node);
+        }
+    }
+}
+
 int main(){
     Engine engine;
 
@@ -42,6 +123,16 @@ int main(){
     engine.createWindow("test");
     SceneTree scene;
 
+    CameraNode *cam = new CameraNode(engine.getInput());
+    cam->setInputs(myKeysMap::MOVE_CAMERA, myKeysMap::ROTATE_CAMERA);
+    scene.addObject(scene.getRootObject(), cam);
+    scene.setMainCamera(cam);
+
+    LightNode *sunLight = new LightNode(new DirectionnalLight(glm::vec3(5, 8, -2), glm::vec3(1.f)));
+    LightNode *ambientLight = new LightNode(new AmbientLight());
+    scene.addObject(scene.getRootObject(), ambientLight);
+    scene.addObject(scene.getRootObject(), sunLight);
+
     /* Exemple creation mesh 2D
      *
     Mesh* mesh = new Mesh();
@@ -82,9 +173,11 @@ int main(){
     utils::setPosition2D((MeshNode*)tnode,glm::vec2(200, 170));
     utils::rotate2D((MeshNode*)tnode, glm::vec2(0),-0.5);
 
+    tnode->m_movement = glm::translate(glm::rotate(glm::translate(glm::mat4(), glm::vec3(240, 180, 0)), 0.03f, glm::vec3(0, 0, 1)), glm::vec3(-240, -180, 0));
+
     // mnode->setTransform(glm::rotate(glm::translate(glm::mat4(), glm::vec3(200, 170, 0)), -0.5f, glm::vec3(0, 0, 1)));
     scene.addObject(scene.getRootObject(),(SceneNode*)tnode);
-    
+
     //tnode = fonte_des_neiges->getTextNode("Such Text", glm::vec3(0.7, 0.4, 0.2));
     //tnode->setTransform(glm::rotate(glm::translate(glm::mat4(), glm::vec3(200, 170, 0)), -0.5f, glm::vec3(0, 0, 1)));
     //scene.addObject(scene.getRootObject(),tnode);
@@ -93,12 +186,14 @@ int main(){
   //  mnode = new MeshNode(fonte_des_neiges->getTextMesh("Very font", glm::vec3(0.7, 0.2, 0.8)));
   //  mnode->setTransform(glm::rotate(glm::translate(glm::mat4(), glm::vec3(180, 400, 0)), 0.1f, glm::vec3(0, 0, 1)));
   //  scene.addObject(scene.getRootObject(),mnode);
-    
+
    // mnode = new MeshNode(fonte_des_neiges->getTextMesh("Much animation", glm::vec3(0.3, 0.3, 0.8)));
    // mnode->setTransform(glm::translate(glm::mat4(), glm::vec3(400, 250, 0)));
    // mnode->m_movement = glm::translate(glm::rotate(glm::translate(glm::mat4(), glm::vec3(580, 280, 0)), 0.03f, glm::vec3(0, 0, 1)), glm::vec3(-580, -280, 0));
    // scene.addObject(scene.getRootObject(),mnode);
 
+    generateTerrain(&scene);
+
 
     engine.setScene(&scene);