Egalware/EgtGraphics
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

EgtGraphics :

Browse Source 
- aggiunta gestione primitiva delle textures.
This commit is contained in:
Dario Sassi
2015-09-28 16:13:42 +00:00
parent a2c5908a7e
commit b839d7ac36
8 changed files with 406 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files
TextureMgr.cpp
+247
View File
@@ -0,0 +1,247 @@
//----------------------------------------------------------------------------
// EgalTech 2015-2015
//----------------------------------------------------------------------------
// File : TextureMgr.cpp Data : 27.09.15 Versione : 1.6i8
// Contenuto : Implementazione della classe gestione textures.
//
//
//
// Modifiche : 27.09.15 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------
//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "Scene.h"
#include "TextureMgr.h"
#include "\EgtDev\Include\EGnStringUtils.h"
#include "\EgtDev\Include\EgtStringConverter.h"
#include "\EgtDev\Extern\FreeImage\Include\FreeImage.h"
using namespace std ;
//----------------------------------------------------------------------------
TextureMgr::TextureMgr( void)
{
// inserisco le texture standard calcolate : Chessboard e Lines
}
//----------------------------------------------------------------------------
TextureMgr::~TextureMgr( void)
{
// scarico le texture da OpenGL
for ( auto iIter = m_umTextData.begin() ; iIter != m_umTextData.end() ; ++ iIter) {
GLuint nTextId = iIter->second.nTexId ;
glDeleteTextures( 1, &nTextId) ;
}
m_umTextData.clear() ;
}
//----------------------------------------------------------------------------
bool
TextureMgr::LoadTexture( const string& sName, const string& sFile, double dDimX, double dDimY, bool bRepeat)
{
// verifico se immagine già caricata
auto iIter = m_umTextData.find( sName) ;
if ( iIter != m_umTextData.end())
return ( EqualNoCase( iIter->second.sFile, sFile) && iIter->second.bRepeat == bRepeat) ;
// leggo l'immagine dal file
FIBITMAP* pDib = nullptr ;
if ( ! ReadImage( sFile, pDib))
return false ;
// se necessario, converto l'immagine a 32 bit per pixel (BGRA)
int bitsPerPixel = FreeImage_GetBPP( pDib) ;
if ( bitsPerPixel != 32) {
FIBITMAP* pTmpDib = pDib ;
pDib = FreeImage_ConvertTo32Bits( pTmpDib) ;
FreeImage_Unload( pTmpDib) ;
}
// se necessario e possibile, la riduco alle dimensioni caricabili da OpenGL corrente
if ( ! TestImageWithOpenGL( pDib))
return false ;
// recupero le dimensioni in pixel dell'immagine
int nWidth = FreeImage_GetWidth( pDib) ;
int nHeight = FreeImage_GetHeight( pDib) ;
// carico l'immagine in OpenGL come texture
GLuint nTexName ;
glPixelStorei( GL_UNPACK_ALIGNMENT, 4) ;
glGenTextures( 1, &nTexName) ;
glBindTexture( GL_TEXTURE_2D, nTexName) ;
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, ( bRepeat ? GL_REPEAT : GL_CLAMP_TO_BORDER)) ;
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, ( bRepeat ? GL_REPEAT : GL_CLAMP_TO_BORDER)) ;
float color[] = { 0.9f, 0.9f, 0.9f, 1.0f} ;
glTexParameterfv( GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, color) ;
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR) ;
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR) ;
glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, nWidth, nHeight,
0, GL_BGRA, GL_UNSIGNED_BYTE, FreeImage_GetBits( pDib)) ;
// libero l'immagine originaria
FreeImage_Unload( pDib) ;
// verifico che la texture sia stata veramente caricata
if ( ! glIsTexture( nTexName))
return false ;
// rendo non corrente questa texture
glBindTexture( GL_TEXTURE_2D, 0) ;
// salvo i dati
TextureData textData( sFile, dDimX, dDimY, nWidth, nHeight, nTexName, bRepeat) ;
m_umTextData.emplace( sName, textData) ;
return true ;
}
//----------------------------------------------------------------------------
bool
TextureMgr::UnloadTexture( const std::string& sName)
{
// cerco la texture, se non la trovo già ok
auto iIter = m_umTextData.find( sName) ;
if ( iIter == m_umTextData.end())
return true ;
// scarico la texture da OpenGL
GLuint nTextId = iIter->second.nTexId ;
glDeleteTextures( 1, &nTextId) ;
// tolgo la texture dall'elenco
m_umTextData.erase( iIter) ;
return true ;
}
//----------------------------------------------------------------------------
bool
TextureMgr::ChangeDimensions( const std::string& sName, double dDimX, double dDimY)
{
// ricerca della texture di nome dato
auto iIter = m_umTextData.find( sName) ;
if ( iIter == m_umTextData.end())
return false ;
// assegno le nuove dimensioni
iIter->second.dDimX = dDimX ;
iIter->second.dDimY = dDimY ;
return true ;
}
//----------------------------------------------------------------------------
bool
TextureMgr::GetTextureData( const string& sName, unsigned int& nId, double& dDimX, double& dDimY)
{
// ricerca della texture di nome dato
auto iIter = m_umTextData.find( sName) ;
if ( iIter == m_umTextData.end())
return false ;
// restituzione dei parametri
nId = iIter->second.nTexId ;
dDimX = iIter->second.dDimX ;
dDimY = iIter->second.dDimY ;
return true ;
}
//----------------------------------------------------------------------------
bool
TextureMgr::ReadImage( const string& sFile, FIBITMAP*& pDib)
{
// deduco il formato dell'immagine dalla sua segnatura o dalla estensione del file
FREE_IMAGE_FORMAT nFif = FreeImage_GetFileTypeU( stringtoW( sFile), 0) ;
if ( nFif == FIF_UNKNOWN)
nFif = FreeImage_GetFIFFromFilenameU( stringtoW( sFile)) ;
// se non determinata, esco con errore
if ( nFif == FIF_UNKNOWN)
return false ;
// carico l'immagine
pDib = nullptr ;
if ( FreeImage_FIFSupportsReading( nFif))
pDib = FreeImage_LoadU( nFif, stringtoW( sFile)) ;
if ( pDib == nullptr)
return false ;
// recupero alcuni dati dell'immagine e li verifico
if ( FreeImage_GetBits( pDib) == nullptr ||
FreeImage_GetWidth( pDib) == 0 || FreeImage_GetHeight( pDib) == 0) {
FreeImage_Unload( pDib) ;
pDib = nullptr ;
return false ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
TextureMgr::TestImageWithOpenGL( FIBITMAP*& pDib)
{
// recupero le dimensioni in pixel dell'immagine
int nWidth = FreeImage_GetWidth( pDib) ;
int nHeight = FreeImage_GetHeight( pDib) ;
// verifico sia caricabile da OpenGL corrente
glTexImage2D( GL_PROXY_TEXTURE_2D, 0, GL_RGBA, nWidth, nHeight,
0, GL_BGRA, GL_UNSIGNED_BYTE, FreeImage_GetBits( pDib)) ;
int nW ;
glGetTexLevelParameteriv( GL_PROXY_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &nW) ;
if ( nW == 0) {
// recupero la massima dimensione di una texture per OpenGL corrente
int nMaxTextDim ;
glGetIntegerv(GL_MAX_TEXTURE_SIZE, &nMaxTextDim) ;
// cerco le dimensioni POT (power of two) appena minori delle due dimensioni
int nNewW = nMaxTextDim ;
while ( nNewW > nWidth)
nNewW /= 2 ;
int nNewH = nMaxTextDim ;
while ( nNewH > nHeight)
nNewH /= 2 ;
// deformo la texture per avere queste dimensioni
FIBITMAP* pTmpDib = pDib ;
pDib = FreeImage_Rescale( pTmpDib, nNewW, nNewH, FILTER_BILINEAR) ;
FreeImage_Unload( pTmpDib) ;
nWidth = nNewW ;
nHeight = nNewH ;
// verifico che la nuova immagine sia valida
if ( pDib == nullptr)
return false ;
if ( FreeImage_GetBits( pDib) == nullptr ||
FreeImage_GetWidth( pDib) != nWidth || FreeImage_GetHeight( pDib) != nHeight) {
FreeImage_Unload( pDib) ;
pDib = nullptr ;
return false ;
}
}
return true ;
}
//----------------------------------------------------------------------------
//// !!! PROVVISORIO Textures
//#define checkImageWidth 64
//#define checkImageHeight 64
//static GLubyte checkImage[checkImageHeight][checkImageWidth][4];
//static GLuint texName;
//
//void makeCheckImage(void)
//{
// int i, j, c;
//
// for (i = 0; i < checkImageHeight; i++) {
// for (j = 0; j < checkImageWidth; j++) {
// c = (((i&0x8)==0)^((j&0x8)==0))*255;
// checkImage[i][j][0] = (GLubyte) c;
// checkImage[i][j][1] = (GLubyte) c;
// checkImage[i][j][2] = (GLubyte) c;
// checkImage[i][j][3] = (GLubyte) 255;
// }
// }
//}
//
//#include "\EgtDev\Extern\FreeImage\Include\FreeImage.h"
//#include "\EgtDev\Include\EgtStringConverter.h"
//#include <string>