texture.cpp

Go to the documentation of this file.

// Texture handling

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
#include <GL/glu.h>

#include "config.h"
#include "texture.h"

// Textures file names
static const char *g_texfiles[TEX_N] = {
  "rock.raw_256x256_rgba_byte",
  "snow.raw_256x256_rgba_byte",
  "grass.raw_256x256_rgba_byte",
  "sand.raw_256x256_rgba_byte",
  "grass-shtrih"
};

static const char *g_cube_map_files[6] = {
    "tropical_lf.raw_256x256_rgba_byte",
    "tropical_rt.raw_256x256_rgba_byte",
    "tropical_up.raw_256x256_rgba_byte",
    "tropical_dn.raw_256x256_rgba_byte",
    "tropical_ft.raw_256x256_rgba_byte",
    "tropical_rt.raw_256x256_rgba_byte" };
    
GLuint g_cube_map_handle;
    

// Texture handles
static GLuint g_handles[TEX_N];
// Texture data
typedef unsigned char rgba[4];
typedef rgba teximage[ 256*256 ];
static teximage g_textures[TEX_N];

static teximage g_cube_map_textures[6];

// Initialize all textures
void initTextures()
{
  // Generate handles
  glGenTextures( TEX_N, g_handles );

  glGenTextures( 1, &g_cube_map_handle);

  // Load textures
  for (int i=0; i<TEX_N; i++) {

    // Generate filename
    char filename[300];
    strcpy( filename, g_strResourceDir );
    strcat( filename, g_texfiles[i] );

    // Open and read file (binary mode)
    FILE *f = fopen( filename, "rb" );
    if (f == NULL) {
      printf( "Error opening texture file %s\n.", g_texfiles[i] );
      exit(1);
    }

    int n = fread( g_textures[i], 4, 256*256, f );
    if (n != 256*256) {
      printf( "Error reading texture file %s: Only %i pixels read.\n",
              g_texfiles[i], n );
    }
    else {
      printf( "Successfully loaded texture %s.\n", g_texfiles[i] );
    }

    // Load texture image to OpenGL
    glBindTexture( GL_TEXTURE_2D, g_handles[i] );
    // Build all mipmap stages
    gluBuild2DMipmaps( GL_TEXTURE_2D, GL_RGBA, 256, 256, GL_RGBA, GL_UNSIGNED_BYTE, g_textures[i] );

    // Set filtering modes
    // LINEAR_MIPMAP_LINEAR specifies the highest quality mode, sometimes called
    // "trilinear filtering". Anisotropic is even better, but not yet officially supported in OpenGL.
    //   glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST );
    //glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );

    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR );
    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
  }

//loading cube map
GLenum Texture;
    for (int i=0; i<6; i++)
    {
    // Generate filename
    char filename[200];
    strcpy( filename, g_strResourceDir );
    strcat( filename, g_cube_map_files[i] );

    // Open and read file (binary mode)
    FILE *f = fopen( filename, "rb" );
    if (f == NULL) {
      printf( "Error opening texture file %s\n.", g_cube_map_files[i] );
      exit(1);
    }

    int n = fread( g_cube_map_textures[i], 4, 256*256, f );
    if (n != 256*256) {
      printf( "Error reading texture file %s: Only %i pixels read.\n",
              g_cube_map_files[i], n );
    }
    else {
      printf( "Successfully loaded texture %s.\n", g_cube_map_files[i] );
    }

    // Load texture image to OpenGL
        switch (i)
        {
        case 0: Texture = GL_TEXTURE_CUBE_MAP_POSITIVE_X; break;
        case 1: Texture = GL_TEXTURE_CUBE_MAP_NEGATIVE_X; break;
        case 2: Texture = GL_TEXTURE_CUBE_MAP_POSITIVE_Y; break;
        case 3: Texture = GL_TEXTURE_CUBE_MAP_NEGATIVE_Y; break;
        case 4: Texture = GL_TEXTURE_CUBE_MAP_POSITIVE_Z; break;
        case 5: Texture = GL_TEXTURE_CUBE_MAP_NEGATIVE_Z; break;
        }
//    glBindTexture( GL_TEXTURE_2D, g_handles[i] );
    // Build all mipmap stages
    gluBuild2DMipmaps( Texture,//GL_TEXTURE_2D, 
        GL_RGBA, 256, 256, GL_RGBA, GL_UNSIGNED_BYTE, g_cube_map_textures[i] );
    }
    glBindTexture( GL_TEXTURE_CUBE_MAP, g_cube_map_handle);
//    glEnable( GL_TEXTURE_CUBE_MAP);

}

// Delete all textures
void deleteTextures()
{
  // Release handles
  glDeleteTextures( TEX_N, g_handles );
  
  glDeleteTextures( 1, &g_cube_map_handle);
}


// Get the OpenGL texture handle of a texture
GLuint texture( TEXTURE t )
{
  assert( t>=0 && t<TEX_N );
  return g_handles[t];
}

---