texture.cpp

Go to the documentation of this file.

/* *************************************************************************************
        Writer:         Sebastien Bloc
        Copyright:      2003-2004
        eMail:          sebastien.bloc@free.fr
        URL:            http://mignonsoft.free.fr

        This program is free software; you can redistribute it and/or
        modify it under the terms of the GNU General Public License
        as published by the Free Software Foundation; either version 2
        of the License, or (at your option) any later version.

        This program is distributed in the hope that it will be useful,
        but WITHOUT ANY WARRANTY; without even the implied warranty of
        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        GNU General Public License for more details.
        http://www.gnu.org/copyleft/gpl.html
************************************************************************************* */

#include "3d.h"
#include "texture.h"
#include "FreeImage.h"

void Texture::VerifyId()
{
        if (!id) 
        {
                GLuint idCur;
                glGenTextures(1,&idCur);
                id = idCur;
                list.i+=this; // nouvelle arrivant dans la liste generale
                Config();
        }
        glBindTexture(target,id);
}

void Texture::Config() 
{
        VerifyId();
        glTexParameteri(target, GL_TEXTURE_MAG_FILTER, magFilter); 
        glTexParameteri(target, GL_TEXTURE_MIN_FILTER, minFilter); 
        glTexParameteri(target, GL_TEXTURE_WRAP_T , wrapT);
        glTexParameteri(target, GL_TEXTURE_WRAP_S , wrapS);
        if (border.isEnable) glTexParameterfv(target, GL_TEXTURE_BORDER_COLOR , border);
        glTexEnvi(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,envMode);
        if (envColor.isEnable) glTexEnvfv(GL_TEXTURE_ENV,GL_TEXTURE_ENV_COLOR ,envColor);
}

BOOL Texture::Delete()
{
        return Texture::Delete(this);
}

BOOL Texture::Delete(Texture *texture)
{
        for (list.i=0;list.i.More();list.i++)
        {
                if (texture==list.i.GetElem()) 
                { 
                        list.i.Supr(); 
                        return TRUE; 
                }
        }
        return FALSE;
}

void Texture::ConfigPixelStore()
{
        // sinon pb defois
        glPixelStorei( GL_UNPACK_ALIGNMENT,   1);
        glPixelStorei( GL_UNPACK_ROW_LENGTH,  0);
        glPixelStorei( GL_UNPACK_SKIP_ROWS,   0);
        glPixelStorei( GL_UNPACK_SKIP_PIXELS, 0);
}

GLubyte * Texture::ConfigSize (int _xSize,int _ySize,BOOL allocate,BOOL resizeIt)
{   
        VerifyId();

        xSize = GetNearExp2(_xSize);
        ySize = GetNearExp2(_ySize);

        if (resizeIt)
        {
                xScale = 1;
                yScale = 1;
        }
        else 
        {
                xScale = _xSize/(double)xSize;
                yScale = _ySize/(double)ySize;
                if ( (xSize!=_xSize) || (ySize!=_ySize) ) useResizing = TRUE;
        }

        ConfigPixelStore();

        if (allocate)
        {
                int size = xSize*ySize*3;
                GLubyte *dataOut= new GLubyte[size];
                ZeroMemory(dataOut,size); 
                return dataOut;
        }
        else return NULL;
}

double Texture::GetXCoord(double x)
{
        if (useResizing) return x*xScale;
        else return x;
}

double Texture::GetYCoord(double y)
{
        if (useResizing) return y*yScale;
        else return y;
}

void Texture::SetCoord(double x,double y)
{
        if (useResizing) glTexCoord2d(x*xScale,y*yScale);
        else glTexCoord2d(x,y);
}


Texture::Texture()
{
        Zero();
}

Texture::~Texture()
{
        GLuint idRes;
        glDeleteTextures(1,&idRes);
        id=idRes;
}

void Texture::Zero()
{
        target = texture2D;
        magFilter=linear;
        minFilter=linear;
        wrapS = repeat;
        wrapT = repeat;
        envMode = modulate;
        envColor.Zero();
        border.Zero();
        name="";
        id=0;
        xScale=0;
        yScale=0;
        useResizing = FALSE;
        dataOut=NULL;
        //VerifId() //ne marche toujour au constructeur car la fenetre openGl n'est peut etre pas encors initialisé
}

