Now using scene graph nodes for instance and bound extents management.

--HG--
extra : convert_revision : svn%3A7752d6cf-9f14-4ad2-affc-04f1e67b81a5/trunk%4035

KREngine/KREngine/Classes/KRInstance.cpp

@@ -53,7 +53,7 @@ tinyxml2::XMLElement *KRInstance::saveXML( tinyxml2::XMLNode *parent)
 {
     tinyxml2::XMLElement *e = KRNode::saveXML(parent);
     e->SetAttribute("mesh_name", m_model_name.c_str());
-    e->SetAttribute("lightmap", m_shadowMap.c_str());
+    e->SetAttribute("light_map", m_shadowMap.c_str());
     return e;
 }
 
@@ -64,14 +64,14 @@ KRMat4 &KRInstance::getModelMatrix() {
 
 #if TARGET_OS_IPHONE
 
-void KRInstance::render(KRCamera *pCamera, KRModelManager *pModelManager, KRMaterialManager *pMaterialManager, bool bRenderShadowMap, KRMat4 &viewMatrix, KRVector3 &cameraPosition, KRVector3 &lightDirection, KRMat4 *pShadowMatrices, GLuint *shadowDepthTextures, int cShadowBuffers, KRShaderManager *pShaderManager, KRTextureManager *pTextureManager) {
+void KRInstance::render(KRCamera *pCamera, KRModelManager *pModelManager, KRBoundingVolume &frustrumVolume, KRMaterialManager *pMaterialManager, bool bRenderShadowMap, KRMat4 &viewMatrix, KRVector3 &cameraPosition, KRVector3 &lightDirection, KRMat4 *pShadowMatrices, GLuint *shadowDepthTextures, int cShadowBuffers, KRShaderManager *pShaderManager, KRTextureManager *pTextureManager) {
     
     if(m_pModel == NULL) {
         m_pModel = pModelManager->getModel(m_model_name.c_str());
     }
     
-    if(m_pModel != NULL) {
+    if(m_pModel != NULL && (getExtents(pModelManager).test_intersect(frustrumVolume) || bRenderShadowMap)) {
-        
+
         if(m_pShadowMap == NULL && m_shadowMap.size()) {
             m_pShadowMap = pTextureManager->getTexture(m_shadowMap.c_str());
         }
@@ -101,16 +101,23 @@ void KRInstance::render(KRCamera *pCamera, KRModelManager *pModelManager, KRMate
             
     }
     
+    KRNode::render(pCamera, pModelManager, frustrumVolume, pMaterialManager, bRenderShadowMap, viewMatrix, cameraPosition, lightDirection, pShadowMatrices, shadowDepthTextures, cShadowBuffers, pShaderManager, pTextureManager);
 }
 
 #endif
 
-KRBoundingVolume KRInstance::getExtents(KRModelManager *pModelManager) {
+void KRInstance::calcExtents(KRModelManager *pModelManager) {
+    KRNode::calcExtents(pModelManager);
     if(m_pModel == NULL) {
         m_pModel = pModelManager->getModel(m_model_name.c_str());
     }
     assert(m_pModel != NULL);
     
     KRMesh *pMesh = m_pModel->getMesh();
-    return KRBoundingVolume(KRVector3(pMesh->getMinX(), pMesh->getMinY(), pMesh->getMinZ()), KRVector3(pMesh->getMaxX(), pMesh->getMaxY(), pMesh->getMaxZ()), m_modelMatrix);
+    KRBoundingVolume mesh_bounds = KRBoundingVolume(KRVector3(pMesh->getMinX(), pMesh->getMinY(), pMesh->getMinZ()), KRVector3(pMesh->getMaxX(), pMesh->getMaxY(), pMesh->getMaxZ()), m_modelMatrix);
+    if(m_pExtents) {
+        *m_pExtents = m_pExtents->get_union(mesh_bounds);
+    } else {
+        m_pExtents = new KRBoundingVolume(mesh_bounds);
+    }
 }

KREngine/KREngine/Classes/KRInstance.h

@@ -58,11 +58,10 @@ public:
     
 #if TARGET_OS_IPHONE
     
-    void render(KRCamera *pCamera, KRModelManager *pModelManager, KRMaterialManager *pMaterialManager, bool bRenderShadowMap, KRMat4 &viewMatrix,  KRVector3 &cameraPosition, KRVector3 &lightDirection, KRMat4 *pShadowMatrices, GLuint *shadowDepthTextures, int cShadowBuffers, KRShaderManager *pShaderManager, KRTextureManager *pTextureManager);
+    virtual void render(KRCamera *pCamera, KRModelManager *pModelManager, KRBoundingVolume &frustrumVolume, KRMaterialManager *pMaterialManager, bool bRenderShadowMap, KRMat4 &viewMatrix, KRVector3 &cameraPosition, KRVector3 &lightDirection, KRMat4 *pShadowMatrices, GLuint *shadowDepthTextures, int cShadowBuffers, KRShaderManager *pShaderManager, KRTextureManager *pTextureManager);
-    
 #endif
     
-    KRBoundingVolume getExtents(KRModelManager *pModelManager);
+    virtual void calcExtents(KRModelManager *pModelManager);
     
     KRMat4 &getModelMatrix();
     

KREngine/KREngine/Classes/KRNode.cpp

@@ -12,14 +12,17 @@
 #import "KRPointLight.h"
 #import "KRSpotLight.h"
 #import "KRDirectionalLight.h"
+#import "KRInstance.h"
 
 
 KRNode::KRNode(std::string name)
 {
+    m_pExtents = NULL;
     m_name = name;
     m_localScale = KRVector3(1.0f, 1.0f, 1.0f);
     m_localRotation = KRVector3(0.0f, 0.0f, 0.0f);
     m_localTranslation = KRVector3(0.0f, 0.0f, 0.0f);
+    m_parentNode = NULL;
 }
 
 KRNode::~KRNode() {
@@ -27,10 +30,14 @@ KRNode::~KRNode() {
         delete *itr;
     }
     m_childNodes.clear();
+    clearExtents();
 }
 
 void KRNode::addChild(KRNode *child) {
+    assert(child->m_parentNode == NULL);
+    child->m_parentNode = this;
     m_childNodes.push_back(child);
+    clearExtents();
 }
 
 tinyxml2::XMLElement *KRNode::saveXML(tinyxml2::XMLNode *parent) {
@@ -78,16 +85,20 @@ void KRNode::loadXML(tinyxml2::XMLElement *e) {
             addChild(child_node);
         }
     }
+    clearExtents();
 }
 
 void KRNode::setLocalTranslation(const KRVector3 &v) {
     m_localTranslation = v;
+    clearExtents();
 }
 void KRNode::setLocalScale(const KRVector3 &v) {
     m_localScale = v;
+    clearExtents();
 }
 void KRNode::setLocalRotation(const KRVector3 &v) {
     m_localRotation = v;
+    clearExtents();
 }
 
 const KRVector3 &KRNode::getLocalTranslation() {
@@ -117,6 +128,7 @@ KRNode *KRNode::LoadXML(tinyxml2::XMLElement *e) {
     } else if(strcmp(szElementName, "spot_light") == 0) {
         new_node = new KRSpotLight(szName);
     } else if(strcmp(szElementName, "mesh") == 0) {
+        new_node = new KRInstance(szName, szName, KRMat4(), e->Attribute("light_map"));
         
     }
     
@@ -127,3 +139,43 @@ KRNode *KRNode::LoadXML(tinyxml2::XMLElement *e) {
     return new_node;
 }
 
+#if TARGET_OS_IPHONE
+
+void KRNode::render(KRCamera *pCamera, KRModelManager *pModelManager, KRBoundingVolume &frustrumVolume, KRMaterialManager *pMaterialManager, bool bRenderShadowMap, KRMat4 &viewMatrix, KRVector3 &cameraPosition, KRVector3 &lightDirection, KRMat4 *pShadowMatrices, GLuint *shadowDepthTextures, int cShadowBuffers, KRShaderManager *pShaderManager, KRTextureManager *pTextureManager) {
+    
+    for(std::vector<KRNode *>::iterator itr=m_childNodes.begin(); itr < m_childNodes.end(); ++itr) {
+        KRNode *child = (*itr);
+        child->render(pCamera, pModelManager, frustrumVolume, pMaterialManager, bRenderShadowMap, viewMatrix, cameraPosition, lightDirection, pShadowMatrices, shadowDepthTextures, cShadowBuffers, pShaderManager, pTextureManager);
+    }
+}
+
+#endif
+
+void KRNode::clearExtents() {
+    if(m_pExtents) {
+        delete m_pExtents;
+        m_pExtents = NULL;
+    }
+    if(m_parentNode) {
+        m_parentNode->clearExtents();
+    }
+}
+
+KRBoundingVolume KRNode::getExtents(KRModelManager *pModelManager) {
+    if(!m_pExtents) {
+        calcExtents(pModelManager);
+    }
+    return *m_pExtents;
+}
+
+void KRNode::calcExtents(KRModelManager *pModelManager) {
+    clearExtents();
+    for(std::vector<KRNode *>::iterator itr=m_childNodes.begin(); itr < m_childNodes.end(); ++itr) {
+        KRNode *child = (*itr);
+        if(m_pExtents) {
+            *m_pExtents = m_pExtents->get_union(child->getExtents(pModelManager));
+        } else {
+            m_pExtents = new KRBoundingVolume(child->getExtents(pModelManager));
+        }
+    }
+}

KREngine/KREngine/Classes/KRNode.h

@@ -12,6 +12,13 @@
 #import "KRResource.h"
 #import "KRVector3.h"
 #import "tinyxml2.h"
+class KRBoundingVolume;
+class KRCamera;
+class KRShaderManager;
+class KRModelManager;
+class KRMaterialManager;
+class KRMat4;
+class KRTextureManager;
 
 class KRNode
 {
@@ -35,6 +42,18 @@ public:
     const KRVector3 &getLocalScale();
     const KRVector3 &getLocalRotation();
     
+    void clearExtents();
+    virtual void calcExtents(KRModelManager *pModelManager);
+    KRBoundingVolume getExtents(KRModelManager *pModelManager);    
+#if TARGET_OS_IPHONE
+    
+    virtual void render(KRCamera *pCamera, KRModelManager *pModelManager, KRBoundingVolume &frustrumVolume, KRMaterialManager *pMaterialManager, bool bRenderShadowMap, KRMat4 &viewMatrix, KRVector3 &cameraPosition, KRVector3 &lightDirection, KRMat4 *pShadowMatrices, GLuint *shadowDepthTextures, int cShadowBuffers, KRShaderManager *pShaderManager, KRTextureManager *pTextureManager);
+
+#endif
+    
+protected:
+    KRBoundingVolume *m_pExtents;
+    
 private:
     KRVector3 m_localTranslation;
     KRVector3 m_localScale;
@@ -43,6 +62,8 @@ private:
     std::string m_name;
     
     std::vector<KRNode *> m_childNodes;
+    KRNode *m_parentNode;
+    
 };
 
 

KREngine/KREngine/Classes/KRScene.cpp

@@ -38,25 +38,12 @@
 #import "KRScene.h"
 
 KRScene::KRScene(std::string name) : KRResource(name) {
-    m_pExtents = NULL;
+
     m_pRootNode = new KRNode("scene_root");
 }
-KRScene::~KRScene() {
+KRScene::~KRScene() {    
-    for(vector<KRInstance *>::iterator itr = m_instances.begin(); itr != m_instances.end(); ++itr){
-        delete *itr;
-    }
-    m_instances.empty();
-    
     delete m_pRootNode;
     m_pRootNode = NULL;
-    
-    clearExtents();
-}
-KRInstance *KRScene::addInstance(std::string instance_name, std::string model_name, KRMat4 modelMatrix, std::string shadow_map) {
-    clearExtents();
-    KRInstance *pInstance = new KRInstance(instance_name, model_name, modelMatrix, shadow_map);
-    m_instances.push_back(pInstance);
-    return pInstance;
 }
 
 #if TARGET_OS_IPHONE
@@ -89,43 +76,14 @@ void KRScene::render(KRCamera *pCamera, KRModelManager *pModelManager, KRBoundin
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
     }
-    
+
-    
+    m_pRootNode->render(pCamera, pModelManager, frustrumVolume, pMaterialManager, bRenderShadowMap, viewMatrix, cameraPosition, lightDirection, pShadowMatrices, shadowDepthTextures, cShadowBuffers, pShaderManager, pTextureManager);
-    for(vector<KRInstance *>::iterator itr = m_instances.begin(); itr != m_instances.end(); ++itr){
-        KRInstance *pInstance = *itr;
-        
-        if(pInstance->getExtents(pModelManager).test_intersect(frustrumVolume) || bRenderShadowMap) {
-            pInstance->render(pCamera, pModelManager, pMaterialManager, bRenderShadowMap, viewMatrix, cameraPosition, lightDirection, pShadowMatrices, shadowDepthTextures, cShadowBuffers, pShaderManager, pTextureManager);
-        }
-    }
 }
 
 #endif
 
-void KRScene::calcExtents(KRModelManager *pModelManager) {
-    clearExtents();
-    for(vector<KRInstance *>::iterator itr = m_instances.begin(); itr != m_instances.end(); ++itr){
-        KRInstance *pInstance = *itr;
-        if(m_pExtents) {
-            *m_pExtents = m_pExtents->get_union(pInstance->getExtents(pModelManager));
-        } else {
-            m_pExtents = new KRBoundingVolume(pInstance->getExtents(pModelManager));
-        }
-    }
-}
-
 KRBoundingVolume KRScene::getExtents(KRModelManager *pModelManager) {
-    if(!m_pExtents) {
+    return m_pRootNode->getExtents(pModelManager);
-        calcExtents(pModelManager);
-    }
-    return *m_pExtents;
-}
-
-void KRScene::clearExtents() {
-    if(m_pExtents) {
-        delete m_pExtents;
-        m_pExtents = NULL;
-    }
 }
 
 

KREngine/KREngine/Classes/KRScene.h

@@ -57,7 +57,6 @@ public:
     
     static KRScene *LoadXML(const std::string& path);
     
-    KRInstance *addInstance(std::string instance_name, std::string model_name, KRMat4 modelMatrix, std::string shadow_map);
     KRNode *getRootNode();
     
 #if TARGET_OS_IPHONE
@@ -68,14 +67,9 @@ public:
     
     KRBoundingVolume getExtents(KRModelManager *pModelManager);
 private:
-    vector<KRInstance *> m_instances;
     KRNode *m_pRootNode;
-    
-    
     KRBoundingVolume *m_pExtents;
-    
+
-    void calcExtents(KRModelManager *pModelManager);
-    void clearExtents();
 };
 
 

objview/Classes/KRObjViewGLView.h

@@ -45,10 +45,7 @@
 	/* OpenGL names for the renderbuffer and framebuffers used to render to this view */
 	GLuint viewFramebuffer, viewRenderbuffer;
     
-    KREngine *renderEngine;
+    KREngine *renderEngine;	
-    
-    KRScene *m_pScene;
-	
 }
 
 // OpenGL drawing

objview/Classes/KRObjViewGLView.mm

@@ -86,10 +86,6 @@
 }
 
 - (void)dealloc {
-    if(m_pScene) {
-        delete m_pScene;
-        m_pScene = NULL;
-    }
     if(renderEngine) {
         [renderEngine release];
         renderEngine = nil;
@@ -102,9 +98,7 @@
 #pragma mark OpenGL drawing
 
 - (BOOL)loadObjects
-{
+{    
-    m_pScene = new KRScene("default");
-    
     NSString *documentsDirectory = [NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES) objectAtIndex:0];
     NSFileManager* fileManager = [NSFileManager defaultManager];
     
@@ -149,7 +143,7 @@
     //m_scene.addInstance(pModelManager->getModel("HoganCombined"), KRMat4());
     //m_scene.addInstance(pModelManager->getModel("polySurface12848"), KRMat4(), "PillarLightmap2k");
     //m_scene.addInstance(pModelManager->getModel("Wall2"), KRMat4(), "Wall2_lightmap");
-    
+    /*
     std::map<std::string, KRModel *> models = pModelManager->getModels();
     for(std::map<std::string, KRModel *>::iterator itr=models.begin(); itr != models.end(); itr++) {
         std::string lightmap = (*itr).first;
@@ -157,6 +151,7 @@
         m_pScene->addInstance((*itr).second->getName(), (*itr).second->getName(), KRMat4(), lightmap);
         
     }
+     */
     
     [renderEngine setNearZ: 25.0];
     [renderEngine setFarZ: 5000.0];
@@ -262,7 +257,7 @@
 
 - (KRScene *)getScene;
 {
-    return m_pScene;
+    return renderEngine.getSceneManager->getFirstScene();
 }
 
 #pragma mark -

objview/Classes/KRObjViewViewController.mm

@@ -213,47 +213,21 @@
     
     if(bUpdateParam) {
         bUpdateParam = false;
-        if(iParam == [engine getParameterCount] && dRightSlider > 0.9) {
+        
-            if(!bLoadedTestInstances) {
+        double dValue = dRightSlider * ([engine getParameterMaxWithIndex: iParam] - [engine getParameterMinWithIndex: iParam]) + [engine getParameterMinWithIndex: iParam];
-                bLoadedTestInstances = true;
+        switch([engine getParameterTypeWithIndex: iParam]) {
-                
+            case KRENGINE_PARAMETER_INT:
-                KRModelManager *pModelManager = [engine getModelManager];
+                dValue = dRightSlider * ([engine getParameterMaxWithIndex: iParam] + 0.5 - [engine getParameterMinWithIndex: iParam]) + [engine getParameterMinWithIndex: iParam];
-
+                [engine setParameterValueWithIndex: iParam Value: dValue];
-                KRScene *scene =[glView getScene];
+                break;
-                
+            case KRENGINE_PARAMETER_BOOL:
-                 srand ( time(NULL) );
+                [engine setParameterValueWithIndex: iParam Value: 1.0 - dValue];
-                 for(int iHouse=1; iHouse < 12; iHouse++) {
+                break;
-                     for(int iInstance=0; iInstance < 20; iInstance++) {
+            case KRENGINE_PARAMETER_FLOAT:
-                         char szName[100];
+                [engine setParameterValueWithIndex: iParam Value: dValue];
-                         sprintf(szName, "fachwerkhaus%i", iHouse);
+                break;
-                         KRMat4 pos;
-                         
-                         pos.rotate((double)rand() / (double)RAND_MAX * 6.282, Y_AXIS);
-                         pos.translate((double)rand() / (double)RAND_MAX * 10000 - 5000, 0.0, (double)rand() / (double)RAND_MAX * 10000 - 5000);
-                         
-                         scene->addInstance(szName, szName, pos, "");
-                     }
-                 }
-                
-            }
-
-        } else {
-            double dValue = dRightSlider * ([engine getParameterMaxWithIndex: iParam] - [engine getParameterMinWithIndex: iParam]) + [engine getParameterMinWithIndex: iParam];
-            switch([engine getParameterTypeWithIndex: iParam]) {
-                case KRENGINE_PARAMETER_INT:
-                    dValue = dRightSlider * ([engine getParameterMaxWithIndex: iParam] + 0.5 - [engine getParameterMinWithIndex: iParam]) + [engine getParameterMinWithIndex: iParam];
-                    [engine setParameterValueWithIndex: iParam Value: dValue];
-                    break;
-                case KRENGINE_PARAMETER_BOOL:
-                    [engine setParameterValueWithIndex: iParam Value: 1.0 - dValue];
-                    break;
-                case KRENGINE_PARAMETER_FLOAT:
-                    [engine setParameterValueWithIndex: iParam Value: dValue];
-                    break;
-            }
-            
-
         }
+
     }