---

r_textures.cpp

Go to the documentation of this file.

// OMICRON ENGINE HEADER FILE
//
// --------------------------------------------------------------------------
// Copyright (C) 2001-2002 by Bjoern Paetzel <kolrabi@gmx.de>
//
// This file is part of the Omicron Engine.
//
// The Omicron Engine 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.
//
// The Omicron Engine  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 The Omicron Engine;  if not,  write to the  Free Software Foundation,
// Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
//
// --------------------------------------------------------------------------
// Last modified:       $Date: 2002/12/13 12:29:26 $
// By           :       $Author: kolrabi $
// $Id: r_textures.cpp,v 1.2 2002/12/13 12:29:26 kolrabi Exp $ 

/*

  $Log: r_textures.cpp,v $
  Revision 1.2  2002/12/13 12:29:26  kolrabi
  fixed some bugs

  Revision 1.1.1.1  2002/12/07 19:02:04  kolrabi
  initial release


*/

#include            "omicron/internal.h"
#include            "omicron/render.h"
#include            "omicron/texture.h"
#include            "omicron/image.h"
#include            "omicron/file.h"
#include            "omicron/array.h"

/**************************************************************************** 
 **************************************************************************** 
 * ROUTINES ***************************************************************** 
 **************************************************************************** 
 ****************************************************************************/ 

texture_manager_c::texture_manager_c()
{
    SafeDelete(gv.texman);

    gv.texman = this;

    textures = new array_c<texture_t>;
}

texture_manager_c::~texture_manager_c()
{
    gv.texman = NULL;
    freeall();
    SafeDelete(textures);
}

/****************************************************************************
 * find                         returns the number of the requested texture *
 ****************************************************************************/
sshort texture_manager_c::find
(  
    const char *        name                
)
{
    for (sshort i=0; i<textures->get_count(); i++) 
    {
        texture_t *tex = textures->get(i);

        if (tex->texture != 0 && !strcmpi(name, tex->name)) 
              return i; 
    }

    return TEXTURE_NOTFOUND; 
}

/****************************************************************************
 * create                                      create a texture in any slot *
 ****************************************************************************/
sshort texture_manager_c::create
(
    ushort  width,                  // requested width 
    ushort  height,                 // and height 
    const char    *szName                 // and name of the texture 
)
{
    texture_t *tex = new texture_t;

    tex->width = width;
    tex->height = height;
    sprintf(tex->name, "%s", szName);
    tex->texture = 0;

    return (sshort)textures->add(tex);
}


/****************************************************************************
 * load_ex                                   load a texture to a given slot *
 ****************************************************************************/
sshort texture_manager_c::load
(  
    const char      *name,                  // texture name 
    bool            nocomp
) 
{ 
    image_c       *img;             // the image descriptoer 

    // load image 
    img = new image_c;
    AssertReturnValue1(img, INVALID_INDEX);
    
    if (!img->load(name))
    {
        SafeDelete(img);
        return INVALID_INDEX;
    }

    sshort num;
 
    // create texture 
    if ( ( num = create( img->get_width(), img->get_height(), name ))
          == INVALID_INDEX )
    { 
        SafeDelete(img);
        return INVALID_INDEX; 
    } 

    set_bits(num, img->get_pixels(), true, nocomp); 

    SafeDelete(img); 

    return num; 
}

/****************************************************************************
 * freeall                                                free all textures *
 ****************************************************************************/
void texture_manager_c::freeall
(
) 
{ 
    _log_printf(MSG_DEBUG, "freeing textures..."); 

    ulong c = 0; 
    
    for (sshort i=0; i<textures->get_count(); i++) 
    { 
        texture_t *tex = textures->get(i);

        if (!tex)
            continue;

        if (tex->texture) 
            glDeleteTextures(1, (GLuint*)&tex->texture); 

        textures->remove_ptr(tex);

        SafeDelete(tex);

        c++; 
    } 
 
    _log_printf(MSG_DEBUG, "%u textures freed...", c); 
} // freeall 
 
/****************************************************************************
 * free                                                    free one texture *
 ****************************************************************************/
void texture_manager_c::freetex
(
    sshort num
)
{
    texture_t *tex = textures->get(num);

    if (!tex)
        return;

    if (tex->texture) 
        glDeleteTextures(1, (GLuint*)&tex->texture); 

    textures->remove_ptr(tex);
    SafeDelete(tex);
} // free 
 
/****************************************************************************
 * set                                                     sets the texture *
 ****************************************************************************/
void texture_manager_c::set 
(  
    sshort num,                         
    sshort /* stage */                  
) 
{ 
    if (num<-1 || num>textures->get_count()) 
        num = -1;
    
    if (num == -1)
    {
        glDisable(GL_TEXTURE_2D);
        return;
    }

    texture_t *tex = textures->get(num);

    glEnable(GL_TEXTURE_2D);
    glBindTexture(GL_TEXTURE_2D, tex->texture); 
} // set 
 
