VRUT::ImageDDS Class Reference

Image container with support for many formats readable by wxImage. More...

#include <imagedds.h>

Inheritance diagram for VRUT::ImageDDS:

List of all members.

Public Member Functions
	ImageDDS ()
	Class constructor.
virtual	~ImageDDS ()
	Class destructor.
virtual bool	IsOk () const
	Is image properly loaded? - Image overload.
virtual bool	Load (const wxString &fname)
	Load image data from file - Image overload.
virtual GLuint	BuildOglTexture () const
virtual bool	HasTransparency () const
	Get true if image has alpha channel - Image overload.
virtual int	GetWidth () const
	Get the widht of the image.
virtual int	GetHeight () const
	Get the height of the image.
Protected Attributes
struct VRUT::ImageDDS::DdsLoadInfo	image
Classes
union	DDS_header
	Texture header info. More...
struct	DdsLoadInfo
	Image data. More...

---

Detailed Description

Image container with support for many formats readable by wxImage.

Definition at line 126 of file imagedds.h.

---

Constructor & Destructor Documentation

ImageDDS::ImageDDS

(

)

Class constructor.

Definition at line 21 of file imagedds.cpp.

                   : Image()
{
}

ImageDDS::~ImageDDS

(

)

[virtual]

Class destructor.

Definition at line 26 of file imagedds.cpp.

{
}

---

Member Function Documentation

bool ImageDDS::IsOk

(

)

const [virtual]

Is image properly loaded? - Image overload.

Implements VRUT::Image.

Definition at line 31 of file imagedds.cpp.

{
       return (image.data != (unsigned char *)NULL);
}

bool ImageDDS::Load

(

const wxString &

fname

)

[virtual]

Load image data from file - Image overload.

Reimplemented from VRUT::Image.

Definition at line 37 of file imagedds.cpp.

{
       if (Image::Load(fname))
       {
              SAFE_DELETE_ARR(image.data);
              /* Open the file */
              wxFileInputStream fin(fname);
              /* Get the surface descriptor */
              fin.Read(&image.header, sizeof(image.header));

              if ( image.header.dwMagic != DDS_MAGIC || image.header.dwSize != 124 ||
                  !(image.header.dwFlags & DDSD_PIXELFORMAT) || !(image.header.dwFlags & DDSD_CAPS) )
              {
                     LOGERROR(wxString::Format(wxT("<ImageDDS>File '%s' doesn't appear to be a valid .dds file"), fname.c_str()));
                     return false;
              }

              if ( PF_IS_DXT1( image.header.sPixelFormat ) )
              {
                     image.compressed = true;
                     image.swap = false;
                     image.palette = false;
                     image.divSize = 4;
                     image.blockBytes = 8;
                     image.internalFormat = GL_COMPRESSED_RGBA_S3TC_DXT1_EXT;
              }
              else if ( PF_IS_DXT3( image.header.sPixelFormat ) )
              {
                     image.compressed = true;
                     image.swap = false;
                     image.palette = false;
                     image.divSize = 4;
                     image.blockBytes = 16;
                     image.internalFormat = GL_COMPRESSED_RGBA_S3TC_DXT3_EXT;
              }
              else if ( PF_IS_DXT5( image.header.sPixelFormat ) )
              {
                     image.compressed = true;
                     image.swap = false;
                     image.palette = false;
                     image.divSize = 4;
                     image.blockBytes = 16;
                     image.internalFormat = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;
              }
              else if ( PF_IS_BGRA8( image.header.sPixelFormat ) )
              {
                     image.compressed = false;
                     image.swap = false;
                     image.palette = false;
                     image.divSize = 1;
                     image.blockBytes = 4;
                     image.internalFormat = GL_RGBA8;
                     image.externalFormat = GL_BGRA;
                     image.type = GL_UNSIGNED_BYTE;
              }
              else if ( PF_IS_BGR8( image.header.sPixelFormat ) )
              {
                     image.compressed = false;
                     image.swap = false;
                     image.palette = false;
                     image.divSize = 1;
                     image.blockBytes = 3;
                     image.internalFormat = GL_RGB8;
                     image.externalFormat = GL_BGR;
                     image.type = GL_UNSIGNED_BYTE;
              }
              else if ( PF_IS_BGR5A1( image.header.sPixelFormat ) )
              {
                     image.compressed = false;
                     image.swap = true;
                     image.palette = false;
                     image.divSize = 1;
                     image.blockBytes = 2;
                     image.internalFormat = GL_RGB5_A1;
                     image.externalFormat = GL_BGRA;
                     image.type = GL_UNSIGNED_SHORT_1_5_5_5_REV;
              }
              else if ( PF_IS_BGR565( image.header.sPixelFormat ) )
              {
                     image.compressed = false;
                     image.swap = true;
                     image.palette = false;
                     image.divSize = 1;
                     image.blockBytes = 2;
                     image.internalFormat = GL_RGB5;
                     image.externalFormat = GL_RGB;
                     image.type = GL_UNSIGNED_SHORT_5_6_5;
              }
              else if ( PF_IS_INDEX8( image.header.sPixelFormat ) )
              {
                     image.compressed = false;
                     image.swap = false;
                     image.palette = true;
                     image.divSize = 1;
                     image.blockBytes = 1;
                     image.internalFormat = GL_RGB8;
                     image.externalFormat = GL_BGRA;
                     image.type = GL_UNSIGNED_BYTE;
              }
              else
              {
                     LOGERROR(wxString::Format(wxT("<ImageDDS>Unknown pixel format in DDS file '%s'"), fname.c_str()));
                     return false;
              }

              /* Calculate pixel data size */
              unsigned curr = fin.TellI();
              unsigned end = fin.SeekI(0, wxFromEnd);
              fin.SeekI(curr);
              unsigned bufferSize = end - curr;
              /* Read pixel data with mipmaps */
              image.data = new unsigned char[bufferSize];
              fin.Read(image.data, sizeof(unsigned char) * bufferSize);

              return true;
       }
       return false;
}

