ddsfile.cpp

Go to the documentation of this file.

/*
**  Command & Conquer Generals Zero Hour(tm)
**  Copyright 2025 Electronic Arts Inc.
**
**  This program 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 3 of the License, or
**  (at your option) any later version.
**
**  This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
*/
 
// 08/06/02 KM Added cube map and volume texture support
#include "ddsfile.h"
#include "ffactory.h"
#include "bufffile.h"
#include "formconv.h"
#include "dx8wrapper.h"
#include "bitmaphandler.h"
#include "colorspace.h"
#include <string.h>
#include <ddraw.h>
 
#ifndef DDSCAPS2_CUBEMAP
#define DDSCAPS2_CUBEMAP 0x00000200L
#endif
 
#ifndef DDSCAPS2_VOLUME
#define DDSCAPS2_VOLUME 0x00200000L
#endif
// ----------------------------------------------------------------------------
 
DDSFileClass::DDSFileClass(const char* name,unsigned reduction_factor)
    :
    DDSMemory(NULL),
    Width(0),
    Height(0),
    Depth(0),
    FullWidth(0),
    FullHeight(0),
    FullDepth(0),
    LevelSizes(NULL),
    LevelOffsets(NULL),
    MipLevels(0),
    ReductionFactor(reduction_factor),
    Format(WW3D_FORMAT_UNKNOWN),
    Type(DDS_TEXTURE),
    DateTime(0),
    CubeFaceSize(0)
{
    strncpy(Name,name,sizeof(Name));
    // The name could be given in .tga or .dds format, so ensure we're opening .dds...
    int len=strlen(Name);
    Name[len-3]='d';
    Name[len-2]='d';
    Name[len-1]='s';
 
    file_auto_ptr file(_TheFileFactory,Name);   
    if (!file->Is_Available()) 
    {
        return;
    }
 
    int result=file->Open();
    if (!result)
    {
        WWASSERT("File would not open\n");
        return;
    }
 
    DateTime=file->Get_Date_Time();
    char header[4];
 
    unsigned read_bytes=file->Read(header,4);
    if (!read_bytes)
    {
        WWASSERT("File loading failed trying to read header\n");
        return;
    }
    // Now, we read DDSURFACEDESC2 defining the compressed data
    read_bytes=file->Read(&SurfaceDesc,sizeof(LegacyDDSURFACEDESC2));
    // Verify the structure size matches the read size
    if (read_bytes==0 || read_bytes!=SurfaceDesc.Size) 
    {
        StringClass tmp(0,true);
        tmp.Format("File %s loading failed.\nTried to read %d bytes, got %d. (SurfDesc.size=%d)\n",name,sizeof(LegacyDDSURFACEDESC2),read_bytes,SurfaceDesc.Size);
        WWASSERT_PRINT(0,tmp);
        return;
    }
 
    Format=D3DFormat_To_WW3DFormat((D3DFORMAT)SurfaceDesc.PixelFormat.FourCC);
    WWASSERT(
        Format==WW3D_FORMAT_DXT1 ||
        Format==WW3D_FORMAT_DXT2 ||
        Format==WW3D_FORMAT_DXT3 ||
        Format==WW3D_FORMAT_DXT4 ||
        Format==WW3D_FORMAT_DXT5);
 
    MipLevels=SurfaceDesc.MipMapCount;
    if (MipLevels==0) MipLevels=1;
 
    if (MipLevels>ReductionFactor) MipLevels-=ReductionFactor;
    else {
        MipLevels=1;
        ReductionFactor=ReductionFactor-MipLevels;
    }
 
    // Drop the two lowest miplevels!
    if (MipLevels>2) MipLevels-=2;
    else MipLevels=1;
 
    // check texture type, normal, cube or volume
    if (SurfaceDesc.Caps.Caps2&DDSCAPS2_CUBEMAP)
    {
        Type=DDS_CUBEMAP;
    }
    else if (SurfaceDesc.Caps.Caps2&DDSCAPS2_VOLUME)
    {
        Type=DDS_VOLUME;
    }
 
 
    FullWidth=SurfaceDesc.Width;
    FullHeight=SurfaceDesc.Height;
    FullDepth=SurfaceDesc.Depth;
    Width=SurfaceDesc.Width>>ReductionFactor;
    Height=SurfaceDesc.Height>>ReductionFactor;
    Depth=SurfaceDesc.Depth;
 
    unsigned level_size=Calculate_DXTC_Surface_Size
    (
        SurfaceDesc.Width,
        SurfaceDesc.Height,
        Format
    );
    unsigned level_offset=0;
 
    unsigned level_mip_dec=4;
    if (Type==DDS_VOLUME)
    {
        // add slices to level data size
        level_size*=SurfaceDesc.Depth;
        level_mip_dec=8;
    }
 
    LevelSizes=W3DNEWARRAY unsigned[MipLevels];
    LevelOffsets=W3DNEWARRAY unsigned[MipLevels];
    for (unsigned level=0;level<ReductionFactor;++level) 
    {
        if (level_size>16) 
        {   // If surface is bigger than one block (8 or 16 bytes)...
            level_size/=level_mip_dec;
        }
    }
    for (level=0;level<MipLevels;++level) 
    {
        LevelSizes[level]=level_size;
        LevelOffsets[level]=level_offset;
        level_offset+=level_size;
        if (level_size>16) 
        {   // If surface is bigger than one block (8 or 16 bytes)...
            level_size/=level_mip_dec;
        }
    }
 
    if (Type==DDS_CUBEMAP)
    {
        for (level=0; level<MipLevels;++level)
        {
            CubeFaceSize+=LevelSizes[level];
        }
 
        // this accounts for dropping 2 lowest mip levels
        if (MipLevels>2)
            CubeFaceSize+=16;
    }
    file->Close();
}
 
// ----------------------------------------------------------------------------
 
DDSFileClass::~DDSFileClass()
{
    delete[] DDSMemory;
    delete[] LevelSizes;
    delete[] LevelOffsets;
}
 
unsigned DDSFileClass::Get_Width(unsigned level) const
{
    WWASSERT(level<MipLevels); 
    unsigned width=Width>>level;
    if (width<4) width=4;
    return width;
}
 
unsigned DDSFileClass::Get_Height(unsigned level) const
{
    WWASSERT(level<MipLevels); 
    unsigned height=Height>>level;
    if (height<4) height=4;
    return height;
}
 
