first working version of SparrowEngine

CMakeLists.txt

@@ -1,6 +1,8 @@
 project(SparrowEngine)
 cmake_minimum_required(VERSION 2.8)
 
+find_package(OpenGL REQUIRED)
+
 if(WIN32)
 	set(SYSTEM_LIB_PATH "win32")
 else(WIN32)
@@ -84,6 +86,13 @@ find_library(LINEAR_MATH_LIBRARY
 		${LIB_ROOT}
 )
 
+find_library(GLEW_LIBRARY
+        NAMES
+                GLEW
+        PATHS
+                ${LIB_ROOT}
+)
+
 target_link_libraries(
 	${LIBRARY_NAME}
 	${SFML_LIBRARY_WINDOW}
@@ -93,6 +102,8 @@ target_link_libraries(
         ${BULLET_COLLISION_LIBRARY}
         ${BULLET_DYNAMICS_LIBRARY}
         ${LINEAR_MATH_LIBRARY}
+        ${GLEW_LIBRARY}
+        ${OPENGL_LIBRARIES}
 )
 
 target_link_libraries(

cameranode.cpp

@@ -1,7 +1,50 @@
 #include "cameranode.h"
+#include <glm/ext.hpp>
 
-CameraNode::CameraNode()
+CameraNode::CameraNode(glm::vec3 position, float yFov, float near, float far) :
+    m_hasMoved(true),
+    m_hasResized(false),
+    m_eye(position),
+    m_target(0, 0, 1),
+    m_yFov(yFov),
+    m_near(near),
+    m_far(far)
 {
 
 }
 
+void CameraNode::setPosition(glm::vec3 position)
+{
+    m_hasMoved = true;
+    m_eye = position;
+}
+
+void CameraNode::setTarget(glm::vec3 target)
+{
+    m_hasMoved = true;
+    m_target = target;
+}
+
+void CameraNode::update()
+{
+    if(m_hasMoved)
+        m_view = glm::lookAt(m_eye, m_target, glm::vec3(0, 1, 0));
+    if(m_hasResized)
+        m_projection = glm::perspective(m_yFov, m_ratio, m_near, m_far);
+}
+
+glm::mat4 CameraNode::getProjectionMatrix()
+{
+    return m_projection;
+}
+
+glm::mat4 CameraNode::getViewMatrix()
+{
+    return m_view;
+}
+
+void CameraNode::resize(int width, int height)
+{
+    m_hasResized = false;
+    m_ratio = ((float)width)/((float)height);
+}

cameranode.h

@@ -6,16 +6,33 @@
 
 class CameraNode : public SceneNode, public Camera
 {
+    bool m_hasMoved;
+    bool m_hasResized;
+
+    glm::vec3 m_eye;
+    glm::vec3 m_target;
+
+    float m_yFov;
+    float m_ratio;
+    float m_near;
+    float m_far;
+
+    glm::mat4 m_projection;
+    glm::mat4 m_view;
+
 public:
-    CameraNode();
+    CameraNode(glm::vec3 position, float yFov = 70.f, float near = 0.1f, float far = 100.f);
+    CameraNode(float yFov = 70.f, float near = 0.1f, float far = 100.f) :
+        CameraNode(glm::vec3(0), yFov, near, far) {}
+
+    void setPosition(glm::vec3 position);
+    void setTarget(glm::vec3 target);
+
     virtual void update();
+
     virtual glm::mat4 getProjectionMatrix();
     virtual glm::mat4 getViewMatrix();
     virtual void resize(int width, int height);
-
-signals:
-
-public slots:
 };
 
 #endif // CAMERANODE_H

engine.cpp

@@ -8,15 +8,32 @@
 #include <btBulletDynamicsCommon.h>
 #include "resourcemanager.h"
 #include "scene.h"
+#include "cameranode.h"
 
 Engine::Engine() :
     m_input(NULL),
-    m_window(NULL)
+    m_window(NULL),
+    m_world(NULL)
 {
     m_clock = new sf::Clock();
     m_clock->restart();
     m_renderer = new SparrowRenderer();
-    m_renderer->setCamera(NULL); // TODO
+    m_renderer->setCamera(NULL);
+}
+
+Engine::~Engine()
+{
+    delete m_clock;
+    if(m_window != NULL)
+        m_renderer->destroyGL();
+    delete m_renderer;
+    if(m_window != NULL)
+    {
+        delete m_window;
+        delete m_input;
+    }
+    if(m_world != NULL)
+        delete m_world;
 }
 
 void Engine::createWindow(std::string title,
@@ -53,7 +70,8 @@ void Engine::update()
     // update Scene
     m_scene->update();
     // update Physics
-    m_world->stepSimulation(1000.f*(float)getDeltaTime());
+    if(m_world != NULL)
+        m_world->stepSimulation(1000.f*(float)getDeltaTime());
     // update Display
     m_renderer->renderGL();
     m_window->display();
@@ -61,15 +79,15 @@ void Engine::update()
 
 void Engine::start()
 {
-    running = true;
+    m_running = true;
-    while(!m_input->isCloseRequested() && running){
+    while(!m_input->isCloseRequested() && m_running){
         update();
     }
 }
 
 void Engine::stop()
 {
-    running = false;
+    m_running = false;
 }
 
 unsigned int Engine::getTime()
@@ -84,5 +102,5 @@ unsigned int Engine::getDeltaTime()
 
 void Engine::setScene(std::string sceneName)
 {
-    m_scene = RESOURCE_GET(Scene,sceneName);
+    m_scene = RESOURCE_GET(Scene, sceneName);
 }

engine.h

@@ -17,12 +17,14 @@ class Engine
 {
 public:
     Engine();
+    ~Engine();
 
     void createWindow(std::string title = "SparrowEngine",
                     unsigned int w = 800,
                     unsigned int h = 600,
                     bool isWindowed = true);
     void setScene(std::string sceneName);
+    void initPhysics();
 
     void start();
     void stop();
@@ -39,7 +41,7 @@ private:
     unsigned int m_timeStamp = 0;
     unsigned int m_lastTimeStamp = 0;
 
-    bool running;
+    bool m_running;
     sf::Window* m_window;
 
     Input* m_input;
@@ -47,7 +49,6 @@ private:
     btDiscreteDynamicsWorld* m_world;
     SparrowRenderer* m_renderer;
 
-    void initPhysics();
     void update();
 };
 

main.cpp

@@ -1,8 +1,20 @@
 #include "engine.h"
 #include <input.h>
+#include "scene.h"
+#include "cameranode.h"
+#include "resourcemanager.h"
+#include "sparrowrenderer.h"
 
 int main(){
+    CameraNode camera;
+    RESOURCE_ADD(&camera, SceneNode, "camera");
+
+    Scene scene("testScene");
+    scene.addChild("camera");
+
     Engine engine;
+    engine.getRenderer()->setCamera(&camera);
     engine.createWindow("test");
+    engine.setScene("testScene");
     engine.start();
 }

scene.cpp

@@ -1,14 +1,17 @@
 #include "scene.h"
 #include "resourcemanager.h"
 
-Scene::Scene()
+// Scene
-{
 
+Scene::Scene(std::string name) :
+    m_name(name)
+{
+    RESOURCE_ADD(this, Scene, m_name);
 }
 
-void Scene::update()
+Scene::~Scene()
 {
-    m_root->update();
+    RESOURCE_ADD(NULL, Scene, m_name);
 }
 
 // Container Node

scene.h

@@ -3,17 +3,6 @@
 
 #include <vector>
 #include <string>
-class SceneNode;
-class ContainerNode;
-
-class Scene
-{
-public:
-    Scene();
-    void update();
-private:
-    ContainerNode* m_root;
-};
 
 class SceneNode
 {
@@ -32,4 +21,13 @@ protected:
     std::vector<SceneNode*> m_children;
 };
 
+class Scene : public ContainerNode
+{
+public:
+    Scene(std::string name);
+    ~Scene();
+private:
+    std::string m_name;
+};
+
 #endif // SCENE_H