K3dTextureBuild.cpp

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2007 by Jan Koci   *
 *   honza.koci@email.cz   *
 *   http://kengine.sourceforge.net/tutorial/
 *                                                                         *
 *   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.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

#include "K3dTextureBuild.h"

K3dTextureBuild::K3dTextureBuild(K3dGameData *_pGameData)
{
        cout << "K3dTexture::K3dTexture()" << endl;
        m_pGameData = _pGameData;
        // Set this pointer to the game data
        m_pGameData->SetTextureBuild(this);
}

K3dTextureBuild::~K3dTextureBuild()
{
        cout << "K3dTexture::~K3dTexture()" << endl;
        DeleteTextures();
}

void K3dTextureBuild::DeleteTextures()
{
        while(m_pGameData->GetTextureObjSP().GetNum())
        {
                K3dTextureObj *p = m_pGameData->GetTextureObjSP().Get(0);
                p = m_pGameData->GetTextureObjSP().Delete(p);
        }
}

void K3dTextureBuild::LoadTextures()
{
        cout << "void K3dTextureBuild::LoadTextures()" << endl;
        K3dString strFc = "void K3dTextureBuild::LoadTextures() -- ";
        K3dString strOut;
        // Get virtual machine from global data
        K3dLua *pLua = m_pGameData->GetLua();
        // Get number of textures
        pLua->LuaGetGlobal(K_STR_NUM_TEXTURES);
    if (!pLua->LuaIsNumber(-1))
        {
                cerr << "Warning: void K3dTextureBuild::LoadTextures(): Doesn`t load " << K_STR_NUM_TEXTURES << " from map file" << endl;
                return;
    }
        int iNumTextures = (int) pLua->LuaToNumber(-1);
        for(int i=0; i<iNumTextures; i++)
        {
                K3dTextureObj *pTexture = m_pGameData->GetTextureObjSP().New();
                K3dString kString(K_STR_TEXTURE_TABLE);
                // Add number behind string
                kString.AddNumber(i);
                
                pLua->LuaGetGlobal(kString.GetString().c_str());
                if (!pLua->LuaIsTable(-1))
                {
                        strOut = strFc + kString;
                        strOut += " is not a valid texture table";
                        pLua->LuaError(strOut.GetString().c_str());
                }
                
                pTexture->GetName() = pLua->LuaGetFieldString(K_STR_NAME);
                K3dString strPath = pLua->LuaGetFieldString(K_STR_PATH);
                // Set texture filename 
                K3dString strFileName = m_pGameData->GetPath(K_PATH_APP) + strPath;
                // Create texture and get texture index
                pTexture->GetId() = CreateTexture(strFileName.GetString().c_str());
                // Set texture width and height
                pTexture->GetWidth() = GetTextureWidth();
                pTexture->GetHeight() = GetTextureHeight();
        }
}

int K3dTextureBuild::FindTextureId(const char* _strName)
{
        K3dString strName(_strName);
        for(int i=0; i<m_pGameData->GetTextureObjSP().GetNum(); i++)
        {
                K3dTextureObj *pTexture = m_pGameData->GetTextureObjSP().Get(i);
                if(strName == pTexture->GetName())
                {
                        return i;
                }
        }
        return -1;
}

bool K3dTextureBuild::SwapSurfaceRows(SDL_Surface *_ptSurface)
{
        cout << "bool K3dTexture::SwapSurfaceRows(SDL_Surface *_ptSurface)" << endl;
        Uint8 *puiHiRow, *puiLoRow, *puiTmpRow;

        // Alokace pameti pro pomocny radek
        puiTmpRow = (Uint8 *)malloc(_ptSurface->pitch);

        if(puiTmpRow == NULL)
        {
                fprintf(stderr, "Unable to allocate memory.\n");
                cerr << "bool K3dTexture::SwapSurfaceRows() -- Error - Unable to allocate memory" << endl;
                return false;
        }

        // Pointer to the firts and last row
        puiHiRow = (Uint8 *)_ptSurface->pixels;
        puiLoRow = puiHiRow + (_ptSurface->h * _ptSurface->pitch) - _ptSurface->pitch;

        if(SDL_MUSTLOCK(_ptSurface))
        {
                if(SDL_LockSurface(_ptSurface) == -1)
                {
                        fprintf(stderr, "Unable to lock _ptSurface.\n");
                        cerr << "bool K3dTexture::SwapSurfaceRows() -- Error - Unable to lock _ptSurface." << endl;
                        free(puiTmpRow);
                        return false;
                }
        }

        for(int i = 0; i < _ptSurface->h / 2; i++)
        {
                memcpy(puiTmpRow, puiHiRow, _ptSurface->pitch);
                memcpy(puiHiRow, puiLoRow, _ptSurface->pitch);
                memcpy(puiLoRow, puiTmpRow, _ptSurface->pitch);

                puiHiRow += _ptSurface->pitch;
                puiLoRow -= _ptSurface->pitch;
        }

        if (SDL_MUSTLOCK(_ptSurface))
        {
                SDL_UnlockSurface(_ptSurface);
        }

        free(puiTmpRow);

        return true;
}