unsigned DDSFileClass::Get_Depth(unsigned level) const
{
    WWASSERT(level<MipLevels);
    unsigned depth=Depth>>level;
    if (depth<4) depth=4;
    return depth;
}
 
const unsigned char* DDSFileClass::Get_Memory_Pointer(unsigned level) const
{
    WWASSERT(level<MipLevels); 
    return DDSMemory+LevelOffsets[level];
}
 
unsigned DDSFileClass::Get_Level_Size(unsigned level) const
{
    WWASSERT(level<MipLevels); 
    return LevelSizes[level];
}
 
// For some reason DX-Tex tool doesn't fill the surface size field, so we need to calculate it...
unsigned DDSFileClass::Calculate_DXTC_Surface_Size
(
    unsigned width, 
    unsigned height, 
    WW3DFormat format
)
{
    unsigned level_size=(width/4)*(height/4);
    switch (format) 
    {
    case WW3D_FORMAT_DXT1:
        level_size*=8;
        break;
    case WW3D_FORMAT_DXT2:
    case WW3D_FORMAT_DXT3:
    case WW3D_FORMAT_DXT4:
    case WW3D_FORMAT_DXT5:
        level_size*=16;
        break;
    }
 
    return level_size;
}
 
// ----------------------------------------------------------------------------
 
bool DDSFileClass::Load()
{
    if (DDSMemory) return false;
    if (!LevelSizes || !LevelOffsets) return false;
 
    file_auto_ptr file(_TheFileFactory,Name);   
    if (!file->Is_Available()) 
    {
        return false;
    }
 
    file->Open();
    // Data size is file size minus the header and info block
    unsigned size=file->Size()-SurfaceDesc.Size-4;
 
    if (!size)
    {
        return false;
    }
 
    // Skip mip levels if reduction factor is not zero
    unsigned level_size=Calculate_DXTC_Surface_Size
    (
        SurfaceDesc.Width,
        SurfaceDesc.Height,
        Format
    );
 
    unsigned skipped_offset=0;
    for (unsigned i=0;i<ReductionFactor;++i) 
    {
        skipped_offset+=level_size;
        size-=level_size;
        if (level_size>16) 
        {   // If surface is bigger than one block (8 or 16 bytes)...
            level_size/=4;
        }
    }
 
    // Skip the header and info block and possible unused mip levels
    unsigned seek_size=file->Seek(SurfaceDesc.Size+4+skipped_offset);
    WWASSERT(seek_size==(SurfaceDesc.Size+4+skipped_offset));
 
    if (size && size<0x80000000) 
    {
        // Allocate memory for the data excluding the headers
        DDSMemory=MSGW3DNEWARRAY("DDSMemory") unsigned char[size];
        // Read data
        unsigned read_size=file->Read(DDSMemory,size);
        // Verify we got all the data
        WWASSERT(read_size==size);
    }
    file->Close();
    return true;
}
 
// ----------------------------------------------------------------------------
 
WWINLINE static unsigned RGB565_To_ARGB8888(unsigned short rgb)
{
    unsigned rgba=0;
    rgba|=unsigned(rgb&0x001f)<<3;
    rgba|=unsigned(rgb&0x07e0)<<5;
    rgba|=unsigned(rgb&0xf800)<<8;
    return rgba;
}
 
WWINLINE static unsigned short ARGB8888_To_RGB565(unsigned argb_)
{
    unsigned char* argb=(unsigned char*)&argb_;
    unsigned short rgb;
    rgb=((argb[2])&0xf8)<<8;
    rgb|=((argb[1])&0xfc)<<3;
    rgb|=((argb[0])&0xf8)>>3;
    return rgb;
}
 
 
// ----------------------------------------------------------------------------
//
// Copy mipmap level to D3D surface. The copying is performed using another
// Copy_Level_To_Surface function (see below).
//
// ----------------------------------------------------------------------------
 
void DDSFileClass::Copy_Level_To_Surface(unsigned level,IDirect3DSurface8* d3d_surface,const Vector3& hsv_shift)
{
    WWASSERT(d3d_surface);
    // Verify that the destination surface size matches the source surface size
    D3DSURFACE_DESC surface_desc;
    DX8_ErrorCode(d3d_surface->GetDesc(&surface_desc));
 
    // First lock the surface
    D3DLOCKED_RECT locked_rect;
    DX8_ErrorCode(d3d_surface->LockRect(&locked_rect,NULL,0));
 
    Copy_Level_To_Surface(
        level,
        D3DFormat_To_WW3DFormat(surface_desc.Format),
        surface_desc.Width,
        surface_desc.Height,
        reinterpret_cast<unsigned char*>(locked_rect.pBits),
        locked_rect.Pitch,
        hsv_shift);
 
    // Finally, unlock the surface
    DX8_ErrorCode(d3d_surface->UnlockRect());
}
 
// ----------------------------------------------------------------------------
//
// Copy one mipmap level of texture to a memory surface. Surface type conversion
// is performed if the destination is of different format. Scaling will be done
// one of these days as well. Conversions between different types of compressed
// surfaces are not performed and scaling of compressed surfaces is also not
// possible.
//
// ----------------------------------------------------------------------------
 
