Subversion Repositories gelsvn

#include "GLGraphics/SimpleTrackBall.h"

#include "GLGraphics/draw.h"

#include <assert.h>

#include <stdio.h>

#ifdef WIN32

#include <windows.h>

#include <io.h>

#endif

#include <string.h>

#include <stdlib.h>

#include <iostream>

#include <CGLA/Vec2i.h>

#include <CGLA/Vec2f.h>

#include <IL/il.h>

#include <IL/ilu.h>

using namespace std;

using namespace CGLA;

bool load_image_into_texture(const std::string& name, GLuint& id)

{

    unsigned char* image = 0;

    unsigned int bpp = 0;

    unsigned int size_x = 0;

    unsigned int size_y = 0;

    unsigned int load_size_x = 0;

    unsigned int load_size_y = 0;

    ILenum Error;

    ILuint  ImgId;

    static bool washere = false;

    if(!washere)

    {

        ilInit();

        iluInit();

        washere=true;

    }

    ilEnable(IL_CONV_PAL);

    ilEnable(IL_ORIGIN_SET);

    ilOriginFunc(IL_ORIGIN_LOWER_LEFT);

    ilGenImages(1, &ImgId);

    ilBindImage(ImgId);

    char* name_cstr = const_cast<char*>(name.c_str());

    if(!ilLoadImage(name_cstr))

    {

        cout << "could not load <" << name_cstr  << ">" << endl;

        return false;

    }

    load_size_x = ilGetInteger(IL_IMAGE_WIDTH);

    load_size_y = ilGetInteger(IL_IMAGE_HEIGHT);

    bpp = ilGetInteger(IL_IMAGE_BITS_PER_PIXEL);

    if (bpp==24)

        ilConvertImage(IL_RGB, IL_UNSIGNED_BYTE);

    else if (bpp==32)

        ilConvertImage(IL_RGBA, IL_UNSIGNED_BYTE);

    else if (bpp==8)

        ilConvertImage(IL_LUMINANCE, IL_UNSIGNED_BYTE);

    else

        assert(0);

    unsigned int i;

    for (i=2;i<=4096 ;i*=2)

        if (i>=load_size_x)

            break;

    size_x = i;

    for (i=2;i<=4096 ;i*=2)

        if (i>=load_size_y)

            break;

    size_y = i;

    if(size_x != load_size_x || size_y != load_size_y)

    {

        iluImageParameter(ILU_FILTER, ILU_BILINEAR);

        iluScale(size_x, size_y, 1);

    }

    const int image_size =size_x*size_y*ilGetInteger(IL_IMAGE_BYTES_PER_PIXEL);

    image = new unsigned char[image_size];

    memcpy(image, ilGetData(), image_size);

    ilDeleteImages(1, &ImgId);

    bool any_errors=false;

    while ((Error = ilGetError())) {

        cout << __LINE__ << "Error: " << iluErrorString(Error) << endl;

        any_errors = true;

    }

    if(any_errors) return false;

    GLint internalFormat=0;

    GLenum format=0;

    glGenTextures(1, &id);

    switch (bpp)

    {

    case 8:

        internalFormat =  GL_LUMINANCE;

        format = GL_LUMINANCE;

        break;

    case 24:

        internalFormat =  GL_RGB;

        format = GL_RGB;

        break;

    case 32:

        internalFormat =  GL_RGBA;

        format = GL_RGBA;

        break;

    default:

        return false;

    }

    glBindTexture(GL_TEXTURE_2D, id);

    glTexImage2D(GL_TEXTURE_2D, 0, internalFormat, size_x, size_y, 0,

                 format, GL_UNSIGNED_BYTE, image);

    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);

    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);

    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

    return true;

}

void enable_textures(TriMesh& tm)

{

    for(int i=0;i<tm.materials.size(); ++i)

    {

        Material& mat = tm.materials[i];

        if(mat.tex_name != "")

        {

            string name = mat.tex_path + mat.tex_name;

            GLuint tex_id;

            if(load_image_into_texture(name, tex_id))

							mat.tex_id = tex_id;

				}

    }

}

    enable_textures(mesh);