E:/Eigene Dateien/Eigene Projekte/c0re/TextureInterface.cpp

Go to the documentation of this file.

/*
        This file is part of c0re.

        c0re is a multiplayer RTS on a hexagonal map with an evolving unit concept.
    Copyright (C) 2007 Stephan Hofmann

    c0re 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 3 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, see <http://www.gnu.org/licenses/>.
*/

#include "TextureInterface.h"

#include "system.h"
#include <GL/gl.h>
#include <GL/glu.h>
#include <IL/il.h>

int TextureInterface::s_handlerIndex = 1;

TextureInterface::TextureInterface()
{
                ilInit();
}

TextureInterface::~TextureInterface()
{
}

TextureData* TextureInterface::loadBMP(std::string p_filename)
{
        TextureData* ret = 0;
        int i;

        int j=0; //Index variables
        FILE *l_file; //File pointer

        if( fopen_s(&l_file, p_filename.c_str(), "rb") == 0) 
        {  
                ret = new TextureData;

                fread(&(ret->fileheader), sizeof(ret->fileheader), 1, l_file); // Read the fileheader
                
                fseek(l_file, sizeof(ret->fileheader), SEEK_SET); // Jump the fileheader
                fread(&(ret->infoheader), sizeof(ret->infoheader), 1, l_file); // and read the infoheader

                // Now we need to allocate the memory for our image (width * height * color deep)
                ret->l_texture = (unsigned char *) malloc(ret->infoheader.biWidth * ret->infoheader.biHeight * 4);
                // And fill it with zeros
                memset(ret->l_texture, 0, ret->infoheader.biWidth * ret->infoheader.biHeight * 4);
                
                // At this point we can read every pixel of the image
                for (i=0; i < (ret->infoheader.biWidth) * (ret->infoheader.biHeight); i++)
                {            
                                // We load an RGB value from the file
                                fread(&(ret->rgb), sizeof(ret->rgb), 1, l_file); 

                                // And store it
                                ret->l_texture[j+0] = ret->rgb.rgbtRed; // Red component
                                ret->l_texture[j+1] = ret->rgb.rgbtGreen; // Green component
                                ret->l_texture[j+2] = ret->rgb.rgbtBlue; // Blue component
                                ret->l_texture[j+3] = 255; // Alpha value
                                j += 4; // Go to the next position
                }

                fclose(l_file); // Closes the file stream
        }

        return ret;
}

int TextureInterface::bind(TextureData* data)
{
        int ret = 0;

        s_handlerIndex++;
        glBindTexture(GL_TEXTURE_2D, ret=s_handlerIndex); // Bind the ID texture specified by the 2nd parameter

        // The next commands sets the texture parameters
        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); // If the u,v coordinates overflow the range 0,1 the image is repeated
        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); // The magnification function ("linear" produces better results)
        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST); //The minifying function

        glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); // We don't combine the color with the original surface color, use only the texture map.

        // Finally we define the 2d texture
        glTexImage2D(GL_TEXTURE_2D, 0, 4, data->infoheader.biWidth, data->infoheader.biHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, data->l_texture);

        // And create 2d mipmaps for the minifying function
        gluBuild2DMipmaps(GL_TEXTURE_2D, 4, data->infoheader.biWidth, data->infoheader.biHeight, GL_RGBA, GL_UNSIGNED_BYTE, data->l_texture);

        glBindTexture(GL_TEXTURE_2D, 0);

        return ret;
}

TextureData* TextureInterface::loadPNG(std::string p_filename)
{
        TextureData *ret = 0;
        ilBindImage(0);
        if (ilLoadImage(p_filename.c_str()) == IL_TRUE)
        {
                ret = new TextureData();
                ret->infoheader.biWidth = ilGetInteger(IL_IMAGE_WIDTH);
                ret->infoheader.biHeight = ilGetInteger(IL_IMAGE_HEIGHT);
                ret->l_texture = (unsigned char*)malloc(ret->infoheader.biWidth * ret->infoheader.biHeight * sizeof(unsigned char) * 4);
                ilCopyPixels(0, 0, 0, ret->infoheader.biWidth, ret->infoheader.biHeight, 1, IL_RGBA, IL_UNSIGNED_BYTE, ret->l_texture);
                while (ilGetError() != IL_NO_ERROR)
                        int stop = 1;
        }
        int stop;
        while (stop = ilGetError() != IL_NO_ERROR)
                stop = 1;
        return ret;
}

---