void DDSFileClass::Copy_Level_To_Surface
(
    unsigned level,
    WW3DFormat dest_format, 
    unsigned dest_width, 
    unsigned dest_height, 
    unsigned char* dest_surface, 
    unsigned dest_pitch,
    const Vector3& hsv_shift
)
{
    WWASSERT(DDSMemory);
    WWASSERT(dest_surface);
 
    if (!DDSMemory || !Get_Memory_Pointer(level))
    {
        WWASSERT_PRINT(DDSMemory,"Surface mip level pointer is missing\n");
        return;
    }
 
    // If the format and size is a match just copy the contents
    bool has_hsv_shift = hsv_shift[0]!=0.0f || hsv_shift[1]!=0.0f || hsv_shift[2]!=0.0f;
    if (dest_format==Format && dest_width==Get_Width(level) && dest_height==Get_Height(level)) {
        // If hue shift, we can't just copy...
        if (has_hsv_shift) {
            if (Format==WW3D_FORMAT_DXT1) {
                const unsigned* src_ptr=reinterpret_cast<const unsigned*>(Get_Memory_Pointer(level));
                unsigned* dest_ptr=reinterpret_cast<unsigned*>(dest_surface);
                for (unsigned y=0;y<dest_height;y+=4) {
                    for (unsigned x=0;x<dest_width;x+=4) {
                        unsigned cols=*src_ptr++;       // Bytes 1-4 of color block
                        unsigned col0=RGB565_To_ARGB8888(unsigned short(cols>>16));
                        unsigned col1=RGB565_To_ARGB8888(unsigned short(cols&0xffff));
                        Recolor(col0,hsv_shift);
                        Recolor(col1,hsv_shift);
                        col0=ARGB8888_To_RGB565(col0);
                        col1=ARGB8888_To_RGB565(col1);
                        cols=unsigned(col0)<<16|col1;
                        *dest_ptr++=cols;
 
                        *dest_ptr++=*src_ptr++;     // Bytes 5-8 of color block
                    }
                }
            }
            else if (Format==WW3D_FORMAT_DXT5) {
                const unsigned* src_ptr=reinterpret_cast<const unsigned*>(Get_Memory_Pointer(level));
                unsigned* dest_ptr=reinterpret_cast<unsigned*>(dest_surface);
                for (unsigned y=0;y<dest_height;y+=4) {
                    for (unsigned x=0;x<dest_width;x+=4) {
                        *dest_ptr++=*src_ptr++;     // Bytes 1-4 of alpha block
                        *dest_ptr++=*src_ptr++;     // Bytes 5-8 of alpha block
                        unsigned cols=*src_ptr++;       // Bytes 1-4 of color block
                        unsigned col0=RGB565_To_ARGB8888(unsigned short(cols>>16));
                        unsigned col1=RGB565_To_ARGB8888(unsigned short(cols&0xffff));
                        Recolor(col0,hsv_shift);
                        Recolor(col1,hsv_shift);
                        col0=ARGB8888_To_RGB565(col0);
                        col1=ARGB8888_To_RGB565(col1);
                        cols=unsigned(col0)<<16|col1;
                        *dest_ptr++=cols;
 
                        *dest_ptr++=*src_ptr++;     // Bytes 5-8 of color block
                    }
                }
            }
            else {
                WWASSERT(0);
            }
 
        }
        else {
            unsigned compressed_size=Get_Level_Size(level);
            memcpy(dest_surface,Get_Memory_Pointer(level),compressed_size);
        }
    }
    else {
        // If size matches, copy each pixel linearly with color space conversion
        if (dest_width==Get_Width(level) && dest_height==Get_Height(level)) {
            // An exception here - if the source format is DXT1 and the destination
            // is DXT2, just copy the contents and create an empty alpha channel.
            // This is needed on NVidia cards that have problems with DXT1 compression.
            if (Format==WW3D_FORMAT_DXT1 && dest_format==WW3D_FORMAT_DXT2) {
                // If hue shift, we can't just copy...
                if (has_hsv_shift) {
                    const unsigned* src_ptr=reinterpret_cast<const unsigned*>(Get_Memory_Pointer(level));
                    unsigned* dest_ptr=reinterpret_cast<unsigned*>(dest_surface);
                    for (unsigned y=0;y<dest_height;y+=4) {
                        for (unsigned x=0;x<dest_width;x+=4) {
                            *dest_ptr++=0xffffffff;     // Bytes 1-4 of alpha block
                            *dest_ptr++=0xffffffff;     // Bytes 5-8 of alpha block
//                          *dest_ptr++=*src_ptr++;     // Bytes 1-4 of color block
 
                            unsigned cols=*src_ptr++;   // Bytes 1-4 of color block
                            unsigned col0=RGB565_To_ARGB8888(unsigned short(cols>>16));
                            unsigned col1=RGB565_To_ARGB8888(unsigned short(cols&0xffff));
                            Recolor(col0,hsv_shift);
                            Recolor(col1,hsv_shift);
                            col0=ARGB8888_To_RGB565(col0);
                            col1=ARGB8888_To_RGB565(col1);
                            cols=unsigned(col0)<<16|col1;
                            *dest_ptr++=cols;
 
                            *dest_ptr++=*src_ptr++;     // Bytes 5-8 of color block
                        }
                    }
                }
                else {
                    const unsigned* src_ptr=reinterpret_cast<const unsigned*>(Get_Memory_Pointer(level));
                    unsigned* dest_ptr=reinterpret_cast<unsigned*>(dest_surface);
                    for (unsigned y=0;y<dest_height;y+=4) {
                        for (unsigned x=0;x<dest_width;x+=4) {
                            *dest_ptr++=0xffffffff;     // Bytes 1-4 of alpha block
                            *dest_ptr++=0xffffffff;     // Bytes 5-8 of alpha block
                            *dest_ptr++=*src_ptr++;     // Bytes 1-4 of color block
                            *dest_ptr++=*src_ptr++;     // Bytes 5-8 of color block
                        }
                    }
                }
            }
            else {
                unsigned dest_bpp=Get_Bytes_Per_Pixel(dest_format);
 
                // Copy 4x4 block at a time
                bool contains_alpha=false;
                for (unsigned y=0;y<dest_height;y+=4) {
                    unsigned char* dest_ptr=dest_surface;
                    dest_ptr+=y*dest_pitch;
                    for (unsigned x=0;x<dest_width;x+=4,dest_ptr+=dest_bpp*4) {
                        contains_alpha|=Get_4x4_Block(dest_ptr,dest_pitch,dest_format,level,x,y,hsv_shift);
                    }
                }
                if (Format==WW3D_FORMAT_DXT1 && contains_alpha) {
                    WWDEBUG_SAY(("Warning: DXT1 format should not contain alpha information - file %s\n",Name));
                }
            }
        }
    }
}
 