/****************************************************************************
 * setbits                                            sets the texture bits *
 ****************************************************************************/
void texture_manager_c::set_bits
(
    sshort          num, 
    const char *    bits,
    bool            mipmaps,
    bool            nocompression
) 
{ 
    if (num<-1 || num>textures->get_count()) 
        return;

    ulong internalformat = GL_RGBA; 

    AssertReturn1(textures);
    
    texture_t *tex = textures->get(num);
    
    AssertReturn1(tex);

    if (!tex->texture)
    {
        GLuint t;
        
        glGenTextures(1, &t);
        tex->texture = t;
    }
    glBindTexture(GL_TEXTURE_2D, tex->texture); 
    glPixelStorei(GL_UNPACK_ALIGNMENT, 1); 
 
#if defined(WIN32)
    if (extgl_Extensions.ARB_texture_compression && !nocompression)
    { 
        if (extgl_Extensions.EXT_texture_compression_s3tc) 
            internalformat = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT; 
        else 
            internalformat = GL_COMPRESSED_RGBA_ARB; 
    } 
#endif
    
    glTexImage2D(GL_TEXTURE_2D, 0, internalformat, tex->width, tex->height, 0, GL_RGBA, GL_UNSIGNED_BYTE, bits); 

    if (mipmaps)
        gluBuild2DMipmaps(GL_TEXTURE_2D, internalformat, tex->width, tex->height, GL_RGBA, GL_UNSIGNED_BYTE, bits); 
} 
 
/****************************************************************************
 * setbits24                                          sets the texture bits *
 ****************************************************************************/
void texture_manager_c::set_bits24
(
    sshort          num, 
    const char *    bits,
    bool            mipmaps,
    bool            nocompression
) 
{ 
    if (num<0 || num>=textures->get_count())
        return;

    ulong internalformat = GL_RGB; 
    texture_t *tex = textures->get(num);

    glBindTexture(GL_TEXTURE_2D, tex->texture); 
    glPixelStorei(GL_UNPACK_ALIGNMENT, 1); 

#if defined(WIN32)
    if (extgl_Extensions.ARB_texture_compression && !nocompression)
    { 
        if (extgl_Extensions.EXT_texture_compression_s3tc) 
            internalformat = GL_COMPRESSED_RGB_S3TC_DXT1_EXT; 
        else 
            internalformat = GL_COMPRESSED_RGB_ARB; 
    }
#endif
    
    glTexImage2D(GL_TEXTURE_2D, 0, internalformat, tex->width, tex->height, 0, GL_RGB, GL_UNSIGNED_BYTE, bits); 

    if (mipmaps)
        gluBuild2DMipmaps(GL_TEXTURE_2D, internalformat, tex->width, tex->height, GL_RGB, GL_UNSIGNED_BYTE, bits); 
} 

/****************************************************************************
 * get_image                                          gets the texture bits *
 ****************************************************************************/
image_c *texture_manager_c::get_image
( 
    sshort        num
) 
{ 
    if (num<0 || num>=textures->get_count())
        num = 0;

    image_c *img        = new image_c;
    texture_t *tex      = textures->get(num);

    if (!img) return NULL;
 
    img->buflen         = tex->width*tex->height*4; 
    img->width          = tex->width; 
    img->height         = tex->height; 
    img->hasalpha       = false; 
    img->buf            = new char[img->buflen]; 
 
    glBindTexture(GL_TEXTURE_2D, tex->texture); 
    glPixelStorei(GL_UNPACK_ALIGNMENT, 1); 
    glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE, img->buf);

    return img;
} 
 
/****************************************************************************
 * set_image                                          sets the texture bits *
 ****************************************************************************/
void texture_manager_c::set_image
( 
    sshort          num, 
    const image_c * img,
    bool            mipmaps,
    bool            nocompression
) 
{ 
    AssertReturn1(img);

    if (num<0 || num>=textures->get_count())
        num = 0;

    texture_t *tex = textures->get(num);

    if (!tex)
        return;

    tex->width  = img->get_width(); 
    tex->height = img->get_height(); 
 
    set_bits(num, img->get_pixels(), mipmaps, nocompression); 
} 


ushort texture_manager_c::get_width(sshort num)
{
    if (num<0 || num>=textures->get_count())
        return 0;

    texture_t *tex = textures->get(num);
    return tex->width;
}

ushort texture_manager_c::get_height(sshort num)
{
    if (num<0 || num>=textures->get_count())
        return 0;

    texture_t *tex = textures->get(num);
    return tex->height;
}

ulong texture_manager_c::get_gltexture(sshort num)
{
    if (num<0 || num>=textures->get_count())
        return 0;

    texture_t *tex = textures->get(num);
    return tex->texture;
}

---