shading, proto-lighting

Projects/Client/Common/Source/OgreWidget.cpp

@@ -46,7 +46,7 @@ namespace RNR
 
         ogreSceneManager = ogreRoot->createSceneManager();
         ogreSceneManager->setSkyBox(true, "sky/null_plainsky512", 5.f);
-        ogreSceneManager->setAmbientLight(Ogre::ColourValue::White);
+        ogreSceneManager->setAmbientLight(Ogre::ColourValue(0.5f,0.5f,0.5f));
 
         if(Ogre::RTShader::ShaderGenerator::initialize())
         {
@@ -58,11 +58,16 @@ namespace RNR
         else
             printf("OgreWidget::initializeOgre: unable to initialize ShaderGenerator\n");
 
-        Ogre::Light* light = ogreSceneManager->createLight("MainLight");
+        Ogre::Light* light = ogreSceneManager->createLight("SunLight");
         Ogre::SceneNode* lightNode = ogreSceneManager->getRootSceneNode()->createChildSceneNode();
         lightNode->setPosition(0, 10, 15);
+        lightNode->setDirection(-0.25, -0.5, -0.5);
         lightNode->attachObject(light);
 
+        light->setDiffuseColour(0.9, 0.9, 1.0);
+        light->setSpecularColour(1.0, 1.0, 1.0);
+        light->setType(Ogre::Light::LT_DIRECTIONAL);
+
         Ogre::SceneNode* camNode = ogreSceneManager->getRootSceneNode()->createChildSceneNode();
         camNode->setPosition(0, 0, 5);
         camNode->lookAt(Ogre::Vector3(0, sinf(render_time), cosf(render_time)), Ogre::Node::TS_PARENT);
@@ -83,7 +88,8 @@ namespace RNR
         this->render_time += ogreRoot->getTimer()->getMilliseconds() / 1000.0;
         ogreRoot->getTimer()->reset();
 
-        ogreCamera->getParentSceneNode()->lookAt(Ogre::Vector3(sinf(this->render_time)*10.f,0,cosf(this->render_time)*10.f), Ogre::Node::TS_PARENT);
+        ogreCamera->getParentSceneNode()->setPosition(Ogre::Vector3(sinf(this->render_time)*10,5.f,cosf(this->render_time)*10));
+        ogreCamera->getParentSceneNode()->lookAt(Ogre::Vector3(0,0,0), Ogre::Node::TS_PARENT);
         
         ogreRoot->renderOneFrame(this->delta);
     }

Projects/Client/Studio/Source/main.cpp

@@ -20,8 +20,8 @@ int main(int argc, char** argv)
     window.show();
     window.ogreWidget->initializeOgre();
 
-    RNR::World* world = new RNR::World();
+    RNR::World* world = new RNR::World(window.ogreWidget->ogreRoot, window.ogreWidget->ogreSceneManager);
-    Ogre::SceneNode* workspace_node = window.ogreWidget->ogreSceneManager->createSceneNode("Workspace");
+    Ogre::SceneNode* workspace_node = window.ogreWidget->ogreSceneManager->getRootSceneNode()->createChildSceneNode();
     workspace_node->attachObject(world->getWorkspace());
     workspace_node->setVisible(true);
     printf("main: workspace = %p (%p)\n",workspace_node, world->getWorkspace());

Projects/Engine/Header/App/V8/Tree/Instance.hpp

@@ -9,9 +9,15 @@
 
 namespace RNR
 {
+    class World;
+
     class Instance
     {
+        protected:
+            static World* world;
+
         private:
+
             std::string m_name;
             RNR::Instance* m_parent;
             std::vector<RNR::Instance*> m_children;
@@ -24,6 +30,8 @@ namespace RNR
             bool contains(RNR::Instance* child);
             bool isAncestorOf(RNR::Instance* instance);
 
+            static void setWorld(World* world) { Instance::world = world; }
+
             virtual bool askSetParent(RNR::Instance* instance); // derive this
             bool canSetParent(RNR::Instance* instance);
             virtual bool askAddChild(RNR::Instance* instance); // derive this

Projects/Engine/Header/App/V8/World/Workspace.hpp

@@ -18,6 +18,9 @@ namespace RNR
         virtual Ogre::Real getBoundingRadius(void) const;
         virtual void visitRenderables(Ogre::Renderable::Visitor* visitor, bool debugRenderables);
     private:
+        Ogre::AxisAlignedBox m_bbox;
+        Ogre::String m_type;
+        
         void renderQueueAddInstance(Ogre::RenderQueue* queue, Instance* instance);
     };
 }

Projects/Engine/Header/App/V8/World/World.hpp

@@ -2,6 +2,7 @@
 
 #include <App/V8/Tree/Instance.hpp>
 #include <App/V8/World/Workspace.hpp>
+#include <OGRE/Ogre.h>
 
 namespace RNR
 {
@@ -10,9 +11,11 @@ namespace RNR
         private:
             Instance* m_datamodel;
             Workspace* m_workspace;
+            Ogre::Root* m_ogreRoot;
+            Ogre::SceneManager* m_ogreSceneManager;
 
         public:
-            World();
+            World(Ogre::Root* ogre, Ogre::SceneManager* ogreScene);
             ~World();
 
             void preStep();
@@ -23,5 +26,7 @@ namespace RNR
             void setDatamodel(Instance* instance) { m_datamodel = instance; }
             Workspace* getWorkspace() { return m_workspace; }
             void setWorkspace(Workspace* workspace) { m_workspace = workspace; }
+            Ogre::Root* getOgreRoot() { return m_ogreRoot; }
+            Ogre::SceneManager* getOgreSceneManager() { return m_ogreSceneManager; }
     };
 }