// cube map
const unsigned char* DDSFileClass::Get_CubeMap_Memory_Pointer
(
    unsigned int face,
    unsigned int level
) const
{
    return &DDSMemory[CubeFaceSize*face+LevelOffsets[level]];
}
 
 
void DDSFileClass::Copy_CubeMap_Level_To_Surface
(
    unsigned face,
    unsigned level,
    WW3DFormat dest_format,
    unsigned dest_width,
    unsigned dest_height,
    unsigned char* dest_surface,
    unsigned dest_pitch,
    const Vector3& hsv_shift
)
{
    WWASSERT(DDSMemory);
    WWASSERT(dest_surface);
 
    if (!DDSMemory || !Get_CubeMap_Memory_Pointer(face,level))
    {
        WWASSERT_PRINT(DDSMemory,"Surface mip level pointer is missing\n");
        return;
    }
 
    // If the format and size is a match just copy the contents
    bool has_hsv_shift = hsv_shift[0]!=0.0f || hsv_shift[1]!=0.0f || hsv_shift[2]!=0.0f;
    if (dest_format==Format && dest_width==Get_Width(level) && dest_height==Get_Height(level)) 
    {
        // If hue shift, we can't just copy...
        if (has_hsv_shift) 
        {
            if (Format==WW3D_FORMAT_DXT1) 
            {
                const unsigned* src_ptr=reinterpret_cast<const unsigned*>(Get_CubeMap_Memory_Pointer(face,level));
                unsigned* dest_ptr=reinterpret_cast<unsigned*>(dest_surface);
                for (unsigned y=0;y<dest_height;y+=4) 
                {
                    for (unsigned x=0;x<dest_width;x+=4) 
                    {
                        unsigned cols=*src_ptr++;       // Bytes 1-4 of color block
                        unsigned col0=RGB565_To_ARGB8888(unsigned short(cols>>16));
                        unsigned col1=RGB565_To_ARGB8888(unsigned short(cols&0xffff));
                        Recolor(col0,hsv_shift);
                        Recolor(col1,hsv_shift);
                        col0=ARGB8888_To_RGB565(col0);
                        col1=ARGB8888_To_RGB565(col1);
                        cols=unsigned(col0)<<16|col1;
                        *dest_ptr++=cols;
 
                        *dest_ptr++=*src_ptr++;     // Bytes 5-8 of color block
                    }
                }
            }
            else if (Format==WW3D_FORMAT_DXT5) 
            {
                const unsigned* src_ptr=reinterpret_cast<const unsigned*>(Get_CubeMap_Memory_Pointer(face,level));
                unsigned* dest_ptr=reinterpret_cast<unsigned*>(dest_surface);
                for (unsigned y=0;y<dest_height;y+=4) 
                {
                    for (unsigned x=0;x<dest_width;x+=4) 
                    {
                        *dest_ptr++=*src_ptr++;     // Bytes 1-4 of alpha block
                        *dest_ptr++=*src_ptr++;     // Bytes 5-8 of alpha block
                        unsigned cols=*src_ptr++;       // Bytes 1-4 of color block
                        unsigned col0=RGB565_To_ARGB8888(unsigned short(cols>>16));
                        unsigned col1=RGB565_To_ARGB8888(unsigned short(cols&0xffff));
                        Recolor(col0,hsv_shift);
                        Recolor(col1,hsv_shift);
                        col0=ARGB8888_To_RGB565(col0);
                        col1=ARGB8888_To_RGB565(col1);
                        cols=unsigned(col0)<<16|col1;
                        *dest_ptr++=cols;
 
                        *dest_ptr++=*src_ptr++;     // Bytes 5-8 of color block
                    }
                }
            }
            else 
            {
                WWASSERT(0);
            }
 
        }
        else
        {
            unsigned compressed_size=Get_Level_Size(level);
            memcpy(dest_surface,Get_CubeMap_Memory_Pointer(face,level),compressed_size);
        }
    }
    else 
    {
        // If size matches, copy each pixel linearly with color space conversion
        if (dest_width==Get_Width(level) && dest_height==Get_Height(level)) 
        {
            // An exception here - if the source format is DXT1 and the destination
            // is DXT2, just copy the contents and create an empty alpha channel.
            // This is needed on NVidia cards that have problems with DXT1 compression.
            if (Format==WW3D_FORMAT_DXT1 && dest_format==WW3D_FORMAT_DXT2) 
            {
                // If hue shift, we can't just copy...
                if (has_hsv_shift) 
                {
                    const unsigned* src_ptr=reinterpret_cast<const unsigned*>(Get_CubeMap_Memory_Pointer(face,level));
                    unsigned* dest_ptr=reinterpret_cast<unsigned*>(dest_surface);
                    for (unsigned y=0;y<dest_height;y+=4) 
                    {
                        for (unsigned x=0;x<dest_width;x+=4) 
                        {
                            *dest_ptr++=0xffffffff;     // Bytes 1-4 of alpha block
                            *dest_ptr++=0xffffffff;     // Bytes 5-8 of alpha block
//                          *dest_ptr++=*src_ptr++;     // Bytes 1-4 of color block
 
                            unsigned cols=*src_ptr++;   // Bytes 1-4 of color block
                            unsigned col0=RGB565_To_ARGB8888(unsigned short(cols>>16));
                            unsigned col1=RGB565_To_ARGB8888(unsigned short(cols&0xffff));
                            Recolor(col0,hsv_shift);
                            Recolor(col1,hsv_shift);
                            col0=ARGB8888_To_RGB565(col0);
                            col1=ARGB8888_To_RGB565(col1);
                            cols=unsigned(col0)<<16|col1;
                            *dest_ptr++=cols;
 
                            *dest_ptr++=*src_ptr++;     // Bytes 5-8 of color block
                        }
                    }
                }
                else 
                {
                    const unsigned* src_ptr=reinterpret_cast<const unsigned*>(Get_CubeMap_Memory_Pointer(face,level));
                    unsigned* dest_ptr=reinterpret_cast<unsigned*>(dest_surface);
                    for (unsigned y=0;y<dest_height;y+=4) 
                    {
                        for (unsigned x=0;x<dest_width;x+=4) 
                        {
                            *dest_ptr++=0xffffffff;     // Bytes 1-4 of alpha block
                            *dest_ptr++=0xffffffff;     // Bytes 5-8 of alpha block
                            *dest_ptr++=*src_ptr++;     // Bytes 1-4 of color block
                            *dest_ptr++=*src_ptr++;     // Bytes 5-8 of color block
                        }
                    }
                }
            }
            else 
            {
                unsigned dest_bpp=Get_Bytes_Per_Pixel(dest_format);
 
                // Copy 4x4 block at a time
                bool contains_alpha=false;
                for (unsigned y=0;y<dest_height;y+=4) 
                {
                    unsigned char* dest_ptr=dest_surface;
                    dest_ptr+=y*dest_pitch;
                    for (unsigned x=0;x<dest_width;x+=4,dest_ptr+=dest_bpp*4) 
                    {
                        contains_alpha|=Get_4x4_Block(dest_ptr,dest_pitch,dest_format,level,x,y,hsv_shift);
                    }
                }
                if (Format==WW3D_FORMAT_DXT1 && contains_alpha) 
                {
                    WWDEBUG_SAY(("Warning: DXT1 format should not contain alpha information - file %s\n",Name));
                }
            }
        }
    }
}
 
