Implemented KRContext class to reduce the parameter count of method calls

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

KREngine/KREngine/Classes/KRBoundingVolume.cpp

@@ -193,8 +193,8 @@ bool KRBoundingVolume::test_intersect(const KRBoundingVolume &p) const {
 }
 
 
-KRMat4 KRBoundingVolume::calcShadowProj(KRScene *pScene, KRModelManager *pModelManager, GLfloat sun_yaw, GLfloat sun_pitch) const {
-    KRBoundingVolume sceneVolume = pScene->getExtents(pModelManager);
+KRMat4 KRBoundingVolume::calcShadowProj(KRScene *pScene, KRContext *pContext, GLfloat sun_yaw, GLfloat sun_pitch) const {
+    KRBoundingVolume sceneVolume = pScene->getExtents(pContext);
    
     KRMat4 shadowvp;
     shadowvp.rotate(sun_pitch, X_AXIS);

KREngine/KREngine/Classes/KRBoundingVolume.h

@@ -41,6 +41,7 @@
 #import "KRModelManager.h"
 
 class KRScene;
+class KRContext;
 
 class KRBoundingVolume {
 public:
@@ -55,7 +56,7 @@ public:
     KRBoundingVolume get_union(const KRBoundingVolume &p) const;
     bool test_intersect(const KRBoundingVolume &p) const;
     
-    KRMat4 calcShadowProj(KRScene *pScene, KRModelManager *pModelManager, GLfloat sun_yaw, GLfloat sun_pitch) const;
+    KRMat4 calcShadowProj(KRScene *pScene, KRContext *pContext, GLfloat sun_yaw, GLfloat sun_pitch) const;
 private:
     KRVector3 m_vertices[8];
 };

KREngine/KREngine/Classes/KRContext.cpp

@@ -0,0 +1,81 @@
+//
+//  KRContext.cpp
+//  KREngine
+//
+//  Created by Kearwood Gilbert on 12-04-12.
+//  Copyright (c) 2012 Kearwood Software. All rights reserved.
+//
+
+#include <iostream>
+
+#include "KRContext.h"
+
+KRContext::KRContext(const GLchar *szVertShaderSource, const GLchar *szFragShaderSource) {
+     m_pShaderManager = new KRShaderManager(szVertShaderSource, szFragShaderSource);
+     m_pTextureManager = new KRTextureManager();
+     m_pMaterialManager = new KRMaterialManager(m_pTextureManager, m_pShaderManager);
+     m_pModelManager = new KRModelManager();
+     m_pSceneManager = new KRSceneManager();
+}
+
+KRContext::~KRContext() {
+    if(m_pSceneManager) {
+        delete m_pSceneManager;
+        m_pSceneManager = NULL;
+    }
+    
+    if(m_pModelManager) {
+        delete m_pModelManager;
+        m_pModelManager = NULL;
+    }
+    
+    if(m_pTextureManager) {
+        delete m_pTextureManager;
+        m_pTextureManager = NULL;
+    }
+    
+    if(m_pMaterialManager) {
+        delete m_pMaterialManager;
+        m_pMaterialManager = NULL;
+    }
+    
+    if(m_pShaderManager) {
+        delete m_pShaderManager;
+        m_pShaderManager = NULL;
+    }
+}
+
+
+KRSceneManager *KRContext::getSceneManager() {
+    return m_pSceneManager;
+}
+KRTextureManager *KRContext::getTextureManager() {
+    return m_pTextureManager;
+}
+KRMaterialManager *KRContext::getMaterialManager() {
+    return m_pMaterialManager;
+}
+KRShaderManager *KRContext::getShaderManager() {
+    return m_pShaderManager;
+}
+KRModelManager *KRContext::getModelManager() {
+    return m_pModelManager;
+}
+
+void KRContext::loadResource(std::string path) {
+    std::string name = KRResource::GetFileBase(path);
+    std::string extension = KRResource::GetFileExtension(path);
+    if(extension.compare("krobject") == 0) {
+        m_pModelManager->loadModel(name.c_str(), path.c_str());
+    } else if(extension.compare("krscene") == 0) {
+        m_pSceneManager->loadScene(name.c_str(), path.c_str());
+#if TARGET_OS_IPHONE
+    } else if(extension.compare("pvr") == 0) {
+        m_pTextureManager->loadTexture(name.c_str(), path.c_str());
+#endif
+    } else if(extension.compare("mtl") == 0) {
+        m_pMaterialManager->loadFile(path.c_str());
+    } else {
+        fprintf(stderr, "KRContext::loadResource - Unknown resource file type: %s\n", path.c_str());
+    }
+}

KREngine/KREngine/Classes/KRContext.h

@@ -0,0 +1,39 @@
+//
+//  KRContext.h
+//  KREngine
+//
+//  Created by Kearwood Gilbert on 12-04-12.
+//  Copyright (c) 2012 Kearwood Software. All rights reserved.
+//
+
+#ifndef KREngine_KRContext_h
+#define KREngine_KRContext_h
+
+#import "KRSceneManager.h"
+#import "KRTextureManager.h"
+#import "KRMaterialManager.h"
+#import "KRShaderManager.h"
+#import "KRModelManager.h"
+
+class KRContext {
+public:
+    KRContext(const GLchar *szVertShaderSource, const GLchar *szFragShaderSource);
+    ~KRContext();
+    
+    void loadResource(std::string path);
+    
+    KRSceneManager *getSceneManager();
+    KRTextureManager *getTextureManager();
+    KRMaterialManager *getMaterialManager();
+    KRShaderManager *getShaderManager();
+    KRModelManager *getModelManager();
+    
+private:
+    KRSceneManager *m_pSceneManager;
+    KRTextureManager *m_pTextureManager;
+    KRMaterialManager *m_pMaterialManager;
+    KRShaderManager *m_pShaderManager;
+    KRModelManager *m_pModelManager;
+};
+
+#endif

KREngine/KREngine/Classes/KREngine.h

@@ -35,11 +35,7 @@
 #import "KRVector3.h"
 #import "KRModel.h"
 #import "KRScene.h"
-#import "KRTextureManager.h"
-#import "KRMaterialManager.h"
-#import "KRShaderManager.h"
-#import "KRModelManager.h"
-#import "KRSceneManager.h"
+#import "KRContext.h"
 #import "KRCamera.h"
 
 #import "KREngine-common.h"
@@ -81,11 +77,7 @@ typedef enum KREngineParameterType {KRENGINE_PARAMETER_INT, KRENGINE_PARAMETER_F
     GLuint m_postShaderProgram;
     GLuint m_shadowShaderProgram;
     
-    KRSceneManager *m_pSceneManager;
-    KRTextureManager *m_pTextureManager;
-    KRMaterialManager *m_pMaterialManager;
-    KRShaderManager *m_pShaderManager;
-    KRModelManager *m_pModelManager;
+    KRContext *m_pContext;
     
     int m_iFrame;
 
@@ -96,6 +88,8 @@ typedef enum KREngineParameterType {KRENGINE_PARAMETER_INT, KRENGINE_PARAMETER_F
     
 }
 
+@property(nonatomic, readonly) KRContext *context;
+
 - (id)initForWidth: (GLuint)width Height: (GLuint)height;
 
 - (BOOL)loadVertexShader:(NSString *)vertexShaderName fragmentShader:(NSString *)fragmentShaderName forProgram:(GLuint *)programPointer withOptions:(NSString *)options;
@@ -103,8 +97,6 @@ typedef enum KREngineParameterType {KRENGINE_PARAMETER_INT, KRENGINE_PARAMETER_F
 
 - (void)renderShadowBufferNumber: (int)iShadow ForScene: (KRScene *)pScene;
 - (void)renderScene: (KRScene *)pScene WithViewMatrix: (KRMat4)viewMatrix LightDirection: (KRVector3)lightDirection CameraPosition: (KRVector3)cameraPosition;
-- (KRModelManager *)getModelManager;
-- (KRSceneManager *)getSceneManager;
 - (void)invalidateShadowBuffers;
 - (void)allocateShadowBuffers;
 

KREngine/KREngine/Classes/KREngine.mm

@@ -53,6 +53,7 @@ using namespace std;
 @end
 
 @implementation KREngine
+@synthesize context = m_pContext;
 double const PI = 3.141592653589793f;
 
 - (id)initForWidth: (GLuint)width Height: (GLuint)height
@@ -79,11 +80,7 @@ double const PI = 3.141592653589793f;
         GLchar * szVertShaderSource = (GLchar *)[[NSString stringWithContentsOfFile:vertShaderPathname encoding:NSUTF8StringEncoding error:nil] UTF8String];
         GLchar * szFragShaderSource = (GLchar *)[[NSString stringWithContentsOfFile:fragShaderPathname encoding:NSUTF8StringEncoding error:nil] UTF8String];
         
-        m_pShaderManager = new KRShaderManager(szVertShaderSource, szFragShaderSource);
-        m_pTextureManager = new KRTextureManager();
-        m_pMaterialManager = new KRMaterialManager(m_pTextureManager, m_pShaderManager);
-        m_pModelManager = new KRModelManager(m_pMaterialManager);
-        m_pSceneManager = new KRSceneManager();
+        m_pContext = new KRContext(szVertShaderSource, szFragShaderSource);
         
         if (![self createBuffers] || ![self loadShaders] /*|| ![self loadObjects]*/ )
         {
@@ -226,12 +223,12 @@ double const PI = 3.141592653589793f;
         
         KRMat4 newShadowMVP;
         if(shadowMaxDepths[m_cShadowBuffers - 1][iShadow] == 0.0) {
-            KRBoundingVolume ext = KRBoundingVolume(pScene->getExtents(m_pModelManager));
+            KRBoundingVolume ext = KRBoundingVolume(pScene->getExtents(m_pContext));
             
-            newShadowMVP = ext.calcShadowProj(pScene, m_pModelManager, sun_yaw, sun_pitch);
+            newShadowMVP = ext.calcShadowProj(pScene, m_pContext, sun_yaw, sun_pitch);
         } else {
             KRBoundingVolume frustrumSliceVolume = KRBoundingVolume(viewMatrix, m_camera.perspective_fov, m_camera.perspective_aspect, m_camera.perspective_nearz + (m_camera.perspective_farz - m_camera.perspective_nearz) * shadowMinDepths[m_cShadowBuffers - 1][iShadow], m_camera.perspective_nearz + (m_camera.perspective_farz - m_camera.perspective_nearz) * shadowMaxDepths[m_cShadowBuffers - 1][iShadow]);
-            newShadowMVP = frustrumSliceVolume.calcShadowProj(pScene, m_pModelManager, sun_yaw, sun_pitch);
+            newShadowMVP = frustrumSliceVolume.calcShadowProj(pScene, m_pContext, sun_yaw, sun_pitch);
         }
         
         if(!(shadowmvpmatrix[iShadow] == newShadowMVP)) {
@@ -331,8 +328,7 @@ double const PI = 3.141592653589793f;
     KRVector3 cameraPosition;
     KRVector3 lightDirection;
     KRBoundingVolume shadowVolume = KRBoundingVolume(vertices);
-    pScene->render(&m_camera, m_pModelManager, shadowVolume, m_pMaterialManager, true, shadowmvpmatrix[iShadow], cameraPosition, lightDirection, shadowmvpmatrix, NULL, 0, m_pShaderManager, m_pTextureManager);
-    
+    pScene->render(&m_camera, m_pContext, shadowVolume, true, shadowmvpmatrix[iShadow], cameraPosition, lightDirection, shadowmvpmatrix, NULL, m_cShadowBuffers);
     glViewport(0, 0, 768, 1024);
 }
 
@@ -357,7 +353,7 @@ double const PI = 3.141592653589793f;
     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
     
     KRBoundingVolume frustrumVolume = KRBoundingVolume(viewMatrix, m_camera.perspective_fov, m_camera.perspective_aspect, m_camera.perspective_nearz, m_camera.perspective_farz);
-    pScene -> render(&m_camera, m_pModelManager, frustrumVolume, m_pMaterialManager, false, viewMatrix, cameraPosition, lightDirection, shadowmvpmatrix, shadowDepthTexture, m_cShadowBuffers, m_pShaderManager, m_pTextureManager);
+    pScene -> render(&m_camera, m_pContext, frustrumVolume, false, viewMatrix, cameraPosition, lightDirection, shadowmvpmatrix, shadowDepthTexture, m_cShadowBuffers);
 }
 
 - (BOOL)compileShader:(GLuint *)shader type:(GLenum)type file:(NSString *)file withOptions: (NSString *)options
@@ -540,49 +536,16 @@ double const PI = 3.141592653589793f;
 
 - (BOOL)loadResource:(NSString *)path
 {
-    NSString *name = [[path lastPathComponent] stringByDeletingPathExtension];
-    if([path hasSuffix: @".krobject"]) {
-        NSLog(@"object: %@", path);
-        m_pModelManager->loadModel([name UTF8String], [path UTF8String]);
-    } else if([path hasSuffix: @".krscene"]) {
-        NSLog(@"scene: %@", path);
-        m_pSceneManager->loadScene([name UTF8String], [path UTF8String]);
-    } else if([path hasSuffix: @".pvr"]) {
-        NSLog(@"texture: %@", path);
-        m_pTextureManager->loadTexture([name UTF8String], [path UTF8String]);
-    } else if([path hasSuffix: @".mtl"]) {
-        NSLog(@"material: %@", path);
-        m_pMaterialManager->loadFile([path UTF8String]);
-    }
+    m_pContext->loadResource([path UTF8String]);
     
     return TRUE;
 }
 
 - (void)dealloc
 {
-    if(m_pSceneManager) {
-        delete m_pSceneManager;
-        m_pSceneManager = NULL;
-    }
-    
-    if(m_pModelManager) {
-        delete m_pModelManager;
-        m_pModelManager = NULL;
-    }
-    
-    if(m_pTextureManager) {
-        delete m_pTextureManager;
-        m_pTextureManager = NULL;
-    }
-    
-    if(m_pMaterialManager) {
-        delete m_pMaterialManager;
-        m_pMaterialManager = NULL;
-    }
-    
-    if(m_pShaderManager) {
-        delete m_pShaderManager;
-        m_pShaderManager = NULL;
+    if(m_pContext) {
+        delete m_pContext;
+        m_pContext = NULL;
     }
     
     [self invalidatePostShader];
@@ -725,7 +688,7 @@ double const PI = 3.141592653589793f;
     
     const char *szText = [debug_text UTF8String];
     if(*szText) {
-        KRTexture *pFontTexture = m_pTextureManager->getTexture("font");
+        KRTexture *pFontTexture = m_pContext->getTextureManager()->getTexture("font");
         
         glDisable(GL_DEPTH_TEST);
         glUseProgram(m_postShaderProgram);
@@ -783,7 +746,7 @@ double const PI = 3.141592653589793f;
 
 -(int)getParameterCount
 {
-    return 30;
+    return 31;
 }
 
 -(NSString *)getParameterNameWithIndex: (int)i
@@ -1085,13 +1048,13 @@ double const PI = 3.141592653589793f;
 
 -(double)getParameterMinWithIndex: (int)i
 {
-    double minValues[30] = {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f};
+    double minValues[31] = {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f};
     return minValues[i];
 }
 
 -(double)getParameterMaxWithIndex: (int)i
 {
-    double maxValues[30] = {PI, 2.0f * PI, PI, 3.0f, 1.0f, 1.0f, 1.0f, 1.0f, 3.0f, 3.0f, 3.0f, 3.0f, 3.0f, 3.0f, 2.0f, 1.0f, 1.0f, 1.0f, 5.0f, 1.0f, 0.5f, 1.0f, 2.0f, 2.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f};
+    double maxValues[31] = {PI, 2.0f * PI, PI, 3.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 3.0f, 3.0f, 3.0f, 3.0f, 3.0f, 3.0f, 2.0f, 1.0f, 1.0f, 1.0f, 5.0f, 1.0f, 0.5f, 1.0f, 2.0f, 2.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f};
     return maxValues[i];
 }
 
@@ -1105,14 +1068,6 @@ double const PI = 3.141592653589793f;
     }
 }
 
-- (KRModelManager *)getModelManager {
-    return m_pModelManager;
-}
-
-- (KRSceneManager *)getSceneManager {
-    return m_pSceneManager;
-}
-
 - (void)invalidateShadowBuffers {
     for(int i=0; i < m_cShadowBuffers; i++) {
         shadowValid[i] = false;

KREngine/KREngine/Classes/KRInstance.cpp

@@ -31,6 +31,7 @@
 
 #include <iostream>
 #import "KRInstance.h"
+#import "KRContext.h"
 #include <assert.h>
 
 KRInstance::KRInstance(std::string instance_name, std::string model_name, const KRMat4 modelMatrix, std::string light_map) : KRNode(instance_name) {
@@ -64,16 +65,16 @@ KRMat4 &KRInstance::getModelMatrix() {
 
 #if TARGET_OS_IPHONE
 
-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) {
+void KRInstance::render(KRCamera *pCamera, KRContext *pContext, KRBoundingVolume &frustrumVolume, bool bRenderShadowMap, KRMat4 &viewMatrix, KRVector3 &cameraPosition, KRVector3 &lightDirection, KRMat4 *pShadowMatrices, GLuint *shadowDepthTextures, int cShadowBuffers) {
     
     if(m_pModel == NULL) {
-        m_pModel = pModelManager->getModel(m_model_name.c_str());
+        m_pModel = pContext->getModelManager()->getModel(m_model_name.c_str());
     }
     
-    if(m_pModel != NULL && (getExtents(pModelManager).test_intersect(frustrumVolume) || bRenderShadowMap)) {
+    if(m_pModel != NULL && (getExtents(pContext).test_intersect(frustrumVolume) || bRenderShadowMap)) {
 
         if(m_pLightMap == NULL && m_lightMap.size()) {
-            m_pLightMap = pTextureManager->getTexture(m_lightMap.c_str());
+            m_pLightMap = pContext->getTextureManager()->getTexture(m_lightMap.c_str());
         }
         
         if(cShadowBuffers == 0 && m_pLightMap && pCamera->bEnableLightMap && !bRenderShadowMap) {
@@ -97,19 +98,19 @@ void KRInstance::render(KRCamera *pCamera, KRModelManager *pModelManager, KRBoun
         KRVector3 cameraPosObject = inverseModelMatrix.dot(cameraPosition);
         KRVector3 lightDirObject = inverseModelMatrix.dot(lightDirection);
         
-        m_pModel->render(pCamera, pMaterialManager, bRenderShadowMap, mvpmatrix, cameraPosObject, lightDirection, pShadowMatrices, shadowDepthTextures, cShadowBuffers, pShaderManager, pTextureManager, m_pLightMap);
+        m_pModel->render(pCamera, pContext, bRenderShadowMap, mvpmatrix, cameraPosObject, lightDirection, pShadowMatrices, shadowDepthTextures, cShadowBuffers, m_pLightMap);
             
     }
     
-    KRNode::render(pCamera, pModelManager, frustrumVolume, pMaterialManager, bRenderShadowMap, viewMatrix, cameraPosition, lightDirection, pShadowMatrices, shadowDepthTextures, cShadowBuffers, pShaderManager, pTextureManager);
+    KRNode::render(pCamera, pContext, frustrumVolume, bRenderShadowMap, viewMatrix, cameraPosition, lightDirection, pShadowMatrices, shadowDepthTextures, cShadowBuffers);
 }
 
 #endif
 
-void KRInstance::calcExtents(KRModelManager *pModelManager) {
-    KRNode::calcExtents(pModelManager);
+void KRInstance::calcExtents(KRContext *pContext) {
+    KRNode::calcExtents(pContext);
     if(m_pModel == NULL) {
-        m_pModel = pModelManager->getModel(m_model_name.c_str());
+        m_pModel = pContext->getModelManager()->getModel(m_model_name.c_str());
     }
     assert(m_pModel != NULL);
     

KREngine/KREngine/Classes/KRInstance.h

@@ -44,6 +44,9 @@
 #import "KRCamera.h"
 #import "KRModelManager.h"
 #import "KRNode.h"
+#import "KRContext.h"
+#import "KRModel.h"
+#import "KRTexture.h"
 
 class KRBoundingVolume;
 
@@ -58,10 +61,10 @@ public:
     
 #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);
+    virtual void render(KRCamera *pCamera, KRContext *pContext, KRBoundingVolume &frustrumVolume, bool bRenderShadowMap, KRMat4 &viewMatrix, KRVector3 &cameraPosition, KRVector3 &lightDirection, KRMat4 *pShadowMatrices, GLuint *shadowDepthTextures, int cShadowBuffers);
 #endif
     
-    virtual void calcExtents(KRModelManager *pModelManager);
+    virtual void calcExtents(KRContext *pContext);
     
     KRMat4 &getModelMatrix();
     

KREngine/KREngine/Classes/KRMaterial.cpp

@@ -37,6 +37,8 @@
 #include <fcntl.h>
 #include <stdio.h>
 
+#import "KRcontext.h"
+
 KRMaterial::KRMaterial(const char *szName) : KRResource(szName) {
     strcpy(m_szName, szName);
     m_pAmbientMap = NULL;
@@ -156,21 +158,21 @@ bool KRMaterial::isTransparent() {
     return m_tr != 0.0;
 }
 #if TARGET_OS_IPHONE
-void KRMaterial::bind(KRMaterial **prevBoundMaterial, char *szPrevShaderKey, KRCamera *pCamera, KRMat4 &mvpMatrix, KRVector3 &cameraPosition, KRVector3 &lightDirection, KRMat4 *pShadowMatrices, GLuint *shadowDepthTextures, int cShadowBuffers, KRShaderManager *pShaderManager, KRTextureManager *pTextureManager, KRTexture *pLightMap) {
+void KRMaterial::bind(KRMaterial **prevBoundMaterial, char *szPrevShaderKey, KRCamera *pCamera, KRMat4 &mvpMatrix, KRVector3 &cameraPosition, KRVector3 &lightDirection, KRMat4 *pShadowMatrices, GLuint *shadowDepthTextures, int cShadowBuffers, KRContext *pContext, KRTexture *pLightMap) {
     bool bSameMaterial = *prevBoundMaterial == this;
     bool bLightMap = pLightMap && pCamera->bEnableLightMap;
     
     if(!m_pAmbientMap && m_ambientMap.size()) {
-        m_pAmbientMap = pTextureManager->getTexture(m_ambientMap.c_str());
+        m_pAmbientMap = pContext->getTextureManager()->getTexture(m_ambientMap.c_str());
     }
     if(!m_pDiffuseMap && m_diffuseMap.size()) {
-        m_pDiffuseMap = pTextureManager->getTexture(m_diffuseMap.c_str());
+        m_pDiffuseMap = pContext->getTextureManager()->getTexture(m_diffuseMap.c_str());
     }
     if(!m_pNormalMap && m_normalMap.size()) {
-        m_pNormalMap = pTextureManager->getTexture(m_normalMap.c_str());
+        m_pNormalMap = pContext->getTextureManager()->getTexture(m_normalMap.c_str());
     }
     if(!m_pSpecularMap && m_specularMap.size()) {
-        m_pSpecularMap = pTextureManager->getTexture(m_specularMap.c_str());
+        m_pSpecularMap = pContext->getTextureManager()->getTexture(m_specularMap.c_str());
     }
     
     
@@ -185,7 +187,7 @@ void KRMaterial::bind(KRMaterial **prevBoundMaterial, char *szPrevShaderKey, KRC
         bool bNormalMap = m_pNormalMap != NULL && pCamera->bEnableNormalMap;
         bool bSpecMap = m_pSpecularMap != NULL && pCamera->bEnableSpecMap;
         
-        KRShader *pShader = pShaderManager->getShader(pCamera, bDiffuseMap, bNormalMap, bSpecMap, cShadowBuffers, bLightMap, m_diffuseMapScale != default_scale && bDiffuseMap, m_specularMapScale != default_scale && bSpecMap, m_normalMapScale != default_scale && bNormalMap, m_diffuseMapOffset != default_offset && bDiffuseMap, m_specularMapOffset != default_offset && bSpecMap, m_normalMapOffset != default_offset && bNormalMap);
+        KRShader *pShader = pContext->getShaderManager()->getShader(pCamera, bDiffuseMap, bNormalMap, bSpecMap, cShadowBuffers, bLightMap, m_diffuseMapScale != default_scale && bDiffuseMap, m_specularMapScale != default_scale && bSpecMap, m_normalMapScale != default_scale && bNormalMap, m_diffuseMapOffset != default_offset && bDiffuseMap, m_specularMapOffset != default_offset && bSpecMap, m_normalMapOffset != default_offset && bNormalMap);
 
         bool bSameShader = strcmp(pShader->getKey(), szPrevShaderKey) == 0;
         if(!bSameShader) {

KREngine/KREngine/Classes/KRMaterial.h

@@ -50,6 +50,7 @@ using std::list;
 
 
 class KRTextureManager;
+class KRContext;
 
 class KRMaterial : public KRResource {
 public:
@@ -75,7 +76,7 @@ public:
     char *getName();
     
 #if TARGET_OS_IPHONE
-    void bind(KRMaterial **prevBoundMaterial, char *szPrevShaderKey, KRCamera *pCamera, KRMat4 &mvpMatrix, KRVector3 &cameraPosition, KRVector3 &lightDirection, KRMat4 *pShadowMatrices, GLuint *shadowDepthTextures, int cShadowBuffers, KRShaderManager *pShaderManager, KRTextureManager *pTextureManager, KRTexture *pLightMap);
+    void bind(KRMaterial **prevBoundMaterial, char *szPrevShaderKey, KRCamera *pCamera, KRMat4 &mvpMatrix, KRVector3 &cameraPosition, KRVector3 &lightDirection, KRMat4 *pShadowMatrices, GLuint *shadowDepthTextures, int cShadowBuffers, KRContext *pContext, KRTexture *pLightMap);
     
 #endif
     

KREngine/KREngine/Classes/KRModel.cpp

@@ -44,24 +44,18 @@
 #include "KRVector3.h"
 #import "KRShader.h"
 #import "KRShaderManager.h"
+#import "KRContext.h"
 
-
-KRModel::KRModel(std::string name, std::string path, KRMaterialManager *pMaterialManager) {
+KRModel::KRModel(std::string name, std::string path) {
     m_name = name;
-    loadPack(path, pMaterialManager);
+    loadPack(path);
 }
 
-void KRModel::loadPack(std::string path, KRMaterialManager *pMaterialManager) {
+void KRModel::loadPack(std::string path) {
+    m_materials.clear();
+    m_uniqueMaterials.clear();
     m_pMesh = new KRMesh(KRResource::GetFileBase(path));
     m_pMesh->loadPack(path);
-    
-    vector<KRMesh::Submesh *> submeshes = m_pMesh->getSubmeshes();
-    
-    for(std::vector<KRMesh::Submesh *>::iterator itr = submeshes.begin(); itr != submeshes.end(); itr++) {
-        KRMaterial *pMaterial = pMaterialManager->getMaterial((*itr)->szMaterialName);
-        m_materials.push_back(pMaterial);
-        m_uniqueMaterials.insert(pMaterial);
-    }
 }
 
 std::string KRModel::getName() {
@@ -73,7 +67,18 @@ KRModel::~KRModel() {
 }
 #if TARGET_OS_IPHONE
 
-void KRModel::render(KRCamera *pCamera, KRMaterialManager *pMaterialManager, bool bRenderShadowMap, KRMat4 &mvpMatrix, KRVector3 &cameraPosition, KRVector3 &lightDirection, KRMat4 *pShadowMatrices, GLuint *shadowDepthTextures, int cShadowBuffers, KRShaderManager *pShaderManager, KRTextureManager *pTextureManager, KRTexture *pLightMap) {
+void KRModel::render(KRCamera *pCamera, KRContext *pContext, bool bRenderShadowMap, KRMat4 &mvpMatrix, KRVector3 &cameraPosition, KRVector3 &lightDirection, KRMat4 *pShadowMatrices, GLuint *shadowDepthTextures, int cShadowBuffers, KRTexture *pLightMap) {
+    
+    if(m_materials.size() == 0) {
+        vector<KRMesh::Submesh *> submeshes = m_pMesh->getSubmeshes();
+        
+        for(std::vector<KRMesh::Submesh *>::iterator itr = submeshes.begin(); itr != submeshes.end(); itr++) {
+            KRMaterial *pMaterial = pContext->getMaterialManager()->getMaterial((*itr)->szMaterialName);
+            m_materials.push_back(pMaterial);
+            m_uniqueMaterials.insert(pMaterial);
+        }
+    }
+    
     KRMaterial *pPrevBoundMaterial = NULL;
     int iPrevBuffer = -1;
     char szPrevShaderKey[128];
@@ -99,7 +104,7 @@ void KRModel::render(KRCamera *pCamera, KRMaterialManager *pMaterialManager, boo
                 KRMaterial *pMaterial = m_materials[iSubmesh];
                 
                 if(pMaterial != NULL && pMaterial == (*mat_itr)) {
-                    pMaterial->bind(&pPrevBoundMaterial, szPrevShaderKey, pCamera, mvpMatrix, cameraPosition, lightDirection, pShadowMatrices, shadowDepthTextures, cShadowBuffers, pShaderManager, pTextureManager, pLightMap);
+                    pMaterial->bind(&pPrevBoundMaterial, szPrevShaderKey, pCamera, mvpMatrix, cameraPosition, lightDirection, pShadowMatrices, shadowDepthTextures, cShadowBuffers, pContext, pLightMap);
                     m_pMesh->renderSubmesh(iSubmesh, &iPrevBuffer);
                 }
             }

KREngine/KREngine/Classes/KRModel.h

@@ -34,6 +34,7 @@
 #import <string>
 #import "KRMesh.h"
 #import "KRVector2.h"
+#import "KRcontext.h"
 
 #import "KREngine-common.h"
 
@@ -49,12 +50,12 @@ using std::set;
 class KRModel {
     
 public:
-    KRModel(std::string name, std::string path, KRMaterialManager *pMaterialManager);
+    KRModel(std::string name, std::string path);
     ~KRModel();
     
 #if TARGET_OS_IPHONE
     
-    void render(KRCamera *pCamera, KRMaterialManager *pMaterialManager, bool bRenderShadowMap, KRMat4 &mvpMatrix, KRVector3 &cameraPosition, KRVector3 &lightDirection, KRMat4 *pShadowMatrices, GLuint *shadowDepthTextures, int cShadowBuffers, KRShaderManager *pShaderManager, KRTextureManager *pTextureManager, KRTexture *pLightMap);
+    void render(KRCamera *pCamera, KRContext *pContext, bool bRenderShadowMap, KRMat4 &mvpMatrix, KRVector3 &cameraPosition, KRVector3 &lightDirection, KRMat4 *pShadowMatrices, GLuint *shadowDepthTextures, int cShadowBuffers, KRTexture *pLightMap);
     
 #endif
     
@@ -62,7 +63,7 @@ public:
     std::string getName();
 
 private:
-    void loadPack(std::string path, KRMaterialManager *pMaterialManager);
+    void loadPack(std::string path);
     
     vector<KRMaterial *> m_materials;
     set<KRMaterial *> m_uniqueMaterials;

KREngine/KREngine/Classes/KRModelManager.cpp

@@ -31,8 +31,10 @@
 
 #include "KRModelManager.h"
 
-KRModelManager::KRModelManager(KRMaterialManager *pMaterialManager) {
-    m_pMaterialManager = pMaterialManager;
+#import "KRModel.h"
+
+KRModelManager::KRModelManager() {
+
 }
 
 KRModelManager::~KRModelManager() {
@@ -43,7 +45,7 @@ KRModelManager::~KRModelManager() {
 }
 
 KRModel *KRModelManager::loadModel(const char *szName, const char *szPath) {
-    KRModel *pModel = new KRModel(szName, szPath, m_pMaterialManager);
+    KRModel *pModel = new KRModel(szName, szPath);
     m_models[szName] = pModel;
     return pModel;
 }

KREngine/KREngine/Classes/KRModelManager.h

@@ -34,7 +34,8 @@
 
 #import "KREngine-common.h"
 
-#include "KRModel.h"
+class KRContext;
+class KRModel;
 
 #include <map>
 #import <string>
@@ -42,7 +43,7 @@ using std::map;
 
 class KRModelManager {
 public:
-    KRModelManager(KRMaterialManager *pMaterialManager);
+    KRModelManager();
     ~KRModelManager();
     
     KRModel *loadModel(const char *szName, const char *szPath);
@@ -54,7 +55,6 @@ public:
     
 private:
     std::map<std::string, KRModel *> m_models;
-    KRMaterialManager *m_pMaterialManager;
 };
 
 #endif

KREngine/KREngine/Classes/KRNode.cpp

@@ -142,11 +142,11 @@ KRNode *KRNode::LoadXML(tinyxml2::XMLElement *e) {
 
 #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) {
+void KRNode::render(KRCamera *pCamera, KRContext *pContext, KRBoundingVolume &frustrumVolume, bool bRenderShadowMap, KRMat4 &viewMatrix, KRVector3 &cameraPosition, KRVector3 &lightDirection, KRMat4 *pShadowMatrices, GLuint *shadowDepthTextures, int cShadowBuffers) {
     
     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);
+        child->render(pCamera, pContext, frustrumVolume, bRenderShadowMap, viewMatrix, cameraPosition, lightDirection, pShadowMatrices, shadowDepthTextures, cShadowBuffers);
     }
 }
 
@@ -162,21 +162,21 @@ void KRNode::clearExtents() {
     }
 }
 
-KRBoundingVolume KRNode::getExtents(KRModelManager *pModelManager) {
+KRBoundingVolume KRNode::getExtents(KRContext *pContext) {
     if(!m_pExtents) {
-        calcExtents(pModelManager);
+        calcExtents(pContext);
     }
     return *m_pExtents;
 }
 
-void KRNode::calcExtents(KRModelManager *pModelManager) {
+void KRNode::calcExtents(KRContext *pContext) {
     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));
+            *m_pExtents = m_pExtents->get_union(child->getExtents(pContext));
         } else {
-            m_pExtents = new KRBoundingVolume(child->getExtents(pModelManager));
+            m_pExtents = new KRBoundingVolume(child->getExtents(pContext));
         }
     }
 }

KREngine/KREngine/Classes/KRNode.h

@@ -19,6 +19,7 @@ class KRModelManager;
 class KRMaterialManager;
 class KRMat4;
 class KRTextureManager;
+class KRContext;
 
 class KRNode
 {
@@ -43,11 +44,11 @@ public:
     const KRVector3 &getLocalRotation();
     
     void clearExtents();
-    virtual void calcExtents(KRModelManager *pModelManager);
-    KRBoundingVolume getExtents(KRModelManager *pModelManager);    
+    virtual void calcExtents(KRContext *Context);
+    KRBoundingVolume getExtents(KRContext *pContext);    
 #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);
+    virtual void render(KRCamera *pCamera, KRContext *pContext, KRBoundingVolume &frustrumVolume, bool bRenderShadowMap, KRMat4 &viewMatrix, KRVector3 &cameraPosition, KRVector3 &lightDirection, KRMat4 *pShadowMatrices, GLuint *shadowDepthTextures, int cShadowBuffers);
 
 #endif
     

KREngine/KREngine/Classes/KRScene.cpp

@@ -48,7 +48,7 @@ KRScene::~KRScene() {
 
 #if TARGET_OS_IPHONE
 
-void KRScene::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) {
+void KRScene::render(KRCamera *pCamera, KRContext *pContext, KRBoundingVolume &frustrumVolume, bool bRenderShadowMap, KRMat4 &viewMatrix, KRVector3 &cameraPosition, KRVector3 &lightDirection, KRMat4 *pShadowMatrices, GLuint *shadowDepthTextures, int cShadowBuffers) {
     
     if(cShadowBuffers > 0 && !bRenderShadowMap) {
         glActiveTexture(GL_TEXTURE3);
@@ -77,13 +77,13 @@ void KRScene::render(KRCamera *pCamera, KRModelManager *pModelManager, KRBoundin
         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);
+    m_pRootNode->render(pCamera, pContext, frustrumVolume, bRenderShadowMap, viewMatrix, cameraPosition, lightDirection, pShadowMatrices, shadowDepthTextures, cShadowBuffers);
 }
 
 #endif
 
-KRBoundingVolume KRScene::getExtents(KRModelManager *pModelManager) {
-    return m_pRootNode->getExtents(pModelManager);
+KRBoundingVolume KRScene::getExtents(KRContext *pContext) {
+    return m_pRootNode->getExtents(pContext);
 }
 
 

KREngine/KREngine/Classes/KRScene.h

@@ -61,11 +61,11 @@ public:
     
 #if TARGET_OS_IPHONE
     
-    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);
+    void render(KRCamera *pCamera, KRContext *pContext, KRBoundingVolume &frustrumVolume, bool bRenderShadowMap, KRMat4 &viewMatrix, KRVector3 &cameraPosition, KRVector3 &lightDirection, KRMat4 *pShadowMatrices, GLuint *shadowDepthTextures, int cShadowBuffers);
     
 #endif
     
-    KRBoundingVolume getExtents(KRModelManager *pModelManager);
+    KRBoundingVolume getExtents(KRContext *pContext);
 private:
     KRNode *m_pRootNode;
     KRBoundingVolume *m_pExtents;

KREngine/KREngine/Classes/KRSceneManager.cpp

@@ -29,7 +29,8 @@
 //  or implied, of Kearwood Gilbert.
 //
 
-#include "KRSceneManager.h"
+#import "KRSceneManager.h"
+#import "KRScene.h"
 
 KRSceneManager::KRSceneManager() {
 }

KREngine/KREngine/Classes/KRSceneManager.h

@@ -34,7 +34,7 @@
 
 #import "KREngine-common.h"
 
-#include "KRScene.h"
+class KRScene;
 
 #include <map>
 #import <string>