Implementation of reflections in progress

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

KREngine/KREngine/Classes/KRMaterial.cpp

@@ -46,6 +46,7 @@ KRMaterial::KRMaterial(KRContext &context, const char *szName) : KRResource(cont
     m_pSpecularMap = NULL;
     m_pNormalMap = NULL;
     m_pReflectionMap = NULL;
+    m_pReflectionCube = NULL;
     m_ambientColor = KRVector3::Zero();
     m_diffuseColor = KRVector3::One();
     m_specularColor = KRVector3::One();
@@ -57,6 +58,7 @@ KRMaterial::KRMaterial(KRContext &context, const char *szName) : KRResource(cont
     m_specularMap = "";
     m_normalMap = "";
     m_reflectionMap = "";
+    m_reflectionCube = "";
     m_ambientMapOffset = KRVector2(0.0f, 0.0f);
     m_specularMapOffset = KRVector2(0.0f, 0.0f);
     m_diffuseMapOffset = KRVector2(0.0f, 0.0f);
@@ -105,6 +107,9 @@ bool KRMaterial::save(const std::string& path) {
         if(m_reflectionMap.size()) {
             fprintf(f, "map_Reflection %s.pvr -s %f %f -o %f %f\n", m_reflectionMap.c_str(), m_reflectionMapScale.x, m_reflectionMapScale.y, m_reflectionMapOffset.x, m_reflectionMapOffset.y);
         }
+        if(m_reflectionCube.size()) {
+            fprintf(f, "map_ReflectionCube %s.pvr\n", m_reflectionCube.c_str());
+        }
         switch(m_alpha_mode) {
             case KRMATERIAL_ALPHA_MODE_OPAQUE:
                 fprintf(f, "alpha_mode opaque");
@@ -154,6 +159,10 @@ void KRMaterial::setReflectionMap(std::string texture_name, KRVector2 texture_sc
     m_reflectionMapOffset = texture_offset;
 }
 
+void KRMaterial::setReflectionCube(std::string texture_name) {
+    m_reflectionCube = texture_name;
+}
+
 void KRMaterial::setAlphaMode(KRMaterial::alpha_mode_type alpha_mode) {
     m_alpha_mode = alpha_mode;
 }
@@ -217,6 +226,9 @@ bool KRMaterial::bind(KRMaterial **prevBoundMaterial, char *szPrevShaderKey, KRC
     if(!m_pReflectionMap && m_reflectionMap.size()) {
         m_pReflectionMap = pContext->getTextureManager()->getTexture(m_reflectionMap.c_str());
     }
+    if(!m_pReflectionCube && m_reflectionCube.size()) {
+        m_pReflectionCube = pContext->getTextureManager()->getTextureCube(m_reflectionCube.c_str());
+    }
     
     if(!bSameMaterial) { 
         KRVector2 default_scale = KRVector2(1.0f, 1.0f);

KREngine/KREngine/Classes/KRMaterial.h

@@ -73,6 +73,7 @@ public:
     void setDiffuseMap(std::string texture_name, KRVector2 texture_scale, KRVector2 texture_offset);
     void setSpecularMap(std::string texture_name, KRVector2 texture_scale, KRVector2 texture_offset);
     void setReflectionMap(std::string texture_name, KRVector2 texture_scale, KRVector2 texture_offset);
+    void setReflectionCube(std::string texture_name);
     void setNormalMap(std::string texture_name, KRVector2 texture_scale, KRVector2 texture_offset);
     void setAmbient(const KRVector3 &c);
     void setDiffuse(const KRVector3 &c);    
@@ -102,11 +103,13 @@ private:
     KRTexture *m_pDiffuseMap; // mtl map_Kd value
     KRTexture *m_pSpecularMap; // mtl map_Ks value
     KRTexture *m_pReflectionMap; // mtl refl value
+    KRTexture *m_pReflectionCube;
     KRTexture *m_pNormalMap; // mtl map_Normal value
     std::string m_ambientMap;
     std::string m_diffuseMap;
     std::string m_specularMap;
     std::string m_reflectionMap;
+    std::string m_reflectionCube;
     std::string m_normalMap;
     
     KRVector2 m_ambientMapScale;

KREngine/KREngine/Classes/KRMaterialManager.cpp

@@ -232,8 +232,9 @@ bool KRMaterialManager::load(const char *szName, KRDataBlock *data) {
                             pMaterial->setNormalMap(szSymbol[1], texture_scale, texture_offset);
                         } else if(strcmp(szSymbol[0], "map_Reflection") == 0) {
                             pMaterial->setReflectionMap(szSymbol[1], texture_scale, texture_offset);
+                        } else if(strcmp(szSymbol[0], "map_ReflectionCube") == 0) {
+                            pMaterial->setReflectionCube(szSymbol[1]);
                         }
-
                     }
                 }
             }

KREngine/KREngine/Classes/KRTexture.cpp

@@ -7,12 +7,50 @@
 //
 
 #include "KRTexture.h"
+#include "KRDataBlock.h"
+#include <assert.h>
 
-KRTexture::KRTexture(KRDataBlock *data, KRTextureManager *manager) {
+KRTexture::KRTexture(KRContext &context) : KRContextObject(context)
-    m_pData = data;
+{
-    m_pManager = manager;
+    
+    m_iHandle = 0;
+    m_textureMemUsed = 0;
 }
 
-KRTexture::~KRTexture() {
+KRTexture::~KRTexture()
-    
+{
+    long textureMemFreed = 0;
+    releaseHandle(textureMemFreed);
+}
+
+void KRTexture::releaseHandle(long &textureMemUsed) {
+    if(m_iHandle != 0) {
+        textureMemUsed -= getMemSize();
+        GLDEBUG(glDeleteTextures(1, &m_iHandle));
+        m_iHandle = 0;
+        m_textureMemUsed = 0;
+    }
+}
+
+long KRTexture::getMemSize() {
+    return m_textureMemUsed; // TODO - This is not 100% accurate, as loaded format may differ in size while in GPU memory
+}
+
+GLuint KRTexture::getHandle(long &textureMemUsed, int max_dim, bool can_resize) {
+    // Constrain target LOD to be within mipmap levels of texture
+    int target_dim = max_dim;
+    if(target_dim < m_min_lod_max_dim) target_dim = m_min_lod_max_dim;
+    if(target_dim > m_max_lod_max_dim) target_dim = m_max_lod_max_dim;
+    
+    if(can_resize && m_current_lod_max_dim != target_dim) {
+        releaseHandle(textureMemUsed);
+    }
+    if(m_iHandle == 0) {
+        if(createGLTexture(target_dim, m_textureMemUsed)) {
+            textureMemUsed += getMemSize();
+        } else {
+            assert(false);
+        }
+    }
+    return m_iHandle;
 }

KREngine/KREngine/Classes/KRTexture.h

@@ -35,25 +35,33 @@
 #define KRTEXTURE_H
 
 #import "KREngine-common.h"
+#import "KRContextObject.h"
+
 
-class KRTextureManager;
 class KRDataBlock;
 
-class KRTexture {
+class KRTexture : public KRContextObject{
 public:
-    KRTexture(KRDataBlock *data, KRTextureManager *manager);
+    KRTexture(KRContext &context);
     virtual ~KRTexture();
 
-    virtual GLuint getHandle(long &textureMemUsed, int max_dim, bool can_resize) = 0;
+    GLuint getHandle(long &textureMemUsed, int max_dim, bool can_resize);
+    void releaseHandle(long &textureMemUsed);
+    long getMemSize();
 
-    virtual void releaseHandle(long &textureMemUsed) = 0;
-    virtual long getMemSize() = 0;
 
     
 protected:
+    virtual bool createGLTexture(int lod_max_dim, uint32_t &textureMemUsed) = 0;
     
-    KRDataBlock *m_pData;
+    
-    KRTextureManager *m_pManager;
+    GLuint    m_iHandle;
+    uint32_t m_textureMemUsed;
+    
+    int m_current_lod_max_dim;
+    
+    uint32_t m_max_lod_max_dim;
+    uint32_t m_min_lod_max_dim;
 };
 
 

KREngine/KREngine/Classes/KRTexture2D.cpp

@@ -69,20 +69,27 @@ typedef struct _PVRTexHeader
 	uint32_t numSurfs;
 } PVRTexHeader;
 
-KRTexture2D::KRTexture2D(KRDataBlock *data, KRTextureManager *manager) : KRTexture(data, manager) {
+KRTexture2D::KRTexture2D(KRContext &context, KRDataBlock *data) : KRTexture(context) {
-    m_iHandle = 0;
+    m_pData = data;
     m_current_lod_max_dim = 0;
-    m_textureMemUsed = 0;
     load();
 }
 
 KRTexture2D::~KRTexture2D() {
-    long textureMemFreed = 0;
-    releaseHandle(textureMemFreed);
     delete m_pData;
 }
 
+bool KRTexture2D::hasMipmaps() {
+    return m_blocks.size() > 1;
+}
 
+int KRTexture2D::getMaxMipMap() {
+    return m_max_lod_max_dim;
+}
+
+int KRTexture2D::getMinMipMap() {
+    return m_min_lod_max_dim;
+}
 
 bool KRTexture2D::load() {
 #if TARGET_OS_IPHONE
@@ -164,8 +171,31 @@ bool KRTexture2D::load() {
 
 
 
-bool KRTexture2D::createGLTexture(int lod_max_dim) {    
+bool KRTexture2D::createGLTexture(int lod_max_dim, uint32_t &textureMemUsed) {
     m_current_lod_max_dim = 0;
+    GLDEBUG(glGenTextures(1, &m_iHandle));
+    if(m_iHandle == 0) {
+        return false;
+    }
+    GLDEBUG(glBindTexture(GL_TEXTURE_2D, m_iHandle));
+	if (hasMipmaps()) {
+        GLDEBUG(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR));
+    } else {
+        GLDEBUG(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
+    }
+    if(!uploadTexture(GL_TEXTURE_2D, lod_max_dim, m_current_lod_max_dim, textureMemUsed)) {
+        GLDEBUG(glDeleteTextures(1, &m_iHandle));
+        textureMemUsed = 0;
+        m_iHandle = 0;
+        m_current_lod_max_dim = 0;
+        return false;
+    }
+    
+    return true;
+}
+
+bool KRTexture2D::uploadTexture(GLenum target, int lod_max_dim, int &current_lod_max_dim, uint32_t &textureMemUsed)
+{
 	int width = m_iWidth;
 	int height = m_iHeight;
 	GLenum err;
@@ -174,38 +204,24 @@ bool KRTexture2D::createGLTexture(int lod_max_dim) {
         return false;
     }
 
-    GLDEBUG(glGenTextures(1, &m_iHandle));
-    if(m_iHandle == 0) {
-        return false;
-    }
-    GLDEBUG(glBindTexture(GL_TEXTURE_2D, m_iHandle));
-	
-	if (m_blocks.size() > 1) {
-        GLDEBUG(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR));
-    } else {
-        GLDEBUG(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
-    }
     int i=0;
     for(std::list<dataBlockStruct>::iterator itr = m_blocks.begin(); itr != m_blocks.end(); itr++) {
         dataBlockStruct block = *itr;
         if(width <= lod_max_dim && height <= lod_max_dim) {
-            if(width > m_current_lod_max_dim) {
+            if(width > current_lod_max_dim) {
-                m_current_lod_max_dim = width;
+                current_lod_max_dim = width;
             }
-            if(height > m_current_lod_max_dim) {
+            if(height > current_lod_max_dim) {
-                m_current_lod_max_dim = height;
+                current_lod_max_dim = height;
             }
-            GLDEBUG(glCompressedTexImage2D(GL_TEXTURE_2D, i, m_internalFormat, width, height, 0, block.length, block.start));
+            GLDEBUG(glCompressedTexImage2D(target, i, m_internalFormat, width, height, 0, block.length, block.start));
             
             err = glGetError();
             if (err != GL_NO_ERROR) {
-                GLDEBUG(glDeleteTextures(1, &m_iHandle));
+                
-                m_textureMemUsed = 0;
-                m_iHandle = 0;
-                lod_max_dim = 0;
                 return false;
             }
-            m_textureMemUsed += block.length;
+            textureMemUsed += block.length;
             i++;
         }
 		
@@ -220,38 +236,8 @@ bool KRTexture2D::createGLTexture(int lod_max_dim) {
 	}
     
     return true;
+
 }
 
-GLuint KRTexture2D::getHandle(long &textureMemUsed, int max_dim, bool can_resize) {
-    // Constrain target LOD to be within mipmap levels of texture
-    int target_dim = max_dim;
-    if(target_dim < m_min_lod_max_dim) target_dim = m_min_lod_max_dim;
-    if(target_dim > m_max_lod_max_dim) target_dim = m_max_lod_max_dim;
 
-    if(can_resize && m_current_lod_max_dim != target_dim) {
-        releaseHandle(textureMemUsed);
-    }
-    if(m_iHandle == 0) {
-        if(createGLTexture(target_dim)) {
-            textureMemUsed += getMemSize();
-        } else {
-            assert(false);
-        }
 
-        //createGLTexture();
-    }
-    return m_iHandle;
-}
-
-void KRTexture2D::releaseHandle(long &textureMemUsed) {
-    if(m_iHandle != 0) {
-        textureMemUsed -= getMemSize();
-        GLDEBUG(glDeleteTextures(1, &m_iHandle));
-        m_iHandle = 0;
-        m_textureMemUsed = 0;
-    }
-}
-
-long KRTexture2D::getMemSize() {
-    return m_textureMemUsed; // TODO - This is not 100% accurate, as loaded format may differ in size while in GPU memory
-}

KREngine/KREngine/Classes/KRTexture2D.h

@@ -43,23 +43,23 @@ using std::list;
 
 #include "KRTexture.h"
 
-class KRTextureManager;
-
 class KRTexture2D : public KRTexture {
 public:
-    KRTexture2D(KRDataBlock *data, KRTextureManager *manager);
+    KRTexture2D(KRContext &context, KRDataBlock *data);
     ~KRTexture2D();
     
+    bool hasMipmaps();
+    int getMaxMipMap();
+    int getMinMipMap();
     
-    virtual GLuint getHandle(long &textureMemUsed, int max_dim, bool can_resize);
+    bool uploadTexture(GLenum target, int lod_max_dim, int &current_lod_max_dim, uint32_t &textureMemUsed);
-    virtual void releaseHandle(long &textureMemUsed);
-    virtual long getMemSize();
     
 private:
+    KRDataBlock *m_pData;
+    
+    virtual bool createGLTexture(int lod_max_dim, uint32_t &textureMemUsed);
 
-    bool createGLTexture(int lod_max_dim);
     
-    GLuint    m_iHandle;
     uint32_t  m_iWidth;
     uint32_t  m_iHeight;
     GLenum    m_internalFormat;
@@ -74,12 +74,6 @@ private:
     
     bool load();
 
-    int m_current_lod_max_dim;
-    
-    uint32_t m_max_lod_max_dim;
-    uint32_t m_min_lod_max_dim;
-    
-    uint32_t m_textureMemUsed;
 };
 
 #endif

KREngine/KREngine/Classes/KRTextureCube.cpp

@@ -30,28 +30,55 @@
 //
 
 #include "KRTextureCube.h"
+#include "KRTexture2D.h"
+#include "KRContext.h"
 
-KRTextureCube::KRTextureCube(KRDataBlock *data, KRTextureManager *manager) : KRTexture(data, manager)
+KRTextureCube::KRTextureCube(KRContext &context, std::string name) : KRTexture(context)
 {
-    m_iHandle = 0;
+    m_name = name;
+    
+    m_max_lod_max_dim = 2048;
+    m_min_lod_max_dim = 64;
+    
+    for(int i=0; i<6; i++) {
+        std::string faceName = m_name + SUFFIXES[i];
+        KRTexture2D *faceTexture = (KRTexture2D *)getContext().getTextureManager()->getTexture(faceName.c_str());
+        if(faceTexture) {
+            if(faceTexture->getMaxMipMap() < m_max_lod_max_dim) m_max_lod_max_dim = faceTexture->getMaxMipMap();
+            if(faceTexture->getMinMipMap() > m_min_lod_max_dim) m_min_lod_max_dim = faceTexture->getMinMipMap();
+        }
+    }
 }
 
 KRTextureCube::~KRTextureCube()
 {
-    if(m_iHandle != 0) glDeleteTextures(1, &m_iHandle);
 }
 
-GLuint KRTextureCube::getHandle(long &textureMemUsed, int max_dim, bool can_resize)
+bool KRTextureCube::createGLTexture(int lod_max_dim, uint32_t &textureMemUsed)
 {
-    return 0;
+    m_current_lod_max_dim = 0;
-}
+    GLDEBUG(glGenTextures(1, &m_iHandle));
+    if(m_iHandle == 0) {
+        return false;
+    }
     
-void KRTextureCube::releaseHandle(long &textureMemUsed)
+    GLDEBUG(glBindTexture(GL_TEXTURE_CUBE_MAP, m_iHandle));
-{
     
-}
+    bool bMipMaps = false;
 
-long KRTextureCube::getMemSize()
+    for(int i=0; i<6; i++) {
-{
+        std::string faceName = m_name + SUFFIXES[i];
-    return 0;
+        KRTexture2D *faceTexture = (KRTexture2D *)getContext().getTextureManager()->getTexture(faceName.c_str());
+        if(faceTexture) {
+            if(faceTexture->hasMipmaps()) bMipMaps = true;
+            faceTexture->uploadTexture(TARGETS[i], lod_max_dim, m_current_lod_max_dim, textureMemUsed);
+        }
+    }
+    
+    if(bMipMaps) {
+        GLDEBUG(glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR));
+    } else {
+        GLDEBUG(glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
+    }
+    return true;
 }

KREngine/KREngine/Classes/KRTextureCube.h

@@ -33,26 +33,38 @@
 #define KRTEXTURECUBE_H
 
 #include "KRTexture.h"
-#include "KRTextureManager.h"
 
 class KRTextureCube : public KRTexture {
 public:
-    KRTextureCube(KRDataBlock *data, KRTextureManager *manager);
+    KRTextureCube(KRContext &context, std::string name);
     virtual ~KRTextureCube();
     
-    virtual GLuint getHandle(long &textureMemUsed, int max_dim, bool can_resize);
-    virtual void releaseHandle(long &textureMemUsed);
-    virtual long getMemSize();
-    
 private:
-    std::string m_frontTextureName;
+    virtual bool createGLTexture(int lod_max_dim, uint32_t &textureMemUsed);
-    std::string m_backTextureName;
+    
-    std::string m_leftTextureName;
+    std::string m_name;
-    std::string m_rightTextureName;
-    std::string m_topTextureName;
-    std::string m_bottomTextureName;
     
     GLuint m_iHandle;
+    
+    uint32_t m_textureMemUsed;
+    
+    const GLenum TARGETS[6] = {
+        GL_TEXTURE_CUBE_MAP_POSITIVE_X,
+        GL_TEXTURE_CUBE_MAP_NEGATIVE_X,
+        GL_TEXTURE_CUBE_MAP_POSITIVE_Y,
+        GL_TEXTURE_CUBE_MAP_NEGATIVE_Y,
+        GL_TEXTURE_CUBE_MAP_POSITIVE_Z,
+        GL_TEXTURE_CUBE_MAP_NEGATIVE_Z
+    };
+    
+    const char *SUFFIXES[6] = {
+        "_positive_x",
+        "_negative_x",
+        "_positive_y",
+        "_negative_y",
+        "_positive_z",
+        "_negative_z"
+    };
 };
 
 

KREngine/KREngine/Classes/KRTextureManager.cpp

@@ -51,7 +51,7 @@ KRTextureManager::~KRTextureManager() {
 }
 
 KRTexture *KRTextureManager::loadTexture(const char *szName, KRDataBlock *data) {
-    KRTexture *pTexture = new KRTexture2D(data, this);
+    KRTexture *pTexture = new KRTexture2D(getContext(), data);
     
     std::string lowerName = szName;
     std::transform(lowerName.begin(), lowerName.end(),
@@ -63,17 +63,20 @@ KRTexture *KRTextureManager::loadTexture(const char *szName, KRDataBlock *data)
     return pTexture;
 }
 
-KRTexture *KRTextureManager::loadTextureCube(const char *szName, KRDataBlock *data) {
+KRTexture *KRTextureManager::getTextureCube(const char *szName) {
-    KRTexture *pTexture = new KRTextureCube(data, this);
-    
     std::string lowerName = szName;
     std::transform(lowerName.begin(), lowerName.end(),
                    lowerName.begin(), ::tolower);
     
+    map<std::string, KRTexture *>::iterator itr = m_textures.find(lowerName);
+    if(itr == m_textures.end()) {
+        KRTextureCube *pTexture = new KRTextureCube(getContext(), lowerName);
         
-    
+        m_textures[lowerName] = pTexture;
-    m_textures[lowerName] = pTexture;
+        return pTexture;
-    return pTexture;
+    } else {
+        return (*itr).second;
+    }
 }
 
 KRTexture *KRTextureManager::getTexture(const char *szName) {

KREngine/KREngine/Classes/KRTextureManager.h

@@ -61,8 +61,7 @@ public:
     void selectTexture(int iTextureUnit, KRTexture *pTexture, int lod_max_dim);
     
     KRTexture *loadTexture(const char *szName, KRDataBlock *data);
-    KRTexture *loadTextureCube(const char *szName, KRDataBlock *data);
+    KRTexture *getTextureCube(const char *szName);
-
     KRTexture *getTexture(const char *szFile);
     
     long getMemUsed();