// volume texture copy
const unsigned char* DDSFileClass::Get_Volume_Memory_Pointer(unsigned int level)  const
{
    return NULL;//DDSMemory[
}
 
void DDSFileClass::Copy_Volume_Level_To_Surface
(
    unsigned level,
    unsigned depth,
    WW3DFormat dest_format,
    unsigned dest_width,
    unsigned dest_height,
    unsigned char* dest_surface,
    unsigned row_pitch,
    unsigned slice_pitch,
    const Vector3& hsv_shift
)
{
    WWASSERT(DDSMemory);
    WWASSERT(dest_surface);
 
    if (!DDSMemory || !Get_Volume_Memory_Pointer(level))
    {
        WWASSERT_PRINT(DDSMemory,"Surface mip level pointer is missing\n");
        return;
    }
 
    // get 'dest_surface'
 
 
    // If the format and size is a match just copy the contents
    bool has_hsv_shift = hsv_shift[0]!=0.0f || hsv_shift[1]!=0.0f || hsv_shift[2]!=0.0f;
    if (dest_format==Format && dest_width==Get_Width(level) && dest_height==Get_Height(level)) 
    {
        // If hue shift, we can't just copy...
        if (has_hsv_shift) 
        {
            if (Format==WW3D_FORMAT_DXT1) 
            {
                const unsigned* src_ptr=reinterpret_cast<const unsigned*>(Get_Volume_Memory_Pointer(level));
                unsigned* dest_ptr=reinterpret_cast<unsigned*>(dest_surface);
                for (unsigned y=0;y<dest_height;y+=4) 
                {
                    for (unsigned x=0;x<dest_width;x+=4) 
                    {
                        unsigned cols=*src_ptr++;       // Bytes 1-4 of color block
                        unsigned col0=RGB565_To_ARGB8888(unsigned short(cols>>16));
                        unsigned col1=RGB565_To_ARGB8888(unsigned short(cols&0xffff));
                        Recolor(col0,hsv_shift);
                        Recolor(col1,hsv_shift);
                        col0=ARGB8888_To_RGB565(col0);
                        col1=ARGB8888_To_RGB565(col1);
                        cols=unsigned(col0)<<16|col1;
                        *dest_ptr++=cols;
 
                        *dest_ptr++=*src_ptr++;     // Bytes 5-8 of color block
                    }
                }
            }
            else if (Format==WW3D_FORMAT_DXT5) 
            {
                const unsigned* src_ptr=reinterpret_cast<const unsigned*>(Get_Volume_Memory_Pointer(level));
                unsigned* dest_ptr=reinterpret_cast<unsigned*>(dest_surface);
                for (unsigned y=0;y<dest_height;y+=4) 
                {
                    for (unsigned x=0;x<dest_width;x+=4) 
                    {
                        *dest_ptr++=*src_ptr++;     // Bytes 1-4 of alpha block
                        *dest_ptr++=*src_ptr++;     // Bytes 5-8 of alpha block
                        unsigned cols=*src_ptr++;       // Bytes 1-4 of color block
                        unsigned col0=RGB565_To_ARGB8888(unsigned short(cols>>16));
                        unsigned col1=RGB565_To_ARGB8888(unsigned short(cols&0xffff));
                        Recolor(col0,hsv_shift);
                        Recolor(col1,hsv_shift);
                        col0=ARGB8888_To_RGB565(col0);
                        col1=ARGB8888_To_RGB565(col1);
                        cols=unsigned(col0)<<16|col1;
                        *dest_ptr++=cols;
 
                        *dest_ptr++=*src_ptr++;     // Bytes 5-8 of color block
                    }
                }
            }
            else 
            {
                WWASSERT(0);
            }
 
        }
        else 
        {
            unsigned compressed_size=Get_Level_Size(level);
            memcpy(dest_surface,Get_Volume_Memory_Pointer(level),compressed_size);
        }
    }
    else 
    {
        // If size matches, copy each pixel linearly with color space conversion
        if (dest_width==Get_Width(level) && dest_height==Get_Height(level)) 
        {
            // An exception here - if the source format is DXT1 and the destination
            // is DXT2, just copy the contents and create an empty alpha channel.
            // This is needed on NVidia cards that have problems with DXT1 compression.
            if (Format==WW3D_FORMAT_DXT1 && dest_format==WW3D_FORMAT_DXT2) 
            {
                // If hue shift, we can't just copy...
                if (has_hsv_shift) 
                {
                    const unsigned* src_ptr=reinterpret_cast<const unsigned*>(Get_Volume_Memory_Pointer(level));
                    unsigned* dest_ptr=reinterpret_cast<unsigned*>(dest_surface);
                    for (unsigned y=0;y<dest_height;y+=4) 
                    {
                        for (unsigned x=0;x<dest_width;x+=4) 
                        {
                            *dest_ptr++=0xffffffff;     // Bytes 1-4 of alpha block
                            *dest_ptr++=0xffffffff;     // Bytes 5-8 of alpha block
//                          *dest_ptr++=*src_ptr++;     // Bytes 1-4 of color block
 
                            unsigned cols=*src_ptr++;   // Bytes 1-4 of color block
                            unsigned col0=RGB565_To_ARGB8888(unsigned short(cols>>16));
                            unsigned col1=RGB565_To_ARGB8888(unsigned short(cols&0xffff));
                            Recolor(col0,hsv_shift);
                            Recolor(col1,hsv_shift);
                            col0=ARGB8888_To_RGB565(col0);
                            col1=ARGB8888_To_RGB565(col1);
                            cols=unsigned(col0)<<16|col1;
                            *dest_ptr++=cols;
 
                            *dest_ptr++=*src_ptr++;     // Bytes 5-8 of color block
                        }
                    }
                }
                else 
                {
                    const unsigned* src_ptr=reinterpret_cast<const unsigned*>(Get_Volume_Memory_Pointer(level));
                    unsigned* dest_ptr=reinterpret_cast<unsigned*>(dest_surface);
                    for (unsigned y=0;y<dest_height;y+=4) 
                    {
                        for (unsigned x=0;x<dest_width;x+=4) 
                        {
                            *dest_ptr++=0xffffffff;     // Bytes 1-4 of alpha block
                            *dest_ptr++=0xffffffff;     // Bytes 5-8 of alpha block
                            *dest_ptr++=*src_ptr++;     // Bytes 1-4 of color block
                            *dest_ptr++=*src_ptr++;     // Bytes 5-8 of color block
                        }
                    }
                }
            }
            else 
            {
                WWASSERT(0);
            /*  todo
                unsigned dest_bpp=Get_Bytes_Per_Pixel(dest_format);
 
                // Copy 4x4 block at a time
                bool contains_alpha=false;
                for (unsigned z=0;z<dest_depth;z++)
                {
                    for (unsigned y=0;y<dest_height;y+=4) 
                    {
                        unsigned char* dest_ptr=dest_surface;
                        row_ptr+=y*row_pitch;
                        for (unsigned x=0;x<dest_width;x+=4,dest_ptr+=dest_bpp*4) 
                        {
                            contains_alpha|=Get_4x4_Block(dest_ptr,dest_pitch,dest_format,level,x,y,hsv_shift);
                        }
                    }
                    if (Format==WW3D_FORMAT_DXT1 && contains_alpha) 
                    {
                        WWDEBUG_SAY(("Warning: DXT1 format should not contain alpha information - file %s\n",Name));
                    }
                }*/
            }
        }
    }
}
 