GLuint K3dTextureBuild::CreateTexture(SDL_Surface *_ptSurface)
{
        cout << "GLuint K3dTexture::CreateTexture(SDL_Surface *_ptSurface)" << endl;
        GLuint iTexture;                
        Uint32 uiSavedFlags;    
        Uint8  uiSavedAlpha;
        SDL_Surface *ptTmpImg;  

        // Create empty RGB surface
        ptTmpImg = SDL_CreateRGBSurface(
                SDL_SWSURFACE,          // Software surface
                _ptSurface->w, _ptSurface->h,   
                m_pGameData->GetGraphicOption()->iColorBits,                    // Color Depth
        #if SDL_BYTEORDER == SDL_LIL_ENDIAN
                                0x000000FF,             // OpenGL RGBA mask
                                0x0000FF00,
                                0x00FF0000,
                                0xFF000000
        #else
                                0xFF000000,
                                0x00FF0000,
                                0x0000FF00,
                                0x000000FF
        #endif
                );

        if(ptTmpImg == NULL)
                return 0;

        // Set texture width and height
        m_iWidth = _ptSurface->w;
        m_iHeight = _ptSurface->h;

        // Save alpha blending atribute
        uiSavedFlags = _ptSurface->flags & (SDL_SRCALPHA|SDL_RLEACCELOK);
        uiSavedAlpha = _ptSurface->format->alpha;

        if((uiSavedFlags & SDL_SRCALPHA) == SDL_SRCALPHA)
                SDL_SetAlpha(_ptSurface, 0, 0);

        // Copy surface to the texture picture
        SDL_Rect tArea;
        tArea.x = 0;
        tArea.y = 0;
        tArea.w = _ptSurface->w;
        tArea.h = _ptSurface->h;
        SDL_BlitSurface(_ptSurface, &tArea, ptTmpImg, &tArea);

        // Restore alpha blending atributes
        if((uiSavedFlags & SDL_SRCALPHA) == SDL_SRCALPHA)
                SDL_SetAlpha(_ptSurface, uiSavedFlags, uiSavedAlpha);

        // Swap surface rows
        if(!SwapSurfaceRows(ptTmpImg))
        {
                cout << "GLuint K3dTexture::CreateTexture(SDL_Surface *_ptSurface) -- Error - SwapSurfaceRows returns some error..." << endl;
                SDL_FreeSurface(ptTmpImg);
                return 0;
        }
        
        cout << "GLuint K3dTexture::CreateTexture(SDL_Surface *_ptSurface) -- glGenTextures -- iTexture = " << iTexture << endl;
        // Create texture
        glGenTextures(1, &iTexture);
        glBindTexture(GL_TEXTURE_2D, iTexture);
        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,
                _ptSurface->w, _ptSurface->h,
                0,
                GL_RGBA,
                GL_UNSIGNED_BYTE,
                ptTmpImg->pixels);

        cout << "GLuint K3dTexture::CreateTexture(SDL_Surface *_ptSurface) -- SDL_FreeSurface " << ptTmpImg << endl;
        SDL_FreeSurface(ptTmpImg);
        return iTexture;
}

GLuint K3dTextureBuild::CreateTexture(const char* _strFileName)
{
        cout << "GLuint K3dTexture::CreateTexture()" << endl;
        cout << "Input filename = " << _strFileName << endl;
        GLuint iTexture;

        //cout << "Application path = " << m_pGameData->GetPath(K_PATH_APP).GetString() << endl;
        //K3dString strFileName = m_pGameData->GetPath(K_PATH_APP) + _strFileName;
        //cout << "Filename for load = " << strFileName.GetString( ) << endl;
        // Load image
        SDL_Surface *ptImg = IMG_Load(/*_strFileName.GetString().c_str()*/_strFileName);

        if(ptImg == NULL)
        {
                //fprintf(stderr, "Unable to load '%s': %s\n",
                //      _strFileName, SDL_GetError());
                cerr << "GLuint K3dTexture::CreateTexture() -- Error - Doesn`t load texture " << _strFileName/*.GetString()*/ << SDL_GetError() << endl;
                return 0;
        }

        iTexture = CreateTexture(ptImg);
        cout << "GLuint K3dTexture::CreateTexture(const char* _strFileName) -- SDL_FreeSurface " << ptImg << endl;
        SDL_FreeSurface(ptImg);
        cout << "GLuint K3dTexture::CreateTexture(const char* _strFileName) -- SDL_FreeSurface - OK " << ptImg << endl;
        return iTexture;
}

---