source: GTP/trunk/App/Demos/Vis/FriendlyCulling/src/Texture.cpp @ 2825

#include "Texture.h"
#include "glInterface.h"
#include "common.h"

#include <IL/il.h>
#include <assert.h>
#include <iostream>


namespace CHCDemoEngine
{

using namespace std;


void startil()
{
        ilInit();
        assert(ilGetError() == IL_NO_ERROR);
}


void stopil()
{
        ilShutDown();
        assert(ilGetError() == IL_NO_ERROR);
}


Texture::Texture(const std::string &filename):
mWidth(0), mHeight(0), mFormat(0), mImage(NULL), mTexId(-1), mName(filename)
{
        startil();
        
        if (!ilLoadImage(ILstring(filename.c_str())))
        {
                cerr << "Image load error " << ilGetError() << ": " << filename << endl;
        }
        else
        {
                mWidth = ilGetInteger(IL_IMAGE_WIDTH);
                mHeight = ilGetInteger(IL_IMAGE_HEIGHT);

                mFormat = FORMAT_RGBA;
                mByteSize = mHeight * GetRowLength();
                mImage = malloc(GetByteSize());

                Debug << "successfully loaded texture " << filename << " w " << mWidth << " h " << mHeight << endl;

                ilCopyPixels(0, 0, 0, mWidth, mHeight, 1, IL_RGBA, IL_UNSIGNED_BYTE, mImage);
                assert(ilGetError() == IL_NO_ERROR);
        }
        
        stopil();

        Create();
}


void Texture::Create()
{
        glEnable(GL_TEXTURE_2D);

        glGenTextures(1, &mTexId);
        glBindTexture(GL_TEXTURE_2D, mTexId);
        
        glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);

        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);

        glTexImage2D(GL_RGBA, 0, GL_RGBA, mWidth, mHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, mImage);
        gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGBA, mWidth, mHeight, GL_RGBA, GL_UNSIGNED_BYTE, mImage);

        glBindTexture(GL_TEXTURE_2D, 0);
}


int Texture::GetFormat() const
{
        return mFormat;
}


int Texture::GetWidth() const
{
        return mWidth;
}


int Texture::GetHeight() const
{
        return mHeight;
}


void *Texture::GetImage() const
{
        return mImage;
}


Texture::~Texture()
{
        glDeleteTextures(1, &mTexId);
        free(mImage);
}


std::string Texture::GetName() const
{
        return mName;
}


int Texture::GetRowLength() const
{
        if (mFormat == FORMAT_RGBA)
                return mWidth * 4 * sizeof (unsigned char);
        else
                return mWidth * 3 * sizeof (unsigned char);
}


int Texture::GetPixelSize() const
{
        if (mFormat == FORMAT_RGBA)
                return 4 * sizeof(unsigned char);
        else 
                return 3 * sizeof(unsigned char);
}


void Texture::Bind() const
{
        glBindTexture(GL_TEXTURE_2D, mTexId);
}

}