www.pudn.com > zfxcengine-0.1.0.zip > ceTextureManager_D3D9.cpp

#include  
#include "Render/RenderD3D9/ceTextureManager_D3D9.h" 
#include "Core/ceMemManager.h" 
 
namespace ZFXCE { 
	namespace Render { 
		///////////////////////////////////////////////////////////////////////////// 
		ceTextureManagerD3D9::ceTextureManagerD3D9(void):m_pD3DDevice(NULL) 
		{ 
            PUSH_FUNCTION; 
		} 
		///////////////////////////////////////////////////////////////////////////// 
		ceTextureManagerD3D9::ceTextureManagerD3D9(LPDIRECT3DDEVICE9 D3DDevice):m_pD3DDevice(D3DDevice) 
		{ 
            PUSH_FUNCTION; 
 
            BYTE DefaultTexture[3]; 
			memset(&DefaultTexture[0], 0, sizeof(BYTE) * 3); 
			DefaultTexture[0] = 255; 
			DefaultTexture[1] = 255; 
			DefaultTexture[2] = 0; 
			m_iDefaultTexture = LoadTexture(&DefaultTexture[0], 1, 24); 
		} 
		///////////////////////////////////////////////////////////////////////////// 
		ceTextureManagerD3D9::~ceTextureManagerD3D9(void) 
		{ 
            PUSH_FUNCTION; 
 
            RemoveAllTextures(); 
 
			m_pD3DDevice = NULL; 
			m_pVFS = NULL; 
		} 
        /////////////////////////////////////////////////////////////////////////// 
        int ceTextureManagerD3D9::AddTexture(void) 
        { 
            PUSH_FUNCTION; 
 
            int iIndex = -1; 
            if( !m_FreeIndices.empty() ) 
            { 
                iIndex = m_FreeIndices.top(); 
                m_FreeIndices.pop(); 
            } 
            else 
            { 
                iIndex = (int)m_Textures.size(); 
                m_Textures.resize(iIndex+1); 
            } 
            return iIndex; 
        } 
        //////////////////////////////////////////////////////////////////////////////// 
		INT ceTextureManagerD3D9::IsTextureLoaded(std::string Name) 
		{ 
            PUSH_FUNCTION; 
 
            TextureNameMap::iterator NameIt = m_TextureNames.find(Name); 
            if (NameIt == m_TextureNames.end()) 
                return -1; 
             
            return NameIt->second; 
		} 
		///////////////////////////////////////////////////////////////////////////// 
		INT ceTextureManagerD3D9::LoadTexture(std::string strFile, BOOL Compressed, BOOL bMipMapping, ceTexFilter TexFilter, ceTexType TexType) 
		{ 
            PUSH_FUNCTION; 
 
			assert(m_pVFS != NULL); 
			assert(m_pD3DDevice != NULL); 
 
            // Texture bereits geladen? 
            INT iID = IsTextureLoaded(strFile); 
            if (-1 != iID ) 
                return iID; 
 
            // Datei öffnen 
			INT FileID = m_pVFS->OpenFile(strFile, CE_VFS_BIN); 
			if(FileID == -1) 
				return m_iDefaultTexture; 
			UINT Size = m_pVFS->GetFileSize(FileID); 
			BYTE* Data = new BYTE[Size]; 
			memset(&Data[0], 0, sizeof(BYTE) * Size); 
 
			m_pVFS->GetFileData(FileID, &Data[0], Size); 
			m_pVFS->CloseFile(FileID); 
 
            // TextureObject erstellen 
            ceTextureObjectD3D9* pTexture = new ceTextureObjectD3D9(m_pD3DDevice); 
 
            // Texture laden 
			pTexture->Load(Data, Size, Compressed, bMipMapping, TexFilter, TexType); 
			delete[] Data; 
 
            // Texture hinzufügen 
            iID = AddTexture(); 
            m_Textures[iID] = pTexture; 
            pTexture->SetName(strFile); 
 
			std::pair namepair(strFile, iID); 
			m_TextureNames.insert(namepair); 
 
			return iID; 
			 
		} 
		///////////////////////////////////////////////////////////////////////////// 
		INT ceTextureManagerD3D9::LoadTexture(void* pbData, UINT uiSideLength, UCHAR BPP, BOOL Compressed, BOOL bMipMapping, ceTexFilter TexFilter, ceTexType TexType) 
		{ 
            PUSH_FUNCTION; 
 
			assert(m_pD3DDevice != NULL); 
 
            INT iID = -1; 
 
            // TextureObject erstellen 
            ceTextureObjectD3D9* pTexture = new ceTextureObjectD3D9(m_pD3DDevice); 
 
            // Texture laden 
			pTexture->LoadFromMemory(pbData, uiSideLength, 32, Compressed, bMipMapping, TexFilter, TexType); 
 
            // Texture hinzufügen 
			iID = AddTexture(); 
            m_Textures[iID] = pTexture; 
 
			return iID; 
 
	/*		assert(m_pVFS != NULL); 
			assert(m_pD3DDevice != NULL); 
 
			ceTextureObjectD3D9* tex = new ceTextureObjectD3D9(m_pD3DDevice); 
			if(!tex) 
				return -1; 
 
//			wir haben hier keine richtige Datei, sondern nur Helligkeitswerte. 
//			D.h. wir brauchen noch ne passende Funktion dafür 
//			tex->Load(pbData, uiSideLength, BPP, Compressed, bMipMapping, TexFilter, TexType); 
			std::pair texpair(m_mapTextures.size(), tex); 
			std::pair namepair(m_mapTextureNames.size(), "Memory Texture"); 
 
			m_mapTextureNames.insert(namepair); 
			m_mapTextures.insert(texpair); 
 
			return (INT)m_mapTextures.size()-1;*/ 
		} 
		///////////////////////////////////////////////////////////////////////////// 
		void ceTextureManagerD3D9::BindToTexUnit(INT iID, const ceTextureUnit Unit) 
		{ 
            PUSH_FUNCTION; 
            assert(false && "nicht implementiert"); 
		} 
		///////////////////////////////////////////////////////////////////////////// 
		void ceTextureManagerD3D9::DisableTranslations(INT ID, BOOL Reset) 
		{ 
            PUSH_FUNCTION; 
            assert(false && "nicht implementiert"); 
		} 
		///////////////////////////////////////////////////////////////////////////// 
		void ceTextureManagerD3D9::EnableTranslations(INT ID) 
		{ 
            PUSH_FUNCTION; 
            assert(false && "nicht implementiert"); 
		} 
		///////////////////////////////////////////////////////////////////////////// 
		void ceTextureManagerD3D9::RemoveAllTextures(void) 
		{ 
            PUSH_FUNCTION; 
 
			TextureObjectVector::iterator ObjectIt = m_Textures.begin(); 
			for(; ObjectIt != m_Textures.end(); ObjectIt++) 
			{ 
				delete *ObjectIt; 
			} 
			m_TextureNames.clear(); 
			m_Textures.clear(); 
 
            while (!m_FreeIndices.empty()) 
                m_FreeIndices.pop(); 
		} 
		///////////////////////////////////////////////////////////////////////////// 
		void ceTextureManagerD3D9::RemoveTexture(INT ID) 
		{ 
            PUSH_FUNCTION; 
 
            if (0 <= ID && ID < (int)m_Textures.size() && m_Textures[ID] != NULL) 
            { 
                std::string name = ((ceTextureObjectD3D9*)(m_Textures[ID]))->GetName(); 
 
                delete m_Textures[ID]; 
                m_Textures[ID] = NULL; 
                m_FreeIndices.push(ID); 
 
                TextureNameMap::iterator NameIt = m_TextureNames.find(name); 
                m_TextureNames.erase(NameIt); 
            } 
 
		/*	TextureObjectMap::iterator ObjectIt = m_mapTextures.find(ID); 
			if(ObjectIt != m_mapTextures.end() ) 
			{ 
				TextureNameMap::iterator NameIt = m_mapTextureNames.find(ID); 
				m_mapTextureNames.erase(NameIt); 
				m_mapTextures.erase(ObjectIt); 
				return; 
			}*/ 
		} 
		///////////////////////////////////////////////////////////////////////////// 
		void ceTextureManagerD3D9::SetRotation(INT ID, FLOAT X, FLOAT Y, FLOAT Z) 
		{ 
            PUSH_FUNCTION; 
            assert(false && "nicht implementiert"); 
		} 
		///////////////////////////////////////////////////////////////////////////// 
		void ceTextureManagerD3D9::SetScale(INT ID, FLOAT fScale) 
		{ 
            PUSH_FUNCTION; 
            assert(false && "nicht implementiert"); 
		} 
		///////////////////////////////////////////////////////////////////////////// 
		void ceTextureManagerD3D9::SetTextureEnvMode(INT ID, UINT NewEnv) 
		{ 
            PUSH_FUNCTION; 
            assert(false && "nicht implementiert"); 
		} 
		///////////////////////////////////////////////////////////////////////////// 
		void ceTextureManagerD3D9::SetTranslation(INT ID, FLOAT fS, FLOAT fT) 
		{ 
            PUSH_FUNCTION; 
            assert(false && "nicht implementiert"); 
		} 
        //////////////////////////////////////////////////////////////////////////////// 
		ceTextureObjectD3D9* ceTextureManagerD3D9::GetObjectByID(INT ID) 
		{ 
            PUSH_FUNCTION; 
            assert(0 <= ID && ID < (int)m_Textures.size()); 
 
            return m_Textures[ID]; 
		} 
		///////////////////////////////////////////////////////////////////////////// 
	}	// namespace Render 
}	// namespace ZFXCE