void Texture::operator =(Texture &src)
{
        target = src.target;
        id = src.id;
        xScale = src.xScale;
        yScale = src.yScale;
        name = src.name;
        source = src.source;
        useResizing = src.useResizing;
        xSize = src.xSize;
        ySize = src.ySize;
        wrapS = src.wrapS;
        wrapT = src.wrapT;
        magFilter = src.magFilter;
        minFilter = src.minFilter;
        border = src.border;
        envMode = src.envMode;
        envColor = src.envColor;
}

BOOL Texture::FromNull()
{
        Begin("Null",1,1);
        SetPixel(0,0,255,255,255);
        End();
        return TRUE;
}


BOOL Texture::FromFile(char *_name,char *fileName,BOOL resizeIt)
{
        source = fileName;
        FREE_IMAGE_FORMAT fif = FreeImage_GetFIFFromFilename(source);
        if (fif == FIF_UNKNOWN) return FALSE;
        FreeImage_Initialise();

        FIBITMAP *bitmap = FreeImage_Load(fif,fileName);
        if (!bitmap) return FALSE;
        BYTE *data = FreeImage_GetBits(bitmap);
        if (!data) 
        {
                FreeImage_Unload(bitmap);       
                return FALSE;
        }

        // get the size of our image
        int bpp = FreeImage_GetBPP(bitmap)/8; // convert from bits to bytes, convert width from bytes in row, to just number of pixels in row

        int xImage = FreeImage_GetPitch(bitmap)/bpp;
        int yImage = FreeImage_GetHeight(bitmap);
        name = _name;
        ConfigSize(xImage,yImage,FALSE,FALSE);

        // Create our texture data
        unsigned char *texData = new unsigned char[xSize*ySize*4];

        FreeImage_ConvertToRawBits(texData, bitmap, xSize*4, 32, FI_RGBA_RED_MASK, FI_RGBA_GREEN_MASK, FI_RGBA_BLUE_MASK,TRUE);

        // texData now contains our image.  However we need to 
        // swap the red and blue color channels and flip the scanlines
        // in the vertical direction
        // This is because of the difference between how OpenGL and FreeImage
        // store image data internally.

        int linesize = xSize*4;

        // flip color components
        for(int y=0; y < ySize; y++)
        {
                int pos = y*linesize;
                for(int x=0; x < xSize; x++)
                {
                        int xpos = y*linesize + x*4;
                        unsigned char temp = texData[xpos];
                        texData[xpos] = texData[xpos+2];
                        texData[xpos+2] = temp;
                }       
        }

        if (resizeIt)
        {
                gluScaleImage(GL_RGBA,xImage,yImage,GL_UNSIGNED_BYTE,texData,xSize,ySize,GL_UNSIGNED_BYTE,texData);
                glTexImage2D(GL_TEXTURE_2D,0,GL_RGBA,xSize,ySize,FALSE,GL_RGBA,GL_UNSIGNED_BYTE,texData);
                xScale=1;
                yScale=1;
                useResizing=FALSE;
        }
        else glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA,xSize,ySize,0,GL_RGBA, GL_UNSIGNED_BYTE,texData); 
        delete [] texData; // release files

        FreeImage_Unload(bitmap);       
        FreeImage_DeInitialise();
        return TRUE;
}

Texture * Texture::Find(char *name)
{
        Texture *finding;
        for (list.i=0;list.i.More();list.i++)
        {
                finding = list.i.GetElem();
                if (finding->name==name) return finding;
        }
        return NULL;
}

BOOL Texture::Begin(char *_name,int deltaX,int deltaY)
{
        name = _name;
        dataOut = ConfigSize(deltaX,deltaY,TRUE,FALSE);
        return dataOut?TRUE:FALSE;
}

BOOL Texture::End()
{
        if (!dataOut) return FALSE; // erreur de semantique donc (il dois y avoir un Begin() avant
        glTexImage2D(GL_TEXTURE_2D,0,GL_RGB,xSize,ySize,FALSE,GL_RGB,GL_UNSIGNED_BYTE,dataOut);
        delete dataOut;
        dataOut=NULL;
        return TRUE;
}

BOOL Texture::SetPixel(int x,int y,byte r,byte g,byte b)
{
        // test d'integrité
        if (!dataOut) return FALSE;
        if (x>=xSize||y>=ySize||x<0||y<0) return FALSE; // le point est il a une coordonnée correct
        int pos = (xSize*y+x)*3;
        dataOut[pos]=r;
        dataOut[pos+1]=g;
        dataOut[pos+2]=b;
        return TRUE;
}