Projects/Engine/Source/App/V8/DataModel/BasePart.cpp

@@ -1,14 +1,17 @@
 #include <App/V8/DataModel/BasePart.hpp>
+#include <App/V8/World/World.hpp>
 
 namespace RNR
 {
     Ogre::MeshPtr BasePart::m_partMesh = 0;
 
-    BasePart::BasePart() : m_matrix(), PVInstance()
+    BasePart::BasePart() : m_matrix(), PVInstance(), Ogre::Renderable()
     {
         setName("Part");
-        
+
         updateMatrix();
+        m_nearbyLights = Ogre::LightList();
+        m_nearbyLights.insert(m_nearbyLights.begin(), world->getOgreSceneManager()->getLight("SunLight"));
 
         m_material = Ogre::MaterialManager::getSingletonPtr()->create("part", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
 
@@ -20,24 +23,31 @@ namespace RNR
     {
         m_matrix = m_cframe.getMatrix();
         m_position = m_cframe.getPosition();
-        m_nearbyLights = Ogre::LightList();
-
     }
 
     const Ogre::MaterialPtr& BasePart::getMaterial() const
     {
-        return m_material;
+        Ogre::SubMesh* submesh = m_partMesh->getSubMesh(0);
+        return submesh->getMaterial();
     }
 
     void BasePart::getRenderOperation(Ogre::RenderOperation& op)
     {
         Ogre::SubMesh* submesh = m_partMesh->getSubMesh(0);
-        op.operationType = op.OT_TRIANGLE_LIST;
+        if(submesh)
-        op.vertexData = submesh->vertexData;
+        {
-        op.indexData = submesh->indexData;
+            op.operationType = op.OT_TRIANGLE_LIST;
-        op.numberOfInstances = 1;
+            if(submesh->useSharedVertices == false)
-        op.srcRenderable = this;
+                op.vertexData = submesh->vertexData;
-        op.useIndexes = true;
+            else
+                op.vertexData = m_partMesh->sharedVertexData;
+            op.indexData = submesh->indexData;
+            op.numberOfInstances = 1;
+            op.srcRenderable = this;
+            op.useIndexes = true;
+        }
+        else
+            printf("BasePart::getRenderOperation: couldnt get submesh\n");
     }
 
     Ogre::Real BasePart::getSquaredViewDepth(const Ogre::Camera* cam) const
@@ -53,6 +63,6 @@ namespace RNR
 
     void BasePart::getWorldTransforms(Ogre::Matrix4* xform) const
     {
-        xform[0] = m_matrix;
+        *xform = m_matrix;
     }
 }

Projects/Engine/Source/App/V8/Tree/Instance.cpp

@@ -2,6 +2,8 @@
 
 namespace RNR
 {
+    World* Instance::world = 0;
+
     Instance::Instance()
     {
         m_parent = 0;

Projects/Engine/Source/App/V8/World/Workspace.cpp

@@ -6,11 +6,12 @@ namespace RNR
     Workspace::Workspace() : Instance(), Ogre::MovableObject()
     {
         setName("Workspace");
+        m_type = Ogre::String("Entity");
+        m_bbox = Ogre::AxisAlignedBox(-1000,-1000,-1000, 1000,1000,1000);
     }
 
     void Workspace::_updateRenderQueue(Ogre::RenderQueue* queue)
     {
-        printf("!!!!!!!!!!!!!!!!!!!!1 _updateRenderQueue\n");
         std::vector<Instance*>* children = getChildren();
         for(auto& child : *children)
         {
@@ -21,22 +22,24 @@ namespace RNR
     void Workspace::renderQueueAddInstance(Ogre::RenderQueue* queue, Instance* instance)
     {
         std::vector<Instance*>* children = instance->getChildren();
+        BasePart* rend = dynamic_cast<BasePart*>(instance);        
+        queue->addRenderable(rend);
+
         for(auto& child : *children)
         {
             renderQueueAddInstance(queue, child);
         } 
-        BasePart* rend = dynamic_cast<BasePart*>(instance);        
-        queue->addRenderable(rend);
     }
 
     const Ogre::String& Workspace::getMovableType(void) const
     {
-        return Ogre::String("Entity");
+        printf("Workspace::getMovableType\n");
+        return m_type;
     }
 
     const Ogre::AxisAlignedBox& Workspace::getBoundingBox(void) const
     {
-        return Ogre::AxisAlignedBox(Ogre::Vector3(-1000,-1000,-1000),Ogre::Vector3(1000,1000,1000));
+        return m_bbox;
     }
 
     Ogre::Real Workspace::getBoundingRadius(void) const

Projects/Engine/Source/App/V8/World/World.cpp

@@ -3,8 +3,12 @@
 
 namespace RNR
 {
-    World::World()
+    World::World(Ogre::Root* ogre, Ogre::SceneManager* ogreSceneManager)
     {
+        Instance::setWorld(this);
+
+        m_ogreRoot = ogre;
+        m_ogreSceneManager = ogreSceneManager;
         m_datamodel = new Instance();
         m_datamodel->setName("DataModel");
         m_workspace = new Workspace();