// ----------------------------------------------------------------------------
 
WWINLINE static unsigned Combine_Colors(unsigned col1, unsigned col2, unsigned rel)
{
    const unsigned R_B_MASK=0x00ff00ff;
    const unsigned G_MASK=0x0000ff00;
 
    unsigned rel2=255-rel;
 
    unsigned r_b_col1=col1&R_B_MASK;
    r_b_col1*=rel;
    unsigned r_b_col2=col2&R_B_MASK;
    r_b_col2*=rel2;
    r_b_col1+=r_b_col2;
    r_b_col1>>=8;
    r_b_col1&=R_B_MASK;
 
 
    unsigned g_col1=col1&G_MASK;
    g_col1*=rel;
    unsigned g_col2=col2&G_MASK;
    g_col2*=rel2;
    g_col1+=g_col2;
    g_col1>>=8;
    g_col1&=G_MASK;
 
    return r_b_col1|g_col1;
 
/*  float f=float(rel)/256.0f;
 
    unsigned new_col=0;
    new_col|=int(float(int(col1&0x00ff0000))*f+float(int(col2&0x00ff0000))*(1.0f-f))&0x00ff0000;
    new_col|=int(float(int(col1&0x0000ff00))*f+float(int(col2&0x0000ff00))*(1.0f-f))&0x0000ff00;
    new_col|=int(float(int(col1&0x000000ff))*f+float(int(col2&0x000000ff))*(1.0f-f))&0x000000ff;
    return new_col;
*/
}
 
// ----------------------------------------------------------------------------
//
// Note that this is NOT an efficient way of extracting pixels from compressed image - we should implement
// faster block-copy method for non-scaled copying.
//
// ----------------------------------------------------------------------------
 
unsigned DDSFileClass::Get_Pixel(unsigned level,unsigned x,unsigned y) const
{
    WWASSERT(level<MipLevels);
    WWASSERT(x<Get_Width(level));
    WWASSERT(y<Get_Height(level));
 
    switch (Format) {
    // Note that we don't currently really support alpha on DXT1 - all alpha textures should use DXT5.
    // The reason for this is that when converting from DXT1 to 16 bit uncompressed texture we want
    // to be able to use RGB565 format instead of ARGB4444. As the alpha is encoded in DXT1 per-block
    // basis there isn't really a way to tell if the surface has an alpha or not so either we use alpha
    // or we don't.
    case WW3D_FORMAT_DXT1:
        {
            const unsigned char* block_memory=Get_Memory_Pointer(level)+(x/4)*8+((y/4)*(Get_Width(level)/4))*8;
 
            unsigned col0=RGB565_To_ARGB8888(*(unsigned short*)&block_memory[0]);
            unsigned col1=RGB565_To_ARGB8888(*(unsigned short*)&block_memory[2]);
            unsigned char line=block_memory[4+(y%4)];
            line>>=(x%4)*2;
            line=(line&3);
            if (col0>col1) {
                switch (line) {
                case 0: return col0|0xff000000;
                case 1: return col1|0xff000000;
                case 2: return Combine_Colors(col1,col0,85)|0xff000000;
                case 3: return Combine_Colors(col0,col1,85)|0xff000000;
                }
            }
            else {
                switch (line) {
                case 0: return col0|0xff000000;
                case 1: return col1|0xff000000;
                case 2: return Combine_Colors(col1,col0,128)|0xff000000;
                case 3: return 0x00000000;
                }
            }
        }
        break;
    case WW3D_FORMAT_DXT2:
        return 0xffffffff;
    case WW3D_FORMAT_DXT3:
        return 0xffffffff;
    case WW3D_FORMAT_DXT4:
        return 0xffffffff;
    case WW3D_FORMAT_DXT5:
        {
            const unsigned char* alpha_block=Get_Memory_Pointer(level)+(x/4)*16+((y/4)*(Get_Width(level)/4))*16;
 
            unsigned alpha0=alpha_block[0];
            unsigned alpha1=alpha_block[1];
 
            unsigned bit_idx=((x%4)+4*(y%4))*3;
            unsigned byte_idx=bit_idx/8;
            bit_idx%=8;
            unsigned alpha_index=0;
            for (int i=0;i<3;++i) {
                WWASSERT(byte_idx<6);
                unsigned alpha_bit=(alpha_block[2+byte_idx]>>(bit_idx))&1;
                alpha_index|=alpha_bit<<(i);
                bit_idx++;
                if (bit_idx>=8) {
                    bit_idx=0;
                    byte_idx++;
                }
            }
            WWASSERT(alpha_index<8);
 
            // 8-alpha or 6-alpha block?    
            unsigned alpha_value=0;
            if (alpha0>alpha1) {    
                // 8-alpha block:  derive the other six alphas.    
                // Bit code 000 = alpha_0, 001 = alpha_1, others are interpolated.
                switch (alpha_index) {
                case 0: alpha_value=alpha0; break;
                case 1: alpha_value=alpha1; break;
                case 2: alpha_value=(6*alpha0+1*alpha1+3) / 7; break;    // bit code 010
                case 3: alpha_value=(5*alpha0+2*alpha1+3) / 7; break;    // bit code 011
                case 4: alpha_value=(4*alpha0+3*alpha1+3) / 7; break;    // bit code 100
                case 5: alpha_value=(3*alpha0+4*alpha1+3) / 7; break;    // bit code 101
                case 6: alpha_value=(2*alpha0+5*alpha1+3) / 7; break;    // bit code 110
                case 7: alpha_value=(1*alpha0+6*alpha1+3) / 7; break;    // bit code 111  
                }
            }    
            else {  
                // 6-alpha block.    
                // Bit code 000 = alpha_0, 001 = alpha_1, others are interpolated.
                switch (alpha_index) {
                case 0: alpha_value=alpha0; break;
                case 1: alpha_value=alpha1; break;
                case 2: alpha_value=(4*alpha0+1*alpha1+2) / 5; break;    // Bit code 010
                case 3: alpha_value=(3*alpha0+2*alpha1+2) / 5; break;    // Bit code 011
                case 4: alpha_value=(2*alpha0+3*alpha1+2) / 5; break;    // Bit code 100
                case 5: alpha_value=(1*alpha0+4*alpha1+2) / 5; break;    // Bit code 101
                case 6: alpha_value=0; break;                            // Bit code 110
                case 7: alpha_value=255; break;                          // Bit code 111
                }
            }
            alpha_value<<=24;
 
            // Extract color
 
            const unsigned char* color_block=alpha_block+8;
            unsigned col0=RGB565_To_ARGB8888(*(unsigned short*)&color_block[0]);
            unsigned col1=RGB565_To_ARGB8888(*(unsigned short*)&color_block[2]);
            unsigned char line=color_block[4+(y%4)];
            line>>=(x%4)*2;
            line=(line&3);
            switch (line) {
            case 0: return col0|alpha_value;
            case 1: return col1|alpha_value;
            case 2: return Combine_Colors(col1,col0,85)|alpha_value;
            case 3: return Combine_Colors(col0,col1,85)|alpha_value;
            }
        }
        break;
    }
    return 0xffffffff;
}
 