GLuint ImageDDS::BuildOglTexture

(

)

const [virtual]

Build and bind OpenGL texture from image in CURRENT OpenGL context - Image overload

Returns:

OpenGL ID for texture, GL_ID_NONE if failed

Implements VRUT::Image.

Definition at line 157 of file imagedds.cpp.

{
       GLuint texID = GL_ID_NONE;
       if (IsOk())
       {
              unsigned x = image.header.dwWidth;
              unsigned y = image.header.dwHeight;
              unsigned mipMapCount = (image.header.dwFlags & DDSD_MIPMAPCOUNT) ? image.header.dwMipMapCount : 1;
              glEnable(GL_TEXTURE_2D);

              if (image.compressed)
              {
                     unsigned size = __max( image.divSize, x )/image.divSize * __max( image.divSize, y )/image.divSize * image.blockBytes;
                     if ( size != image.header.dwPitchOrLinearSize || !(image.header.dwFlags & DDSD_LINEARSIZE) )
                     {
                            LOGERROR(wxT("<ImageDDS>Texture size mismatch"));
                            return texID;
                     }
                     PFNGLCOMPRESSEDTEXIMAGE2DPROC vrutCompressedTexImage2D = (PFNGLCOMPRESSEDTEXIMAGE2DPROC) GLGETPROC("glCompressedTexImage2D");
                     if ( vrutCompressedTexImage2D == NULL )
                     {
                            LOGERROR(wxT("<ImageDDS>Compressed textures not supported"));
                            return texID;
                     }

                     glGenTextures( 1, &texID );
                     glBindTexture( GL_TEXTURE_2D, texID );
                     glTexParameteri( GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_FALSE );
                     unsigned offset = 0;
                     for ( unsigned int ix = 0; ix < mipMapCount; ++ix )
                     {
                            vrutCompressedTexImage2D( GL_TEXTURE_2D, ix, image.internalFormat, x, y, 0, size, image.data + offset );
                            GLCHECKERROR;
                            x = (x+1)>>1;
                            y = (y+1)>>1;
                            offset += size;
                            size = __max( image.divSize, x )/image.divSize * __max( image.divSize, y )/image.divSize * image.blockBytes;
                     }
              }
              else if (image.palette) //TODO: not tested
              {
                     //  currently, we unpack palette into BGRA
                     //  I'm not sure we always get pitch...
                     unsigned size = image.header.dwPitchOrLinearSize * image.header.dwHeight;
                     //  And I'm even less sure we don't get padding on the smaller MIP levels...
                     if ( (image.header.dwFlags & DDSD_PITCH) == 0 ||
                            image.header.sPixelFormat.dwRGBBitCount != 8 ||
                            (size != x * y * image.blockBytes) )
                     {
                            LOGERROR(wxT("<ImageDDS>Size mismatch"));
                            return texID;
                     }

                     glGenTextures( 1, &texID );
                     glBindTexture( GL_TEXTURE_2D, texID );
                     glTexParameteri( GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_FALSE );
                     unsigned char * data = image.data + 256 * 4;
                     unsigned int * palette = (unsigned int *)image.data;
                     unsigned int * unpacked = new unsigned[size * sizeof(unsigned)];
                     unsigned offset = 0;
                     for ( unsigned ix = 0; ix < mipMapCount; ++ix )
                     {
                            for ( unsigned zz = 0; zz < size; ++zz )
                            {
                                   unpacked[ zz ] = palette[ data[ zz ] ];
                            }
                            glPixelStorei( GL_UNPACK_ROW_LENGTH, y );
                            glTexImage2D( GL_TEXTURE_2D, ix, image.internalFormat, x, y, 0, image.externalFormat, image.type, unpacked );
                            GLCHECKERROR;
                            x = (x+1)>>1;
                            y = (y+1)>>1;
                            offset += size;
                            size = x * y * image.blockBytes;
                     }
                     delete [] unpacked;
              }
              else
              {
                     if (image.swap )  //TODO: not tested
                            glPixelStorei( GL_UNPACK_SWAP_BYTES, GL_TRUE );
                     glGenTextures( 1, &texID );
                     glBindTexture( GL_TEXTURE_2D, texID );
                     glTexParameteri( GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_FALSE );
                     unsigned size = x * y * image.blockBytes;
                     unsigned offset = 0;
                     //fixme: how are MIP maps stored for 24-bit if pitch != ySize*3 ?
                     for ( unsigned int ix = 0; ix < mipMapCount; ++ix )
                     {
                            glPixelStorei( GL_UNPACK_ROW_LENGTH, y );
                            glTexImage2D( GL_TEXTURE_2D, ix, image.internalFormat, x, y, 0, image.externalFormat, image.type, image.data );
                            GLCHECKERROR;
                            x = (x+1)>>1;
                            y = (y+1)>>1;
                            offset += size;
                            size = x * y * image.blockBytes;
                     }
                     glPixelStorei( GL_UNPACK_SWAP_BYTES, GL_FALSE );
                     GLCHECKERROR;
              }
              glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, mipMapCount-1 );
              GLCHECKERROR;
       }

       return texID;
}

bool ImageDDS::HasTransparency

(

)

const [virtual]

Get true if image has alpha channel - Image overload.

Implements VRUT::Image.

Definition at line 264 of file imagedds.cpp.

{
       return IsOk() && ( image.header.dwFlags & DDPF_ALPHAPIXELS );
}

int ImageDDS::GetWidth

(

)

const [virtual]

Get the widht of the image.

Implements VRUT::Image.

Definition at line 269 of file imagedds.cpp.

{
       return (IsOk()?image.header.dwWidth:0);
}

int ImageDDS::GetHeight

(

)

const [virtual]

Get the height of the image.

Implements VRUT::Image.

Definition at line 274 of file imagedds.cpp.

{
       return (IsOk()?image.header.dwHeight:0);
}

---

Member Data Documentation

struct VRUT::ImageDDS::DdsLoadInfo VRUT::ImageDDS::image [protected]

---

The documentation for this class was generated from the following files:

• /cygdrive/d/src/svn/vrut/trunk/core/src/imagedds.h
• /cygdrive/d/src/svn/vrut/trunk/core/src/imagedds.cpp