BOOL Texture::GetPixel(int x,int y,byte &r,byte &g,byte &b)
{
        // test d'integrité
        if (!dataOut) return FALSE;
        if (x>=xSize||y>=ySize||x<0||y<0) return FALSE; // le point est il a une coordonnée correct
        int pos = (xSize*y+x)*3;
        r=dataOut[pos];
        g=dataOut[pos+1];
        b=dataOut[pos+2];
        return TRUE;
}
BOOL Texture::AddText(char *text,COLORREF color,COLORREF background,int xFormat,int yFormat)
{
        if (!dataOut) return FALSE;

        HBITMAP hBitmap = CreateBitmap(xSize, ySize, 16, 2, NULL);
        if (!hBitmap) return FALSE;
        BITMAP bitmap;
        GetObject(hBitmap,sizeof(bitmap),&bitmap);
        HDC mainDC = GetDC (NULL) ;
        HDC dc = CreateCompatibleDC (mainDC) ;
        SelectObject ( dc, hBitmap);
        RECT r = { 0,0,xSize,ySize};

        // fond unie
        HPEN hPen = CreatePen(PS_SOLID,0,background);
        HPEN hPenOld = (HPEN) SelectObject(dc,hPen);
        HBRUSH hBrush = CreateSolidBrush(background);
        HBRUSH hBrushOld = (HBRUSH) SelectObject(dc,hBrush);
        Rectangle(dc,0,0,xSize,ySize);
        DeleteObject(hBrush);
        DeleteObject(hPen);
        SelectObject(dc,hBrushOld);
        SelectObject(dc,hPenOld);

        SetBkMode(dc,TRANSPARENT);
        SetTextColor(dc,color);

        // parse le type de format
        UINT format = 0;
        format |= DT_WORDBREAK;
        switch (xFormat)
        {
        case -1: format |= DT_LEFT; break;
        case 0: format |= DT_CENTER; break;
        case 1: format |= DT_RIGHT; break;
        }
        switch (yFormat)
        {
        //case -1: format |= DT_TOP|DT_SINGLELINE; break;
        case 0: format |= DT_VCENTER|DT_SINGLELINE; break;
        case 1: format |= DT_BOTTOM|DT_SINGLELINE; break;
        }
        DrawText(dc, text, (int)strlen(text), &r, format );

        
        BITMAPINFOHEADER bi;
        ZeroMemory(&bi,sizeof(BITMAPINFOHEADER));
        bi.biSize               = sizeof(BITMAPINFOHEADER);
        bi.biWidth              = bitmap.bmWidth;
        bi.biHeight             = bitmap.bmHeight;
        bi.biPlanes             = bitmap.bmPlanes; //1;
        bi.biBitCount           = 24;

        int res = GetDIBits (dc,hBitmap,0,bitmap.bmHeight,dataOut,(LPBITMAPINFO)&bi,DIB_RGB_COLORS);
        ReleaseDC (NULL,mainDC) ;
        DeleteDC (dc) ; 
        return TRUE;
}

BOOL Texture::FromText(char *_name,char *text,COLORREF color,COLORREF background,int xFormat,int yFormat)
{
        Begin(_name,64,64);
        source = text;
        AddText(text,color,background,xFormat,yFormat);
        End();
        return TRUE;
}

BOOL Texture::FromBitmap(char *_name,char *fileName,BOOL resizeIt)
{
        AUX_RGBImageRec *pImage = auxDIBImageLoad(fileName);
        if (!pImage) return FALSE;

        Begin(_name,pImage->sizeX,pImage->sizeY);
        source = fileName;

        if (resizeIt)
        {
                BOOL result = gluScaleImage(GL_RGB,pImage->sizeX,pImage->sizeY,GL_UNSIGNED_BYTE,pImage->data,xSize,ySize,GL_UNSIGNED_BYTE,dataOut);
                if (result) glTexImage2D(GL_TEXTURE_2D,0,GL_RGB,xSize,ySize,FALSE,GL_RGB,GL_UNSIGNED_BYTE,dataOut);
                End();
                delete pImage;
                return result;
        }

        // effectue le scaling 
        int xSizeScale = pImage->sizeX*3;
        int ySizeScale = pImage->sizeY;
        int xDeltaScale = (xSize-pImage->sizeX)*3;

        GLubyte *ptrBufferIn = (GLubyte *)pImage->data;
        GLubyte *ptrBufferOut = dataOut; 

        for (int y=0;y<ySizeScale;y++)
        {
                for (int x=0;x<xSizeScale;x++) *ptrBufferOut++=*ptrBufferIn++;
                ptrBufferOut+=xDeltaScale;
        }       

        End();
        delete pImage;
        return TRUE;
}

---