// ----------------------------------------------------------------------------
//
// Uncompress one 4x4 block from the compressed image.
//
// Returns: true if block contained alpha, false is not
//
// Note: Destination can't be DXT or paletted surface!
//
// ----------------------------------------------------------------------------
 
bool DDSFileClass::Get_4x4_Block(
    unsigned char* dest_ptr,            // Destination surface pointer
    unsigned dest_pitch,                    // Destination surface pitch, in bytes
    WW3DFormat dest_format,               // Destination surface format, A8R8G8B8 is fastest
    unsigned level,                     // DDS mipmap level to copy from
    unsigned source_x,                  // DDS x offset to copy from, must be aligned by 4!
    unsigned source_y,                  // DDS y offset to copy from, must be aligned by 4!
    const Vector3& hsv_shift) const
{
    // Verify the block alignment
    WWASSERT((source_x&3)==0);
    WWASSERT((source_y&3)==0);
    // Verify level
    WWASSERT(level<MipLevels);
    // Verify coordinate bounds
    WWASSERT(source_x<Get_Width(level));
    WWASSERT(source_y<Get_Height(level));
 
    unsigned dest_bpp=Get_Bytes_Per_Pixel(dest_format);
 
    bool has_hsv_shift = hsv_shift[0]!=0.0f || hsv_shift[1]!=0.0f || hsv_shift[2]!=0.0f;
    switch (Format) {
    // Note that we don't currently really support alpha on DXT1 - all alpha textures should use DXT5.
    // The reason for this is that when converting from DXT1 to 16 bit uncompressed texture we want
    // to be able to use RGB565 format instead of ARGB4444. As the alpha is encoded in DXT1 per-block
    // basis there isn't really a way to tell if the surface has an alpha or not so either we use alpha
    // or we don't.
    case WW3D_FORMAT_DXT1:
        {
            const unsigned char* block_memory=Get_Memory_Pointer(level)+(source_x/4)*8+((source_y/4)*(Get_Width(level)/4))*8;
 
            unsigned col0=RGB565_To_ARGB8888(*(unsigned short*)&block_memory[0]);
            unsigned col1=RGB565_To_ARGB8888(*(unsigned short*)&block_memory[2]);
            // Even if we don't support alpha, decompression is different if source has alpha
            unsigned dest_pixel=0;
            if (col0>col1) {
                if (has_hsv_shift) {
                    Recolor(col0,hsv_shift);
                    Recolor(col1,hsv_shift);
                }
 
                for (int y=0;y<4;++y) {
                    unsigned char* tmp_dest_ptr=dest_ptr;
                    dest_ptr+=dest_pitch;
                    unsigned char line=block_memory[4+y];
                    for (int x=0;x<4;++x) {
                        switch (line&3) {
                        case 0: dest_pixel=col0|0xff000000; break;
                        case 1: dest_pixel=col1|0xff000000; break;
                        case 2: dest_pixel=Combine_Colors(col1,col0,85)|0xff000000; break;
                        case 3: dest_pixel=Combine_Colors(col0,col1,85)|0xff000000; break;
                        }
                        line>>=2;
 
                        BitmapHandlerClass::Write_B8G8R8A8(tmp_dest_ptr,dest_format,dest_pixel);
                        tmp_dest_ptr+=dest_bpp;
                    }
                }
                return false;   // No alpha found in the block
            }
            else {
                if (has_hsv_shift) {
                    Recolor(col0,hsv_shift);
                    Recolor(col1,hsv_shift);
                }
                bool contains_alpha=false;
                for (int y=0;y<4;++y) {
                    unsigned char* tmp_dest_ptr=dest_ptr;
                    dest_ptr+=dest_pitch;
                    unsigned char line=block_memory[4+y];
                    for (int x=0;x<4;++x) {
                        switch (line&3) {
                        case 0: dest_pixel=col0|0xff000000; break;
                        case 1: dest_pixel=col1|0xff000000; break;
                        case 2: dest_pixel=Combine_Colors(col1,col0,128)|0xff000000; break;
                        case 3: dest_pixel=0x00000000; contains_alpha=true; break;
                        }
                        line>>=2;
 
                        BitmapHandlerClass::Write_B8G8R8A8(tmp_dest_ptr,dest_format,dest_pixel);
                        tmp_dest_ptr+=dest_bpp;
                    }
                }
                return contains_alpha;  // Alpha block...?
            }
        }
        break;
    case WW3D_FORMAT_DXT2:
        return false;
    case WW3D_FORMAT_DXT3:
        return false;
    case WW3D_FORMAT_DXT4:
        return false;
    case WW3D_FORMAT_DXT5:
        {
            // Init alphas
            const unsigned char* alpha_block=Get_Memory_Pointer(level)+(source_x/4)*16+((source_y/4)*(Get_Width(level)/4))*16;
 
            unsigned alphas[8];
            alphas[0]=alpha_block[0];
            alphas[1]=alpha_block[1];
 
            // 8-alpha or 6-alpha block?    
            if (alphas[0]>alphas[1]) {    
                alphas[2]=(6*alphas[0]+1*alphas[1]+3) / 7;   // bit code 010
                alphas[3]=(5*alphas[0]+2*alphas[1]+3) / 7;   // bit code 011
                alphas[4]=(4*alphas[0]+3*alphas[1]+3) / 7;   // bit code 100
                alphas[5]=(3*alphas[0]+4*alphas[1]+3) / 7;   // bit code 101
                alphas[6]=(2*alphas[0]+5*alphas[1]+3) / 7;   // bit code 110
                alphas[7]=(1*alphas[0]+6*alphas[1]+3) / 7;   // bit code 111  
            }
            else {
                alphas[2]=(4*alphas[0]+1*alphas[1]+2) / 5;   // Bit code 010
                alphas[3]=(3*alphas[0]+2*alphas[1]+2) / 5;   // Bit code 011
                alphas[4]=(2*alphas[0]+3*alphas[1]+2) / 5;   // Bit code 100
                alphas[5]=(1*alphas[0]+4*alphas[1]+2) / 5;   // Bit code 101
                alphas[6]=0;                                           // Bit code 110
                alphas[7]=255;                                     // Bit code 111
            }
 
            // Init colors
            const unsigned char* color_block=alpha_block+8;
            unsigned col0=RGB565_To_ARGB8888(*(unsigned short*)&color_block[0]);
            unsigned col1=RGB565_To_ARGB8888(*(unsigned short*)&color_block[2]);
            if (has_hsv_shift) {
                Recolor(col0,hsv_shift);
                Recolor(col1,hsv_shift);
            }
 
            unsigned dest_pixel=0;
            unsigned bit_idx=0;
            unsigned contains_alpha=0xff;
 
            unsigned alpha_indices[16];
            unsigned* ai_ptr=alpha_indices;
            for (int a=0;a<2;++a) {
                ai_ptr[0]=alpha_block[2]&0x7;
                ai_ptr[1]=(alpha_block[2]>>3)&0x7;
                ai_ptr[2]=(alpha_block[2]>>6)|((alpha_block[3]&1)<<2);
                ai_ptr[3]=(alpha_block[3]>>1)&0x7;
                ai_ptr[4]=(alpha_block[3]>>4)&0x7;
                ai_ptr[5]=(alpha_block[3]>>7)|((alpha_block[4]&3)<<1);
                ai_ptr[6]=(alpha_block[4]>>2)&0x7;
                ai_ptr[7]=(alpha_block[4]>>5);
                ai_ptr+=8;
                alpha_block+=3;
            }
 
            unsigned aii=0;
            for (int y=0;y<4;++y) {
                unsigned char* tmp_dest_ptr=dest_ptr;
                dest_ptr+=dest_pitch;
                unsigned char line=color_block[4+y];
                for (int x=0;x<4;++x,bit_idx+=3) {
                    unsigned alpha_value=alphas[alpha_indices[aii++]];
                    contains_alpha&=alpha_value;
                    alpha_value<<=24;
 
                    // Extract color
 
                    switch (line&3) {
                    case 0: dest_pixel=col0|alpha_value; break;
                    case 1: dest_pixel=col1|alpha_value; break;
                    case 2: dest_pixel=Combine_Colors(col1,col0,85)|alpha_value; break;
                    case 3: dest_pixel=Combine_Colors(col0,col1,85)|alpha_value; break;
                    }
                    line>>=2;
 
                    BitmapHandlerClass::Write_B8G8R8A8(tmp_dest_ptr,dest_format,dest_pixel);
                    tmp_dest_ptr+=dest_bpp;
                }
            }
 
 
 
 
/*
            for (int y=0;y<4;++y) {
                unsigned char* tmp_dest_ptr=dest_ptr;
                dest_ptr+=dest_pitch;
                unsigned char line=color_block[4+y];
                for (int x=0;x<4;++x,bit_idx+=3) {
                    unsigned byte_idx=bit_idx/8;
                    unsigned tmp_bit_idx=bit_idx&7;
                    unsigned alpha_index=0;
                    for (int i=0;i<3;++i) {
                        WWASSERT(byte_idx<6);
                        unsigned alpha_bit=(alpha_block[2+byte_idx]>>(tmp_bit_idx))&1;
                        alpha_index|=alpha_bit<<(i);
                        tmp_bit_idx++;
                        if (tmp_bit_idx>=8) {
                            tmp_bit_idx=0;
                            byte_idx++;
                        }
                    }
                    WWASSERT(alpha_index<8);
                    unsigned alpha_value=alphas[alpha_index];
                    contains_alpha&=alpha_value;
                    alpha_value<<=24;
 
                    // Extract color
 
                    switch (line&3) {
                    case 0: dest_pixel=col0|alpha_value; break;
                    case 1: dest_pixel=col1|alpha_value; break;
                    case 2: dest_pixel=Combine_Colors(col1,col0,85)|alpha_value; break;
                    case 3: dest_pixel=Combine_Colors(col0,col1,85)|alpha_value; break;
                    }
                    line>>=2;
 
                    BitmapHandlerClass::Write_B8G8R8A8(tmp_dest_ptr,dest_format,dest_pixel);
                    tmp_dest_ptr+=dest_bpp;
                }
            }
*/
            return contains_alpha!=0xff;    // Alpha block... DXT5 should only be used when the image needs alpha
                                                    // but for now check anyway...
        }
    }
    return false;
 
}