summaryrefslogtreecommitdiff
path: root/3dc/win95/D3_IMAGE.CPP
diff options
context:
space:
mode:
Diffstat (limited to '3dc/win95/D3_IMAGE.CPP')
-rw-r--r--3dc/win95/D3_IMAGE.CPP2491
1 files changed, 2491 insertions, 0 deletions
diff --git a/3dc/win95/D3_IMAGE.CPP b/3dc/win95/D3_IMAGE.CPP
new file mode 100644
index 0000000..c068b82
--- /dev/null
+++ b/3dc/win95/D3_IMAGE.CPP
@@ -0,0 +1,2491 @@
+#include <stdlib.h>
+#include <string.h>
+
+#include "d3_image.hpp"
+#include "platform.h"
+
+// define = 1 if you dont have pre-quantized images to load into palettized D3D texture surfaces
+#define QUANTISE_ON_LOAD 0
+
+#if debug
+#define DEBUG_TRANSPARENCY 1
+#else
+#define DEBUG_TRANSPARENCY 0
+#endif
+
+// image loader stuff
+
+#if OUTPUT_LOG
+#include "debuglog.hpp"
+LogFile CL_LogFile("DB_IMLD.LOG");
+#endif
+
+#if TIME_LOADS
+unsigned int OpenTime;
+unsigned int CloseTime;
+unsigned int ReadTime;
+#endif
+
+static inline unsigned long read_le_dword(D3I_FILE * f)
+{
+ unsigned char d1,d2,d3,d4;
+ d3i_fread(&d1,1,1,f);
+ d3i_fread(&d2,1,1,f);
+ d3i_fread(&d3,1,1,f);
+ d3i_fread(&d4,1,1,f);
+
+ return (unsigned long)d1 | (unsigned long)d2<<8 | (unsigned long)d3<<16 | (unsigned long)d4<<24;
+}
+
+static inline unsigned short read_le_word(D3I_FILE * f)
+{
+ unsigned char d1,d2;
+ d3i_fread(&d1,1,1,f);
+ d3i_fread(&d2,1,1,f);
+
+ return (unsigned short)d1 | (unsigned short)((unsigned short)d2<<8);
+}
+
+// some default globals
+CL_ImageMode CL_Image::imode = CLM_GLOBALPALETTE;
+CL_ImageMode CL_Image::imode_d3d = CLM_ATTACHEDPALETTE;
+CL_ImageMode CL_Image::imode_ddraw = CLM_GLOBALPALETTE;
+LPDDSURFACEDESC CL_Image::format = 0;
+unsigned int CL_Image::bitsperpixel;
+unsigned int CL_Image::bitsperpixel_d3d;
+unsigned int CL_Image::bitsperpixel_ddraw;
+CL_LoadMode CL_Image::lmode = CLL_DDSURFACE;
+
+CL_DX_Format CL_Pixel_32::f;
+CL_DX_Format CL_Pixel_32::f_d3d;
+CL_DX_Format CL_Pixel_32::f_ddraw;
+CL_DX_Format CL_Pixel_16::f;
+CL_DX_Format CL_Pixel_16::f_d3d;
+CL_DX_Format CL_Pixel_16::f_ddraw;
+
+
+void CL_Image::DeleteNotMips(void)
+{
+ if (im24)
+ {
+ delete[] *im24;
+ delete[] im24;
+ im24 = 0;
+ }
+ if (im16)
+ {
+ delete[] *im16;
+ delete[] im16;
+ im16 = 0;
+ }
+ if (im8)
+ {
+ delete[] *im8;
+ delete[] im8;
+ im8 = 0;
+ }
+ if (palette)
+ {
+ delete[] palette;
+ palette = 0;
+ palette_size = 0;
+ }
+ flags.loaded = 0;
+ flags.raw16bit = 0;
+}
+
+void CL_Image::Delete(void)
+{
+ DeleteNotMips();
+ while (mipmaps.size())
+ {
+ delete mipmaps.last_entry();
+ mipmaps.delete_last_entry();
+ }
+}
+
+
+void CL_Image::Copy(CL_Image const & i2)
+{
+ if (i2.im24)
+ {
+ im24 = new CL_Pixel_24 * [height];
+ *im24 = new CL_Pixel_24 [size];
+
+ CL_Pixel_24 const * sptr = *i2.im24;
+ CL_Pixel_24 * dptr = *im24;
+
+ for (int i=size; i; --i)
+ {
+ *dptr++ = *sptr++;
+ }
+
+ CL_Pixel_24 const * * dptrptr = (CL_Pixel_24 const * *) im24;
+ CL_Pixel_24 const * aptr = *im24;
+ for (i=height; i; --i, aptr+=width)
+ {
+ *dptrptr++ = aptr;
+ }
+ }
+
+ if (i2.im16)
+ {
+ im16 = new CL_Pixel_16 * [height];
+ *im16 = new CL_Pixel_16 [size];
+
+ CL_Pixel_16 const * sptr = *i2.im16;
+ CL_Pixel_16 * dptr = *im16;
+
+ for (int i=size; i; --i)
+ {
+ *dptr++ = *sptr++;
+ }
+
+ CL_Pixel_16 const * * dptrptr = (CL_Pixel_16 const * *) im16;
+ CL_Pixel_16 const * aptr = *im16;
+ for (i=height; i; --i, aptr+=width)
+ {
+ *dptrptr++ = aptr;
+ }
+ }
+
+ if (i2.im8)
+ {
+ im8 = new unsigned char * [height];
+ *im8 = new unsigned char [size];
+
+ unsigned char const * sptr = *i2.im8;
+ unsigned char * dptr = *im8;
+
+ for (int i=size; i; --i)
+ {
+ *dptr++ = *sptr++;
+ }
+
+ unsigned char const * * dptrptr = (unsigned char const * *) im8;
+ unsigned char const * aptr = *im8;
+ for (i=height; i; --i, aptr+=width)
+ {
+ *dptrptr++ = aptr;
+ }
+ }
+
+ if (i2.palette)
+ {
+ palette = new CL_Pixel_24 [palette_size];
+
+ CL_Pixel_24 const * sptr = i2.palette;
+ CL_Pixel_24 * dptr = palette;
+
+ for (int i=palette_size; i; --i)
+ {
+ *dptr++ = *sptr;
+ }
+ }
+
+ if (i2.name)
+ {
+ name = new char [strlen(i2.name)+1];
+ strcpy(name,i2.name);
+ }
+
+ if (i2.fname)
+ {
+ fname = new char [strlen(i2.fname)+1];
+ strcpy(fname,i2.fname);
+ }
+
+ for (CLIF<CL_Image *> i_mip(&i2.mipmaps); !i_mip.done(); i_mip.next())
+ {
+ mipmaps.add_entry_end(new CL_Image(*i_mip()));
+ }
+}
+
+
+CL_Image::~CL_Image()
+{
+ Delete();
+ if (fname) delete[] fname;
+ if (name) delete[] name;
+}
+
+
+CL_Image::CL_Image(CL_Image const & i2)
+: width(i2.width)
+, height(i2.height)
+, size(i2.size)
+, im24(0)
+, im16(0)
+, im8(0)
+, palette(0)
+, palette_size(i2.palette_size)
+, fname(0)
+, name(0)
+, flags(i2.flags)
+{
+ Copy(i2);
+}
+
+
+CL_Image & CL_Image::operator = (CL_Image const & i2)
+{
+ if (&i2 != this)
+ {
+ Delete();
+ if (fname) delete[] fname;
+ if (name) delete[] name;
+
+ width = i2.width;
+ height = i2.height;
+ size = i2.size;
+ palette_size = i2.palette_size;
+
+ fname = 0;
+ name = 0;
+
+ flags = i2.flags;
+
+ Copy(i2);
+ }
+ return *this;
+}
+
+
+CL_Error CL_Image::Make(int const _width, int const _height)
+{
+ Delete();
+
+ width = _width;
+ height = _height;
+ palette_size = 0;
+ size = width*height;
+
+ switch (imode)
+ {
+ case CLM_ATTACHEDPALETTE:
+ {
+ palette_size = 256;
+ palette = new CL_Pixel_24 [palette_size];
+ }
+ case CLM_GLOBALPALETTE:
+ case CLM_TLTPALETTE:
+ {
+ im8 = new unsigned char * [height];
+ *im8 = new unsigned char [size];
+
+ unsigned char const * * dptrptr = (unsigned char const * *) im8;
+ unsigned char * dptr = *im8;
+ for (int i=height; i; --i, dptr+=width)
+ {
+ *dptrptr++ = dptr;
+ }
+
+ break;
+ }
+ case CLM_24BIT:
+ {
+ im24 = new CL_Pixel_24 * [height];
+ *im24 = new CL_Pixel_24 [size];
+
+ CL_Pixel_24 const * * dptrptr = (CL_Pixel_24 const * *) im24;
+ CL_Pixel_24 const * aptr = *im24;
+ for (int i=height; i; --i, aptr+=width)
+ {
+ *dptrptr++ = aptr;
+ }
+
+ break;
+ }
+ case CLM_16BIT:
+ {
+ im16 = new CL_Pixel_16 * [height];
+ *im16 = new CL_Pixel_16 [size];
+
+ CL_Pixel_16 const * * dptrptr = (CL_Pixel_16 const * *) im16;
+ CL_Pixel_16 const * aptr = *im16;
+ for (int i=height; i; --i, aptr+=width)
+ {
+ *dptrptr++ = aptr;
+ }
+
+ break;
+ }
+ case CLM_32BIT:
+ {
+ im32 = new CL_Pixel_32 * [height];
+ *im32 = new CL_Pixel_32 [size];
+
+ CL_Pixel_32 const * * dptrptr = (CL_Pixel_32 const * *) im32;
+ CL_Pixel_32 const * aptr = *im32;
+ for (int i=height; i; --i, aptr+=width)
+ {
+ *dptrptr++ = aptr;
+ }
+
+ break;
+ }
+ default:
+ return CLE_INVALIDDXMODE;
+ }
+
+ flags.loaded = 1;
+ return CLE_OK;
+}
+
+
+CL_Error CL_Image::MakeRandom(int const _width, int const _height, int const seed)
+{
+ Delete();
+
+ if (-1!=seed) srand((unsigned int)seed);
+
+ width = _width;
+ height = _height;
+ size = width*height;
+ palette_size = 0;
+
+ switch (imode)
+ {
+ case CLM_ATTACHEDPALETTE:
+ {
+ palette_size = 256;
+ palette = new CL_Pixel_24 [palette_size];
+ CL_Pixel_24 * palP = palette;
+ for (int i=palette_size; i; --i, ++palP)
+ {
+ *palP = CL_Pixel_24(rand()&255,rand()&255,rand()&255);
+ }
+ }
+ case CLM_GLOBALPALETTE:
+ case CLM_TLTPALETTE:
+ {
+ im8 = new unsigned char * [height];
+ *im8 = new unsigned char [size];
+
+ unsigned char const * * dptrptr = (unsigned char const * *) im8;
+ unsigned char * dptr = *im8;
+ for (int i=height; i; --i)
+ {
+ *dptrptr++ = dptr;
+ for (int j=width; j; --j, ++dptr)
+ *dptr = (unsigned char)(rand()&(palette_size-1));
+ }
+
+ break;
+ }
+ case CLM_24BIT:
+ {
+ im24 = new CL_Pixel_24 * [height];
+ *im24 = new CL_Pixel_24 [size];
+
+ CL_Pixel_24 const * * dptrptr = (CL_Pixel_24 const * *) im24;
+ CL_Pixel_24 * aptr = *im24;
+ for (int i=height; i; --i)
+ {
+ *dptrptr++ = aptr;
+ for (int j=width; j; --j, ++aptr)
+ *aptr = CL_Pixel_24(rand()&255,rand()&255,rand()&255);
+ }
+
+ break;
+ }
+ case CLM_16BIT:
+ {
+ im16 = new CL_Pixel_16 * [height];
+ *im16 = new CL_Pixel_16 [size];
+
+ CL_Pixel_16 const * * dptrptr = (CL_Pixel_16 const * *) im16;
+ CL_Pixel_16 * aptr = *im16;
+ for (int i=height; i; --i)
+ {
+ *dptrptr++ = aptr;
+ for (int j=width; j; --j, ++aptr)
+ *aptr = CL_Pixel_24(rand()&255,rand()&255,rand()&255);
+ }
+
+ break;
+ }
+ case CLM_32BIT:
+ {
+ im32 = new CL_Pixel_32 * [height];
+ *im32 = new CL_Pixel_32 [size];
+
+ CL_Pixel_32 const * * dptrptr = (CL_Pixel_32 const * *) im32;
+ CL_Pixel_32 * aptr = *im32;
+ for (int i=height; i; --i)
+ {
+ *dptrptr++ = aptr;
+ for (int j=width; j; --j, ++aptr)
+ *aptr = CL_Pixel_24(rand()&255,rand()&255,rand()&255);
+ }
+
+ break;
+ }
+ default:
+ return CLE_INVALIDDXMODE;
+ }
+
+ flags.loaded = 1;
+ return CLE_OK;
+}
+
+
+CL_Error CL_Image::Load_BMP(D3I_FILE * f)
+{
+ if (!f) return CLE_OPENERROR;
+
+ DeleteNotMips();
+
+ switch (imode)
+ {
+ case CLM_ATTACHEDPALETTE:
+ case CLM_24BIT:
+ case CLM_16BIT:
+ case CLM_32BIT:
+ break;
+ default:
+ return CLE_INVALIDDXMODE;
+ }
+
+ d3i_fseek(f,0,SEEK_SET);
+ unsigned short magic;
+ d3i_fread(&magic,2,1,f);
+ if (magic != *(unsigned short const *)"BM") return CLE_LOADERROR;
+
+ size_t filesize = read_le_dword(f);
+ d3i_fseek(f,4,SEEK_CUR);
+ size_t offset = read_le_dword(f);
+ size_t headsize = read_le_dword(f);
+
+ unsigned short bitdepth;
+
+ if (12 == headsize) // OS/2 1.x
+ {
+ width = read_le_word(f);
+ height = read_le_word(f);
+ size = width * height;
+ if (!width || !height) return CLE_LOADERROR;
+ unsigned short planes = read_le_word(f);
+ if (1 != planes) return CLE_LOADERROR;
+ bitdepth = read_le_word(f);
+
+ if (bitdepth != 24)
+ {
+ palette_size = 1<<bitdepth;
+ palette = new CL_Pixel_24 [palette_size];
+ CL_Pixel_24 * rptr = palette;
+ for (int i=palette_size; i; --i)
+ {
+ rptr++->Read(f,CLF_BGR);
+ }
+ }
+ }
+ else if (40 == headsize || 64 == headsize) // Windows 3.x || OS/2 2.x
+ {
+ width = read_le_dword(f);
+ height = read_le_dword(f);
+ unsigned short planes = read_le_word(f);
+ if (1 != planes) return CLE_LOADERROR;
+ bitdepth = read_le_word(f);
+
+ if (read_le_dword(f)) return CLE_LOADERROR; // compressed bmps not supported
+
+ size = read_le_dword(f);
+
+ d3i_fseek(f,8,SEEK_CUR);
+ palette_size = read_le_dword(f);
+ if (!palette_size && bitdepth != 24) palette_size = 1<<bitdepth;
+
+ if (palette_size)
+ {
+ d3i_fseek(f,headsize+14,SEEK_SET);
+ palette = new CL_Pixel_24 [palette_size];
+ CL_Pixel_24 * rptr = palette;
+ for (int i=palette_size; i; --i)
+ {
+ rptr++->Read(f,CLF_BGRX);
+ }
+ }
+ }
+ else return CLE_LOADERROR;
+
+ d3i_fseek(f,offset,SEEK_SET);
+
+ if (palette_size)
+ {
+ if (bitdepth < 4)
+ {
+ delete[] palette;
+ palette_size = 0;
+ return CLE_LOADERROR;
+ }
+
+ im8 = new unsigned char * [height];
+ *im8 = new unsigned char [size];
+
+ unsigned char const * * dptrptr = (unsigned char const * *) im8;
+ unsigned char * dptr = *im8;
+ for (int i=height; i; --i, dptr+=width)
+ {
+ *dptrptr++ = dptr;
+ }
+
+ #if DEBUG_TRANSPARENCY
+ int num_tps=0;
+ #endif
+ for (i=height-1; i>=0; --i)
+ {
+ dptr = im8[i];
+
+ if (4==bitdepth)
+ {
+ for (int i=width>>1; i; --i)
+ {
+ unsigned char byte;
+ d3i_fread(&byte,1,1,f);
+ #if DEBUG_TRANSPARENCY
+ *dptr = (unsigned char)(byte >> 4 & 0xf);
+ if (!*dptr) num_tps++;
+ *++dptr = (unsigned char)(byte & 0xf);
+ if (!*dptr) num_tps++;
+ ++dptr;
+ #else
+ *dptr++ = (unsigned char)(byte >> 4 & 0xf);
+ *dptr++ = (unsigned char)(byte & 0xf);
+ #endif
+ }
+ if (width & 1)
+ {
+ d3i_fread(dptr,1,1,f);
+ *dptr &= 0xf;
+ #if DEBUG_TRANSPARENCY
+ if (!*dptr) num_tps++;
+ #endif
+ }
+
+ d3i_fseek(f,(~(width-1) & 7)>>1,SEEK_CUR);
+ }
+ else
+ {
+ for (int i=width; i; --i)
+ {
+ #if DEBUG_TRANSPARENCY
+ d3i_fread(dptr,1,1,f);
+ if (!*dptr) num_tps++;
+ dptr++;
+ #else
+ d3i_fread(dptr++,1,1,f);
+ #endif
+ }
+ d3i_fseek(f,~(width-1) & 3,SEEK_CUR);
+ }
+ }
+ #if DEBUG_TRANSPARENCY
+ if (num_tps) CL_LogFile.lprintf("-- %d TRANSPARENT PIXELS FOUND\n",num_tps);
+ #endif
+ }
+ else if (CLM_16BIT == imode)
+ {
+ im16 = new CL_Pixel_16 * [height];
+ *im16 = new CL_Pixel_16 [size];
+
+ CL_Pixel_16 const * * dptrptr = (CL_Pixel_16 const * *) im16;
+ CL_Pixel_16 const * aptr = *im16;
+ for (int i=height; i; --i, aptr+=width)
+ {
+ *dptrptr++ = aptr;
+ }
+
+ for (i=height-1; i>=0; --i)
+ {
+ CL_Pixel_16 * dptr = im16[i];
+
+ for (int i=width; i; --i)
+ {
+ dptr++->Read(f,CLF_BGR);
+ }
+ d3i_fseek(f,~(width*3-1) & 3,SEEK_CUR);
+ }
+
+ }
+ else if (CLM_32BIT == imode)
+ {
+ im32 = new CL_Pixel_32 * [height];
+ *im32 = new CL_Pixel_32 [size];
+
+ CL_Pixel_32 const * * dptrptr = (CL_Pixel_32 const * *) im32;
+ CL_Pixel_32 const * aptr = *im32;
+ for (int i=height; i; --i, aptr+=width)
+ {
+ *dptrptr++ = aptr;
+ }
+
+ for (i=height-1; i>=0; --i)
+ {
+ CL_Pixel_32 * dptr = im32[i];
+
+ for (int i=width; i; --i)
+ {
+ dptr++->Read(f,CLF_BGR);
+ }
+ d3i_fseek(f,~(width*3-1) & 3,SEEK_CUR);
+ }
+
+ }
+ else if (CLM_24BIT == imode)
+ {
+ im24 = new CL_Pixel_24 * [height];
+ *im24 = new CL_Pixel_24 [size];
+
+ CL_Pixel_24 const * * dptrptr = (CL_Pixel_24 const * *) im24;
+ CL_Pixel_24 const * aptr = *im24;
+ for (int i=height; i; --i, aptr+=width)
+ {
+ *dptrptr++ = aptr;
+ }
+
+ for (i=height-1; i>=0; --i)
+ {
+ CL_Pixel_24 * dptr = im24[i];
+
+ for (int i=width; i; --i)
+ {
+ dptr++->Read(f,CLF_BGR);
+ }
+ d3i_fseek(f,~(width*3-1) & 3,SEEK_CUR);
+ }
+
+ }
+ else return CLE_INVALIDDXMODE;
+
+ if (palette_size && CLM_ATTACHEDPALETTE != imode)
+ {
+ if (CLM_16BIT == imode)
+ {
+ im16 = new CL_Pixel_16 * [height];
+ *im16 = new CL_Pixel_16 [size];
+
+ unsigned char const * sptr = *im8;
+ CL_Pixel_16 * dptr = *im16;
+
+ for (int i=size; i; --i, ++dptr,++sptr)
+ {
+ if (*sptr && !palette[*sptr])
+ *dptr = dptr->f.dx_black;
+ else
+ *dptr = palette[*sptr];
+ }
+
+ CL_Pixel_16 const * * dptrptr = (CL_Pixel_16 const * *) im16;
+ CL_Pixel_16 const * aptr = *im16;
+ for (i=height; i; --i, aptr+=width)
+ {
+ *dptrptr++ = aptr;
+ }
+ }
+ else if (CLM_32BIT == imode)
+ {
+ im32 = new CL_Pixel_32 * [height];
+ *im32 = new CL_Pixel_32 [size];
+
+ unsigned char const * sptr = *im8;
+ CL_Pixel_32 * dptr = *im32;
+
+ for (int i=size; i; --i, ++dptr,++sptr)
+ {
+ if (*sptr && !palette[*sptr])
+ *dptr = dptr->f.dx_black;
+ else
+ *dptr = palette[*sptr];
+ }
+
+ CL_Pixel_32 const * * dptrptr = (CL_Pixel_32 const * *) im32;
+ CL_Pixel_32 const * aptr = *im32;
+ for (i=height; i; --i, aptr+=width)
+ {
+ *dptrptr++ = aptr;
+ }
+ }
+ else
+ {
+ im24 = new CL_Pixel_24 * [height];
+ *im24 = new CL_Pixel_24 [size];
+
+ unsigned char const * sptr = *im8;
+ CL_Pixel_24 * dptr = *im24;
+
+ for (int i=size; i; --i, ++dptr,++sptr)
+ {
+ if (*sptr && !palette[*sptr])
+ *dptr = CL_Pixel_24(0,1,0);
+ else
+ *dptr = palette[*sptr];
+ }
+
+ CL_Pixel_24 const * * dptrptr = (CL_Pixel_24 const * *) im24;
+ CL_Pixel_24 const * aptr = *im24;
+ for (i=height; i; --i, aptr+=width)
+ {
+ *dptrptr++ = aptr;
+ }
+ }
+
+ delete[] palette;
+ palette = 0;
+ palette_size = 0;
+ delete[] *im8;
+ delete[] im8;
+ im8 = 0;
+ }
+
+ if (d3i_ferror(f) || d3i_feof(f))
+ {
+ DeleteNotMips();
+ return CLE_LOADERROR;
+ }
+
+ flags.loaded = 1;
+ return CLE_OK;
+}
+
+
+CL_Error CL_Image::Load_PPM(D3I_FILE * f)
+{
+ if (!f) return CLE_OPENERROR;
+
+ DeleteNotMips();
+
+ switch (imode)
+ {
+ case CLM_24BIT:
+ case CLM_16BIT:
+ case CLM_32BIT:
+ break;
+ default:
+ return CLE_INVALIDDXMODE;
+ }
+
+ d3i_fseek(f,0,SEEK_SET);
+ unsigned short magic;
+ d3i_fread(&magic,2,1,f);
+ if (magic != *(unsigned short const *)"P6") return CLE_LOADERROR;
+
+ d3i_fseek(f,1,SEEK_CUR);
+ char buf[256];
+ char * bufptr = buf;
+ unsigned int fields[5];
+ unsigned int fields_read = 0;
+ while (fields_read < 3 && bufptr)
+ {
+ do bufptr = d3i_fgets(buf, sizeof buf, f);
+ while ('#'==buf[0] && bufptr);
+
+ int num_fields_read = sscanf(buf,"%u %u %u",&fields[fields_read],&fields[fields_read+1],&fields[fields_read+2]);
+ if (EOF != num_fields_read) fields_read += num_fields_read;
+ }
+ if (fields_read < 3) return CLE_LOADERROR;
+ width = fields[0];
+ height = fields[1];
+ unsigned int maxval = fields[2];
+ if (maxval > 255) return CLE_LOADERROR;
+
+ size = width * height;
+
+ if (CLM_16BIT == imode)
+ {
+ im16 = new CL_Pixel_16 * [height];
+ *im16 = new CL_Pixel_16 [size];
+
+ CL_Pixel_16 * rptr = *im16;
+ for (int i=size; i; --i)
+ {
+ rptr++->Read(f,CLF_RGB,maxval);
+ }
+
+ CL_Pixel_16 const * * dptrptr = (CL_Pixel_16 const * *) im16;
+ CL_Pixel_16 const * aptr = *im16;
+ for (i=height; i; --i, aptr+=width)
+ {
+ *dptrptr++ = aptr;
+ }
+ }
+ else if (CLM_32BIT == imode)
+ {
+ im32 = new CL_Pixel_32 * [height];
+ *im32 = new CL_Pixel_32 [size];
+
+ CL_Pixel_32 * rptr = *im32;
+ for (int i=size; i; --i)
+ {
+ rptr++->Read(f,CLF_RGB,maxval);
+ }
+
+ CL_Pixel_32 const * * dptrptr = (CL_Pixel_32 const * *) im32;
+ CL_Pixel_32 const * aptr = *im32;
+ for (i=height; i; --i, aptr+=width)
+ {
+ *dptrptr++ = aptr;
+ }
+ }
+ else
+ {
+ im24 = new CL_Pixel_24 * [height];
+ *im24 = new CL_Pixel_24 [size];
+
+ CL_Pixel_24 * rptr = *im24;
+ for (int i=size; i; --i)
+ {
+ rptr++->Read(f,CLF_RGB,maxval);
+ }
+
+ CL_Pixel_24 const * * dptrptr = (CL_Pixel_24 const * *) im24;
+ CL_Pixel_24 const * aptr = *im24;
+ for (i=height; i; --i, aptr+=width)
+ {
+ *dptrptr++ = aptr;
+ }
+ }
+
+ if (d3i_ferror(f) || d3i_feof(f))
+ {
+ DeleteNotMips();
+ return CLE_LOADERROR;
+ }
+
+ flags.loaded = 1;
+ return CLE_OK;
+}
+
+
+CL_Error CL_Image::Load_PGM(D3I_FILE * f)
+{
+ if (!f) return CLE_OPENERROR;
+
+ DeleteNotMips();
+
+ switch (imode)
+ {
+ case CLM_GLOBALPALETTE:
+ case CLM_TLTPALETTE:
+ break;
+ default:
+ return CLE_INVALIDDXMODE;
+ }
+
+ d3i_fseek(f,0,SEEK_SET);
+ unsigned short magic;
+ d3i_fread(&magic,2,1,f);
+ if (magic != *(unsigned short const *)"P5") return CLE_LOADERROR;
+
+ d3i_fseek(f,1,SEEK_CUR);
+ char buf[256];
+ char * bufptr = buf;
+ unsigned int fields[5];
+ unsigned int fields_read = 0;
+ while (fields_read < 3 && bufptr)
+ {
+ do bufptr = d3i_fgets(buf, sizeof buf, f);
+ while ('#'==buf[0] && bufptr);
+
+ int num_fields_read = sscanf(buf,"%u %u %u",&fields[fields_read],&fields[fields_read+1],&fields[fields_read+2]);
+ if (EOF != num_fields_read) fields_read += num_fields_read;
+ }
+ if (fields_read < 3) return CLE_LOADERROR;
+ width = fields[0];
+ height = fields[1];
+ unsigned int maxval = fields[2];
+ if (maxval > 255) return CLE_LOADERROR;
+
+ size = width * height;
+
+ im8 = new unsigned char * [height];
+ *im8 = new unsigned char [size];
+
+ d3i_fread(*im8,1,size,f);
+
+ unsigned char const * * dptrptr = (unsigned char const * *) im8;
+ unsigned char const * aptr = *im8;
+ for (int i=height; i; --i, aptr+=width)
+ {
+ *dptrptr++ = aptr;
+ }
+
+ if (d3i_ferror(f) || d3i_feof(f))
+ {
+ DeleteNotMips();
+ return CLE_LOADERROR;
+ }
+
+ flags.loaded = 1;
+ return CLE_OK;
+}
+
+
+CL_Error CL_Image::Load_PWM(D3I_FILE * f)
+{
+ if (!f) return CLE_OPENERROR;
+
+ DeleteNotMips();
+
+ switch (imode)
+ {
+ case CLM_TLTPALETTE:
+ break;
+ default:
+ return CLE_INVALIDDXMODE;
+ }
+
+ d3i_fseek(f,0,SEEK_SET);
+ unsigned short magic;
+ d3i_fread(&magic,2,1,f);
+ if (magic != *(unsigned short const *)"P8") return CLE_LOADERROR;
+
+ d3i_fseek(f,1,SEEK_CUR);
+ char buf[256];
+ char * bufptr = buf;
+ unsigned int fields[5];
+ unsigned int fields_read = 0;
+ while (fields_read < 3 && bufptr)
+ {
+ do bufptr = d3i_fgets(buf, sizeof buf, f);
+ while ('#'==buf[0] && bufptr);
+
+ int num_fields_read = sscanf(buf,"%u %u %u",&fields[fields_read],&fields[fields_read+1],&fields[fields_read+2]);
+ if (EOF != num_fields_read) fields_read += num_fields_read;
+ }
+ if (fields_read < 3) return CLE_LOADERROR;
+ width = fields[0];
+ height = fields[1];
+ unsigned int maxval = fields[2];
+ if (maxval > 65535) return CLE_LOADERROR;
+
+ size = width * height;
+
+ im16raw = new unsigned short * [height];
+ *im16raw = new unsigned short [size];
+
+ d3i_fread(*im16raw,2,size,f);
+
+ unsigned short const * * dptrptr = (unsigned short const * *) im16raw;
+ unsigned short const * aptr = *im16raw;
+ for (int i=height; i; --i, aptr+=width)
+ {
+ *dptrptr++ = aptr;
+ }
+
+ if (d3i_ferror(f) || d3i_feof(f))
+ {
+ DeleteNotMips();
+ return CLE_LOADERROR;
+ }
+
+ flags.loaded = 1;
+ flags.raw16bit = 1;
+ return CLE_OK;
+}
+
+
+
+CL_Error CL_Image::GetBitsPerPixel(unsigned int* bpp)
+{
+ *bpp = bitsperpixel;
+ return CLE_OK;
+}
+
+CL_Error CL_Image::Load_Image(D3I_FILE * f)
+{
+ if (!f) return CLE_OPENERROR;
+
+ CL_Error retval = CLE_LOADERROR;
+
+ START_TIMER
+
+ d3i_fseek(f,0,SEEK_SET);
+ unsigned short magic;
+ d3i_fread(&magic,2,1,f);
+
+ if ( *(unsigned short const *)"BM" == magic)
+ retval = Load_BMP(f);
+ else if ( *(unsigned short const *)"P6" == magic)
+ retval = Load_PPM(f);
+ else if ( *(unsigned short const *)"P5" == magic)
+ retval = Load_PGM(f);
+ else if ( *(unsigned short const *)"P8" == magic)
+ retval = Load_PWM(f);
+ #if OUTPUT_LOG
+ else CL_LogFile.lputs("** ERROR: Not a recognized file format\n");
+ #endif
+
+ END_TIMER(ReadTime)
+
+ #if OUTPUT_LOG
+ #if TIME_LOADS
+ CL_LogFile.lprintf("-- Timer Stats (ms): Open %d Read %d Close %d\n",OpenTime,ReadTime,CloseTime);
+ #endif
+ #endif
+
+ return retval;
+}
+
+
+void CL_Image::PadTo(int const width_unit,int const height_unit)
+{
+ if (!flags.loaded) return;
+
+ unsigned int const owidth = width;
+ unsigned int const oheight = height;
+
+ width += width_unit-1;
+ width &= ~(width_unit-1);
+ height += height_unit-1;
+ height &= ~(height_unit-1);
+
+ if (width == owidth && height == oheight) return; // already in spec
+
+ size = width * height;
+
+ CL_Pixel_32 * * const oim32 = im32;
+ CL_Pixel_16 * * const oim16 = im16;
+ unsigned char * * const oim8 = im8;
+
+ if (oim32)
+ {
+ im32 = new CL_Pixel_32 * [height];
+ *im32 = new CL_Pixel_32 [size];
+
+ CL_Pixel_32 const * * dptrptr = (CL_Pixel_32 const * *) im32;
+ CL_Pixel_32 const * aptr = *im32;
+ for (unsigned int i=height; i; --i, aptr+=width)
+ {
+ *dptrptr++ = aptr;
+ }
+
+ for (unsigned int y = 0; y < oheight; ++y)
+ {
+ CL_Pixel_32 const * sptr = oim32[y];
+ CL_Pixel_32 * dptr = im32[y];
+
+ for (unsigned int x = 0; x < owidth; ++x, ++dptr, ++sptr)
+ *dptr = *sptr;
+
+ for (; x < width; ++x, ++dptr)
+ *dptr = CL_Pixel_24(0,0,0);
+ }
+
+ for (; y < height; ++y)
+ {
+ CL_Pixel_32 * dptr = im32[y];
+ for (unsigned int x = 0; x < width; ++x, ++dptr)
+ *dptr = CL_Pixel_24(0,0,0);
+ }
+
+ delete[] *oim32;
+ delete[] oim32;
+ }
+
+ if (oim16)
+ {
+ im16 = new CL_Pixel_16 * [height];
+ *im16 = new CL_Pixel_16 [size];
+
+ CL_Pixel_16 const * * dptrptr = (CL_Pixel_16 const * *) im16;
+ CL_Pixel_16 const * aptr = *im16;
+ for (unsigned int i=height; i; --i, aptr+=width)
+ {
+ *dptrptr++ = aptr;
+ }
+
+ for (unsigned int y = 0; y < oheight; ++y)
+ {
+ CL_Pixel_16 const * sptr = oim16[y];
+ CL_Pixel_16 * dptr = im16[y];
+
+ for (unsigned int x = 0; x < owidth; ++x, ++dptr, ++sptr)
+ *dptr = *sptr;
+
+ for (; x < width; ++x, ++dptr)
+ *dptr = CL_Pixel_24(0,0,0);
+ }
+
+ for (; y < height; ++y)
+ {
+ CL_Pixel_16 * dptr = im16[y];
+ for (unsigned int x = 0; x < width; ++x, ++dptr)
+ *dptr = CL_Pixel_24(0,0,0);
+ }
+
+ delete[] *oim16;
+ delete[] oim16;
+ }
+
+ if (oim8)
+ {
+ im8 = new unsigned char * [height];
+ *im8 = new unsigned char [size];
+
+ unsigned char const * * dptrptr = (unsigned char const * *) im8;
+ unsigned char const * aptr = *im8;
+ for (unsigned int i=height; i; --i, aptr+=width)
+ {
+ *dptrptr++ = aptr;
+ }
+
+ for (unsigned int y = 0; y < oheight; ++y)
+ {
+ unsigned char const * sptr = oim8[y];
+ unsigned char * dptr = im8[y];
+
+ for (unsigned int x = 0; x < owidth; ++x, ++dptr, ++sptr)
+ *dptr = *sptr;
+
+ for (; x < width; ++x, ++dptr)
+ *dptr = 0;
+ }
+
+ for (; y < height; ++y)
+ {
+ unsigned char * dptr = im8[y];
+ for (unsigned int x = 0; x < width; ++x, ++dptr)
+ *dptr = 0;
+ }
+
+ delete[] *oim8;
+ delete[] oim8;
+ }
+}
+
+// implementation of the 'popularity algorithm' for reducing palette
+
+unsigned int CL_Pixel_24::FVD_Distance(CL_Pixel_24 const & p2) const
+{
+ unsigned int dg = g > p2.g ? g - p2.g : p2.g - g;
+ unsigned int db = b > p2.b ? b - p2.b : p2.b - b;
+
+ unsigned int dgb = dg + db + ((dg > db ? dg : db)<<1);
+
+ unsigned int dr = r > p2.r ? r - p2.r : p2.r - r;
+ dr += dr<<1; // *= 3
+
+ return dr + dgb + ((dr > dgb ? dr : dgb)<<1);
+}
+
+struct _CL_palpixcnt
+{
+ unsigned int cnt;
+ unsigned int palpos;
+};
+
+int _CL_cmp_palpixcnt(void const * e1, void const * e2)
+{
+ return ((_CL_palpixcnt *)e2)->cnt - ((_CL_palpixcnt *)e1)->cnt;
+}
+
+CL_Error CL_Image::ReducePalette(unsigned int const num_colours)
+{
+ if (!flags.loaded) return CLE_LOADERROR;
+
+ if (!palette) return CLE_INVALIDDXMODE;
+ if (!im8) return CLE_INVALIDDXMODE;
+
+ if (palette_size <= num_colours) return CLE_OK;
+
+ _CL_palpixcnt * const sortarray = new _CL_palpixcnt[palette_size];
+
+ for (unsigned int i=0; i<palette_size; ++i)
+ {
+ sortarray[i].cnt = 0;
+ sortarray[i].palpos = i;
+ }
+
+ for (unsigned int y=0; y<height; ++y)
+ {
+ unsigned char const * sptr = im8[y];
+
+ for (unsigned int x=width; x; --x, ++sptr)
+ ++ sortarray[*sptr].cnt;
+ }
+
+ unsigned int const palstart = CL_Pixel_24(0,0,0) == palette[0] ? 1 : 0;
+ qsort(sortarray + palstart, palette_size - palstart, sizeof(_CL_palpixcnt), _CL_cmp_palpixcnt);
+
+ CL_Pixel_24 * const opalette = palette;
+ unsigned int const opalette_size = palette_size;
+ palette = new CL_Pixel_24[num_colours];
+ palette_size = num_colours;
+
+ for (i=0; i<palette_size; ++i)
+ palette[i] = opalette[sortarray[i].palpos];
+
+ delete[] sortarray;
+
+ // umm - if theres black thats not transparent, make sure it doesnt become colour 0 in palette
+ for (unsigned int pswap=1; pswap<palette_size && 0==palstart && CL_Pixel_24(0,0,0)==palette[0]; ++pswap)
+ {
+ palette[0]=palette[pswap];
+ palette[pswap]=CL_Pixel_24(0,0,0);
+ }
+
+ // emergency?
+ if (0==palstart && CL_Pixel_24(0,0,0)==palette[0])
+ palette[0] = CL_Pixel_24(1,1,1);
+
+ unsigned int * const palmaps = new unsigned int [opalette_size];
+ palmaps[0] = 0;
+ for (i=palstart; i<opalette_size; ++i)
+ {
+ unsigned int closest = palstart;
+ unsigned int distance = opalette[i].FVD_Distance(palette[palstart]);
+
+ for (unsigned int j = palstart+1; j<palette_size; ++j)
+ {
+ unsigned int thisdist = opalette[i].FVD_Distance(palette[j]);
+ if (thisdist < distance)
+ {
+ distance = thisdist;
+ closest = j;
+ }
+ }
+
+ palmaps[i] = closest;
+ }
+
+ delete[] opalette;
+
+ for (y=0; y<height; ++y)
+ {
+ unsigned char * sptr = im8[y];
+
+ for (unsigned int x=width; x; --x, ++sptr)
+ *sptr = (unsigned char)palmaps[*sptr];
+ }
+
+ delete[] palmaps;
+
+ return CLE_OK;
+}
+
+// useful filename handling functions
+
+// returns pointer into string pointing to filename without dirname
+static char const * strip_path(char const * n)
+{
+ char const * rm = strrchr(n,':');
+ if (rm) n = rm+1;
+ rm = strrchr(n,'/');
+ if (rm) n = rm+1;
+ rm = strrchr(n,'\\');
+ if (rm) n = rm+1;
+
+ return n;
+}
+
+#if 0
+static char * strip_path(char * n)
+{
+ char * rm = strrchr(n,':');
+ if (rm) n = rm+1;
+ rm = strrchr(n,'/');
+ if (rm) n = rm+1;
+ rm = strrchr(n,'\\');
+ if (rm) n = rm+1;
+
+ return n;
+}
+#endif
+
+// removes any .extension from filename by inserting null character
+static void strip_file_extension(char * n)
+{
+ char * dotpos = strrchr(n,'.');
+ if (dotpos) *dotpos = 0;
+}
+
+static char * strip_file_extension(char const * n)
+{
+ char * nn = new char[strlen(n)+1];
+ strcpy(nn,n);
+ strip_file_extension(nn);
+ return nn;
+}
+
+// CL_Image functions
+
+CL_Error CL_Image::Locate(char const * iname, int const /* enum_id */)
+{
+ if (!iname) return CLE_RIFFERROR;
+
+ if (name)
+ delete[] name;
+ name = strip_file_extension(strip_path(iname));
+
+ if (fname)
+ delete[] fname;
+ fname = new char[strlen(iname)+1];
+ strcpy(fname,iname);
+
+ flags.located = 1;
+ return CLE_OK;
+}
+
+CL_Error CL_Image::Load(char const * const iname, int const enum_id)
+{
+ if (iname || CL_EID_INVALID != enum_id || !flags.located)
+ {
+ CL_Error locate_err = Locate(iname,enum_id);
+
+ if (locate_err != CLE_OK)
+ {
+ EXITONLOCATEFAIL(locate_err,iname,enum_id)
+ return locate_err;
+ }
+ }
+
+ #if OUTPUT_LOG
+ char const * texformat;
+ unsigned int redbits = 8;
+ unsigned int greenbits = 8;
+ unsigned int bluebits = 8;
+ switch (imode)
+ {
+ case CLM_GLOBALPALETTE:
+ texformat = "Palettized Display";
+ break;
+ case CLM_TLTPALETTE:
+ texformat = "Palettized Display with Abstract TLT Palette";
+ break;
+ case CLM_ATTACHEDPALETTE:
+ texformat = "Palettized Textures";
+ break;
+ case CLM_32BIT:
+ texformat = "32BIT DX";
+ redbits += CL_Pixel_32::f.red_bits_gt8;
+ redbits -= CL_Pixel_32::f.red_bits_lt8;
+ greenbits += CL_Pixel_32::f.green_bits_gt8;
+ greenbits -= CL_Pixel_32::f.green_bits_lt8;
+ bluebits += CL_Pixel_32::f.blue_bits_gt8;
+ bluebits -= CL_Pixel_32::f.blue_bits_lt8;
+ break;
+ case CLM_24BIT:
+ texformat = "24-bit for runtime conversion";
+ break;
+ case CLM_16BIT:
+ texformat = "16BIT DX";
+ redbits += CL_Pixel_16::f.red_bits_gt8;
+ redbits -= CL_Pixel_16::f.red_bits_lt8;
+ greenbits += CL_Pixel_16::f.green_bits_gt8;
+ greenbits -= CL_Pixel_16::f.green_bits_lt8;
+ bluebits += CL_Pixel_16::f.blue_bits_gt8;
+ bluebits -= CL_Pixel_16::f.blue_bits_lt8;
+ break;
+ }
+ CL_LogFile.lprintf("--%s %s (%u-bit, %u-%u-%u)\n",fname,texformat,bitsperpixel,redbits,greenbits,bluebits);
+ #endif
+
+ START_TIMER
+ D3I_FILE * fp = d3i_fopen(fname,"rb");
+ END_TIMER(OpenTime)
+
+ if (fp)
+ {
+ CL_Error retval = Load_Image(fp);
+ START_TIMER
+ d3i_fclose(fp);
+ END_TIMER(CloseTime)
+ if (CLE_OK != retval)
+ {
+ #if OUTPUT_LOG
+ CL_LogFile.lputs("** ERROR: unable to read\n");
+ #endif
+ EXITONREADFAIL(fname)
+ }
+ return retval;
+ }
+
+ #if OUTPUT_LOG
+ CL_LogFile.lputs("** ERROR: unable to open\n");
+ #endif
+ EXITONLOADFAIL(fname)
+ return CLE_OPENERROR;
+}
+
+CL_Error CL_Image::PreLoad(char const * const iname, int const enum_id)
+{
+ CL_Error locate_err = Locate(iname,enum_id);
+
+ if (locate_err != CLE_OK)
+ {
+ return locate_err;
+ }
+
+ return CLE_OK;
+}
+
+CL_Error CL_Image::LoadMipMaps(int const n_mips) // assumes locating has been done (ie. PreLoad or Load has been called)
+{
+ if (!flags.located) return CLE_FINDERROR;
+
+ while (mipmaps.size())
+ {
+ delete mipmaps.last_entry();
+ mipmaps.delete_last_entry();
+ }
+
+ for (int mip_idx = 1; mip_idx < n_mips; ++mip_idx)
+ {
+ CL_Image * mip_n = new CL_Image;
+
+ mip_n->name = new char[strlen(name)+1];
+ mip_n->fname = new char[strlen(fname)+1];
+ strcpy(mip_n->name,name);
+ strcpy(mip_n->fname,fname);
+
+ char * dotpos = strrchr(mip_n->fname,'.');
+ if (!dotpos)
+ {
+ delete mip_n;
+ break;
+ }
+ sprintf(dotpos+3,"%1d",mip_idx);
+
+ mip_n->flags.located = 1;
+
+ if (CLE_OK!=mip_n->Load())
+ {
+ delete mip_n;
+ break;
+ }
+
+ if (mip_n->width << mip_idx < width || mip_n->height << mip_idx < height)
+ {
+ delete mip_n;
+ #if OUTPUT_LOG
+ CL_LogFile.lputs("** Warning: less than half size\n");
+ #endif
+ break;
+ }
+
+ mipmaps.add_entry_end(mip_n);
+ }
+ return CLE_OK;
+}
+
+void CL_Select_Mode(CL_LoadMode const lmode)
+{
+ switch (lmode)
+ {
+ case CLL_D3DTEXTURE:
+ CL_Image::imode = CL_Image::imode_d3d;
+ CL_Image::bitsperpixel = CL_Image::bitsperpixel_d3d;
+ CL_Pixel_16::f = CL_Pixel_16::f_d3d;
+ CL_Pixel_32::f = CL_Pixel_32::f_d3d;
+ break;
+ case CLL_DDSURFACE:
+ CL_Image::imode = CL_Image::imode_ddraw;
+ CL_Image::bitsperpixel = CL_Image::bitsperpixel_ddraw;
+ CL_Pixel_16::f = CL_Pixel_16::f_ddraw;
+ CL_Pixel_32::f = CL_Pixel_32::f_ddraw;
+ break;
+ }
+ CL_Image::lmode = lmode;
+}
+
+// 3DC interface
+
+void CL_Init_DirectDrawMode(CL_VideoMode const vmode)
+{
+ switch (vmode)
+ {
+ case CLV_8:
+ CL_Image::bitsperpixel_ddraw = 8;
+ CL_Image::imode_ddraw = CLM_GLOBALPALETTE;
+ break;
+ case CLV_8TLT:
+ CL_Image::bitsperpixel_ddraw = 8;
+ CL_Image::imode_ddraw = CLM_TLTPALETTE;
+ break;
+ case CLV_15:
+ CL_Image::bitsperpixel_ddraw = 16;
+ CL_Image::imode_ddraw = CLM_16BIT;
+ CL_Pixel_16::f_ddraw.Init
+ (
+ DisplayPixelFormat.dwRBitMask,
+ DisplayPixelFormat.dwGBitMask,
+ DisplayPixelFormat.dwBBitMask
+ );
+ break;
+ case CLV_24:
+ CL_Image::bitsperpixel_ddraw = DisplayPixelFormat.dwRGBBitCount;
+ if (24 == CL_Image::bitsperpixel_ddraw)
+ CL_Image::imode_ddraw = CLM_24BIT;
+ else
+ {
+ CL_Image::imode_ddraw = CLM_32BIT;
+ CL_Pixel_32::f_ddraw.Init
+ (
+ DisplayPixelFormat.dwRBitMask,
+ DisplayPixelFormat.dwGBitMask,
+ DisplayPixelFormat.dwBBitMask
+ );
+ }
+ break;
+ case CLV_8T:
+ CL_Image::bitsperpixel_ddraw = 8;
+ CL_Image::imode_ddraw = CLM_16BIT;
+ CL_Pixel_16::f_ddraw.Init(7<<5,7<<2,3);
+ break;
+ }
+ CL_Select_Mode(CLL_DDSURFACE);
+}
+
+
+CL_Error CL_Image::CopyToScanDrawTexture(unsigned char * * const ImagePtrA [], unsigned int n_mips_max)
+{
+ if (!flags.loaded) return CLE_LOADERROR;
+
+ if (CLL_DDSURFACE != lmode) CL_Select_Mode(CLL_DDSURFACE);
+
+ if (n_mips_max > mipmaps.size()+1) n_mips_max = mipmaps.size()+1;
+
+ if (!*ImagePtrA[0])
+ {
+ if (flags.raw16bit)
+ {
+ if (n_mips_max>1)
+ *ImagePtrA[0] = (unsigned char *) AllocateMem((2*width+1)*(2*height+1)*2/3+(n_mips_max-3)*2); // slightly more than 4/3 w*h*bytedepth
+ else
+ *ImagePtrA[0] = (unsigned char *) AllocateMem(width*height*2);
+ }
+ else
+ {
+ if (n_mips_max>1)
+ *ImagePtrA[0] = (unsigned char *) AllocateMem((2*width+1)*(2*height+1)*bitsperpixel/24+(n_mips_max-3)*(bitsperpixel/8)); // slightly more than 4/3 w*h*bytedepth
+ else
+ *ImagePtrA[0] = (unsigned char *) AllocateMem(width*height*(bitsperpixel>>3));
+ }
+ }
+ if (!*ImagePtrA[0])
+ return CLE_ALLOCFAIL;
+
+ unsigned int my_bitsperpixel = bitsperpixel;
+
+ switch (imode)
+ {
+ unsigned char * tptr;
+ unsigned short * tSptr;
+ unsigned long * tLptr;
+
+ case CLM_GLOBALPALETTE:
+ case CLM_TLTPALETTE:
+ if (flags.raw16bit)
+ {
+ my_bitsperpixel = 16;
+ tSptr = (unsigned short *)*ImagePtrA[0];
+ if (tSptr)
+ {
+ for (int i=0; i<height; ++i)
+ {
+ memcpy(tSptr,im16raw[i],width*sizeof(unsigned short));
+ tSptr += width;
+ }
+ }
+ }
+ else
+ {
+ tptr = *ImagePtrA[0];
+ if (tptr)
+ {
+ for (int i=0; i<height; ++i)
+ {
+ memcpy(tptr,im8[i],width);
+ tptr += width;
+ }
+ }
+ }
+ break;
+ case CLM_16BIT:
+ switch (bitsperpixel)
+ {
+ case 8:
+ tptr = *ImagePtrA[0];
+ if (tptr)
+ {
+ for (int i=0; i<height; ++i)
+ {
+ unsigned char const * i8ptr = im8[i];
+ for (int j=width; j; --j)
+ {
+ *tptr++ = *i8ptr++;
+ }
+ }
+ }
+ break;
+ case 16:
+ tSptr = (unsigned short *)*ImagePtrA[0];
+ if (tSptr)
+ {
+ for (int i=0; i<height; ++i)
+ {
+ CL_Pixel_16 const * i16ptr = im16[i];
+ for (int j=width; j; --j)
+ {
+ *tSptr++ = *i16ptr++;
+ }
+ }
+ }
+ break;
+ }
+ break;
+ case CLM_24BIT:
+ switch (bitsperpixel)
+ {
+ case 24:
+ tptr = *ImagePtrA[0];
+ if (tptr)
+ {
+ for (int i=0; i<height; ++i)
+ {
+ CL_Pixel_24 const * i24ptr = im24[i];
+ for (int j=width; j; --j)
+ {
+ *tptr++ = i24ptr->b;
+ *tptr++ = i24ptr->g;
+ *tptr++ = i24ptr->r;
+ i24ptr++;
+ }
+ }
+ }
+ break;
+ case 32:
+ tLptr = (unsigned long *)*ImagePtrA[0];
+ if (tLptr)
+ {
+ for (int i=0; i<height; ++i)
+ {
+ CL_Pixel_32 const * i32ptr = im32[i];
+ for (int j=width; j; --j)
+ {
+ *tLptr++ = *i32ptr++;
+ }
+ }
+ }
+ break;
+ }
+ break;
+ default:
+ return CLE_INVALIDDXMODE;
+ }
+
+ // now do mipmaps if avail
+
+ CL_Image * last_mipP = this;
+
+ LIF<CL_Image *> i_mip(&mipmaps);
+ for (int i=1; i<n_mips_max && !i_mip.done(); ++i, i_mip.next())
+ {
+ *ImagePtrA[i] = *ImagePtrA[i-1] + last_mipP->width*last_mipP->height*(my_bitsperpixel>>3);
+ CL_Error thismipmaperror = i_mip()->CopyToScanDrawTexture(&ImagePtrA[i],1);
+ if (CLE_OK != thismipmaperror) return thismipmaperror;
+ last_mipP = i_mip();
+ }
+ return CLE_OK;
+}
+
+
+
+// Direct X interface
+
+void CL_Init_D3DMode(LPDDSURFACEDESC const format)
+{
+ CL_Image::format = format;
+
+ if (format->ddpfPixelFormat.dwFlags & DDPF_PALETTEINDEXED8)
+ {
+ #if QUANTISE_ON_LOAD
+ CL_Image::imode_d3d = CLM_24BIT;
+ #else
+ CL_Image::imode_d3d = CLM_ATTACHEDPALETTE;
+ #endif
+ CL_Image::bitsperpixel_d3d = 8;
+ }
+ else if (format->ddpfPixelFormat.dwFlags & DDPF_PALETTEINDEXED4)
+ {
+ #if QUANTISE_ON_LOAD
+ CL_Image::imode_d3d = CLM_24BIT;
+ #else
+ CL_Image::imode_d3d = CLM_ATTACHEDPALETTE;
+ #endif
+ CL_Image::bitsperpixel_d3d = 4;
+ }
+ else if (format->ddpfPixelFormat.dwFlags & DDPF_PALETTEINDEXED2)
+ {
+ #if QUANTISE_ON_LOAD
+ CL_Image::imode_d3d = CLM_24BIT;
+ #else
+ CL_Image::imode_d3d = CLM_ATTACHEDPALETTE;
+ #endif
+ CL_Image::bitsperpixel_d3d = 2;
+ }
+ else if (format->ddpfPixelFormat.dwFlags & DDPF_PALETTEINDEXED1)
+ {
+ #if QUANTISE_ON_LOAD
+ CL_Image::imode_d3d = CLM_24BIT;
+ #else
+ CL_Image::imode_d3d = CLM_ATTACHEDPALETTE;
+ #endif
+ CL_Image::bitsperpixel_d3d = 1;
+ }
+ else
+ {
+ CL_Image::bitsperpixel_d3d = format->ddpfPixelFormat.dwRGBBitCount;
+ if (format->ddpfPixelFormat.dwRGBBitCount > 16)
+ {
+ CL_Image::imode_d3d = CLM_32BIT;
+ CL_Pixel_32::f_d3d.Init
+ (
+ format->ddpfPixelFormat.dwRBitMask,
+ format->ddpfPixelFormat.dwGBitMask,
+ format->ddpfPixelFormat.dwBBitMask
+ );
+ }
+ else
+ {
+ CL_Image::imode_d3d = CLM_16BIT;
+ CL_Pixel_16::f_d3d.Init
+ (
+ format->ddpfPixelFormat.dwRBitMask,
+ format->ddpfPixelFormat.dwGBitMask,
+ format->ddpfPixelFormat.dwBBitMask
+ );
+ }
+ }
+ CL_Select_Mode(CLL_D3DTEXTURE);
+}
+
+
+CL_Error CL_Image::CopyToD3DTexture(LPDIRECTDRAWSURFACE * const DDPtrA [], LPVOID * const DDSurfaceA [], int const MemoryType, unsigned int n_mips_max)
+{
+ if (!flags.loaded) return CLE_LOADERROR;
+
+ WaitForVRamReady(VWS_D3DTEXCREATE);
+
+ if (CLL_D3DTEXTURE != lmode) CL_Select_Mode(CLL_D3DTEXTURE);
+
+ LPDIRECTDRAWSURFACE lpDDS;
+ DDSURFACEDESC ddsd;
+ HRESULT ddrval;
+
+ // Check for image being 4 byte aligned
+ // and fail if it is not
+ if (width & 3 || height & 3)
+ {
+ // return error code
+ return CLE_DXERROR;
+ }
+
+
+ // Set up the surface description. starting
+ // with the passed texture format and then
+ // incorporating the information read from the
+ // ppm.
+ memcpy(&ddsd, format, sizeof(DDSURFACEDESC));
+ ddsd.dwSize = sizeof(DDSURFACEDESC);
+ ddsd.dwFlags = (DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT);
+ ddsd.ddsCaps.dwCaps = (DDSCAPS_TEXTURE | MemoryType);
+ ddsd.dwHeight = height;
+ ddsd.dwWidth = width;
+
+ if (n_mips_max > mipmaps.size()+1) n_mips_max = mipmaps.size()+1;
+
+ if (n_mips_max>1)
+ {
+ ddsd.dwFlags |= DDSD_MIPMAPCOUNT;
+ ddsd.ddsCaps.dwCaps |= DDSCAPS_MIPMAP | DDSCAPS_COMPLEX;
+ ddsd.dwMipMapCount = n_mips_max;
+ }
+
+ // Create the surface
+ ddrval = lpDD->CreateSurface(&ddsd, &lpDDS, NULL);
+
+ LOGDXERR(ddrval);
+ if (ddrval != DD_OK)
+ {
+ #if debug
+ ReleaseDirect3D();
+ exit(ddrval);
+ #else
+ lpDDS->Release();
+ return CLE_DXERROR;
+ #endif
+ }
+
+
+ // now do mipmaps if avail
+
+ if (n_mips_max>1)
+ {
+ // We must now traverse the mip-map chain from highest to lowest
+ // resolutions, For each surface AFTER the first one, we must
+ // load a new file, using a name obtained from the mip map number
+
+ int MipMapNum = 0;
+ LPDIRECTDRAWSURFACE lpThisMipMap, lpNextMipMap;
+ DDSCAPS ddsCaps;
+
+
+ lpThisMipMap = lpDDS;
+ // Component Object Model, increase reference count on
+ // mip-map surface by one.
+ lpThisMipMap->AddRef();
+ ddsCaps.dwCaps = (DDSCAPS_TEXTURE | DDSCAPS_MIPMAP);
+ ddrval = DD_OK;
+
+ LIF<CL_Image *> i_mip(&mipmaps);
+
+ CL_Image * last_mipP = this;
+
+ while ((ddrval == DD_OK) && (MipMapNum < n_mips_max)) // both tests in case...
+ {
+ // Call LoadPPMIntoDDSurface with lpThisMipMap, new file name, and
+ // other values.
+
+ *DDSurfaceA[MipMapNum] = last_mipP->CopyToDDSurface(lpThisMipMap);
+
+ // Death trap
+ if (!*DDSurfaceA[MipMapNum])
+ {
+ return CLE_DXERROR;
+ }
+ *DDPtrA[MipMapNum] = lpThisMipMap;
+
+ // Proceed to the next level.
+ // Collect bonus rings.
+ ddrval = lpThisMipMap->GetAttachedSurface(&ddsCaps, &lpNextMipMap);
+ // Necessary to match the manual increment of the reference count on the
+ // COM texture. I think.
+ lpThisMipMap->Release();
+ // ?? lpNextMipMap = lpThisMipMap;
+ lpThisMipMap = lpNextMipMap;
+
+ MipMapNum++;
+ if (!i_mip.done())
+ {
+ last_mipP = i_mip();
+ i_mip.next();
+ }
+ }
+ }
+ else
+ {
+ *DDSurfaceA[0] = CopyToDDSurface(lpDDS);
+
+ if (!*DDSurfaceA[0]) return CLE_DXERROR;
+
+ *DDPtrA[0] = lpDDS;
+ }
+
+ return CLE_OK;
+}
+
+
+CL_Error CL_Image::CopyToDirectDrawSurface(LPDIRECTDRAWSURFACE * const DDPtrA [], LPVOID * const DDSurfaceA [], int const MemoryType, unsigned int n_mips_max)
+{
+ if (!flags.loaded) return CLE_LOADERROR;
+
+ WaitForVRamReady(VWS_DDCREATE);
+
+ if (CLL_DDSURFACE != lmode) CL_Select_Mode(CLL_DDSURFACE);
+
+ LPDIRECTDRAWSURFACE lpDDS;
+ DDSURFACEDESC ddsd;
+ HRESULT ddrval;
+
+ // Check for image being 4 byte aligned
+ // and fail if it is not
+ if (width & 3 || height & 3)
+ {
+ // return error code
+ return CLE_DXERROR;
+ }
+
+ if (n_mips_max > mipmaps.size()+1) n_mips_max = mipmaps.size()+1;
+
+ // Set up the surface description. starting
+ // with the passed texture format and then
+ // incorporating the information read from the
+ // ppm.
+ memset(&ddsd, 0, sizeof ddsd);
+ ddsd.dwSize = sizeof ddsd;
+ ddsd.dwFlags = (DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT);
+ // Ensure that created surface has same pixel desription
+ // as primary
+ memcpy(&ddsd.ddpfPixelFormat, &DisplayPixelFormat, sizeof(DDPIXELFORMAT));
+ ddsd.ddsCaps.dwCaps = (DDSCAPS_OFFSCREENPLAIN | MemoryType);
+ ddsd.dwHeight = height;
+ ddsd.dwWidth = width;
+
+ if (n_mips_max>1)
+ {
+ ddsd.dwFlags |= DDSD_MIPMAPCOUNT;
+ ddsd.ddsCaps.dwCaps |= DDSCAPS_MIPMAP | DDSCAPS_COMPLEX;
+ ddsd.dwMipMapCount = n_mips_max;
+ }
+
+ // Create the surface
+ ddrval = lpDD->CreateSurface(&ddsd, &lpDDS, NULL);
+
+ LOGDXERR(ddrval);
+ if (ddrval != DD_OK)
+ {
+ #if debug
+ ReleaseDirect3D();
+ exit(ddrval);
+ #else
+ lpDDS->Release();
+ return CLE_DXERROR;
+ #endif
+ }
+
+ DDCOLORKEY set_zero = {0,0};
+ ddrval = lpDDS->SetColorKey(DDCKEY_SRCBLT, &set_zero);
+
+ LOGDXERR(ddrval);
+ if(ddrval != DD_OK)
+ {
+ #if debug
+ ReleaseDirect3D();
+ exit(ddrval);
+ #else
+ lpDDS->Release();
+ return CLE_DXERROR;
+ #endif
+ }
+
+
+ // now do mipmaps if avail
+
+ if (n_mips_max>1)
+ {
+ // We must now traverse the mip-map chain from highest to lowest
+ // resolutions, For each surface AFTER the first one, we must
+ // load a new file, using a name obtained from the mip map number
+
+ int MipMapNum = 0;
+ LPDIRECTDRAWSURFACE lpThisMipMap, lpNextMipMap;
+ DDSCAPS ddsCaps;
+
+
+ lpThisMipMap = lpDDS;
+ // Component Object Model, increase reference count on
+ // mip-map surface by one.
+ lpThisMipMap->AddRef();
+ ddsCaps.dwCaps = (DDSCAPS_TEXTURE | DDSCAPS_MIPMAP);
+ ddrval = DD_OK;
+
+ LIF<CL_Image *> i_mip(&mipmaps);
+
+ CL_Image * last_mipP = this;
+
+ while ((ddrval == DD_OK) && (MipMapNum < n_mips_max)) // both tests in case...
+ {
+ // Call LoadPPMIntoDDSurface with lpThisMipMap, new file name, and
+ // other values.
+
+ *DDSurfaceA[MipMapNum] = last_mipP->CopyToDDSurface(lpThisMipMap);
+
+ // Death trap
+ if (!*DDSurfaceA[MipMapNum])
+ {
+ return CLE_DXERROR;
+ }
+ *DDPtrA[MipMapNum] = lpThisMipMap;
+
+ // Proceed to the next level.
+ // Collect bonus rings.
+ ddrval = lpThisMipMap->GetAttachedSurface(&ddsCaps, &lpNextMipMap);
+ // Necessary to match the manual increment of the reference count on the
+ // COM texture. I think.
+ lpThisMipMap->Release();
+ // ?? lpNextMipMap = lpThisMipMap;
+ lpThisMipMap = lpNextMipMap;
+
+ MipMapNum++;
+ if (!i_mip.done())
+ {
+ last_mipP = i_mip();
+ i_mip.next();
+ }
+ }
+ }
+ else
+ {
+ *DDSurfaceA[0] = CopyToDDSurface(lpDDS);
+
+ if (!*DDSurfaceA[0]) return CLE_DXERROR;
+
+ *DDPtrA[0] = lpDDS;
+ }
+
+ return CLE_OK;
+}
+
+
+LPVOID CL_Image::CopyToDDSurface(LPDIRECTDRAWSURFACE lpDDS)
+{
+ if (!flags.loaded) return 0;
+
+ LPDIRECTDRAWPALETTE lpDDPPMPal;
+ PALETTEENTRY ppe[256];
+ DDSURFACEDESC ddsd;
+ #if QUANTISE_ON_LOAD
+ D3DCOLOR colors[256];
+ D3DCOLOR c;
+ int color_count;
+ #endif
+ int psize;
+ char *lpC;
+ HRESULT ddrval;
+ unsigned int i, j;
+ unsigned int pcaps;
+
+ // Lock the surface so it can be filled with the PPM file
+
+ memset(&ddsd, 0, sizeof(DDSURFACEDESC));
+ ddsd.dwSize = sizeof(DDSURFACEDESC);
+ ddrval = lpDDS->Lock(NULL, &ddsd, 0, NULL);
+
+ if (!ddsd.lpSurface)
+ {
+ lpDDS->Unlock(NULL);
+ lpDDS->Release();
+ LOGDXSTR("No surface");
+ return 0;
+ }
+
+ LOGDXERR(ddrval);
+ if (ddrval != DD_OK)
+ {
+ #if debug
+ ReleaseDirect3D();
+ exit(ddrval);
+ #else
+ lpDDS->Release();
+ return 0;
+ #endif
+ }
+
+ // The method of loading depends on the pixel format of the dest surface
+
+ switch (imode)
+ {
+ case CLM_32BIT:
+ switch (bitsperpixel)
+ {
+ case 32:
+ for (j = 0; j < height; j++)
+ {
+ // Point to next row in texture surface
+ unsigned long * lpLP = (unsigned long*)((char*)ddsd.lpSurface
+ + ddsd.lPitch * j);
+ CL_Pixel_32 * lpP32 = im32[j];
+ for (i = width; i; --i)
+ {
+ *lpLP++ = *lpP32++;
+ }
+ }
+ break;
+ case 24:
+ for (j = 0; j < height; j++)
+ {
+ // Point to next row in texture surface
+ unsigned char * lpCP = (unsigned char*)ddsd.lpSurface
+ + ddsd.lPitch * j;
+ CL_Pixel_32 * lpP32 = im32[j];
+ for (i = width; i; --i)
+ {
+ unsigned long lv = *lpP32++;
+ unsigned char const * lpSrcCP = (unsigned char const *)&lv;
+ // dodgy - makes assumtions about 24-bit values...
+ *lpCP++ = *lpSrcCP++;
+ *lpCP++ = *lpSrcCP++;
+ *lpCP++ = *lpSrcCP++;
+ }
+ }
+ break;
+ default:
+ #if debug
+ ReleaseDirect3D();
+ exit(ddrval);
+ #else
+ lpDDS->Unlock(NULL);
+ lpDDS->Release();
+ return 0;
+ #endif
+ }
+ lpDDS->Unlock(NULL);
+ break;
+ case CLM_16BIT:
+ switch (bitsperpixel)
+ {
+ case 16:
+ for (j = 0; j < height; j++)
+ {
+ // Point to next row in texture surface
+ unsigned short * lpSP = (unsigned short*)((char*)ddsd.lpSurface
+ + ddsd.lPitch * j);
+ CL_Pixel_16 * lpP16 = im16[j];
+ for (i = width; i; --i)
+ {
+ *lpSP++ = *lpP16++;
+ }
+ }
+ break;
+ case 8:
+ for (j = 0; j < height; j++)
+ {
+ // Point to next row in texture surface
+ unsigned char * lpCP = (unsigned char*)ddsd.lpSurface
+ + ddsd.lPitch * j;
+ CL_Pixel_16 * lpP16 = im16[j];
+ for (i = width; i; --i)
+ {
+ *lpCP++ = *lpP16++;
+ }
+ }
+ break;
+ default:
+ // Everything's gone pear-shaped...
+ #if debug
+ ReleaseDirect3D();
+ exit(ddrval);
+ #else
+ lpDDS->Unlock(NULL);
+ lpDDS->Release();
+ return 0;
+ #endif
+ }
+ lpDDS->Unlock(NULL);
+ break;
+ case CLM_24BIT:
+ if (24==bitsperpixel)
+ {
+ for (j = 0; j < height; j++)
+ {
+ // Point to next row in surface
+ unsigned char * lpCP = ((unsigned char*)ddsd.lpSurface) + ddsd.lPitch * j;
+ CL_Pixel_24 * lpP24 = im24[j];
+ for (i = 0; i < width; i++)
+ {
+ // making an assumption about the ordering of r,g,b on the video card
+ *lpCP++ = lpP24->b;
+ *lpCP++ = lpP24->g;
+ *lpCP++ = lpP24->r;
+ lpP24++;
+ }
+ }
+ lpDDS->Unlock(NULL);
+ }
+ else
+ {
+ #if QUANTISE_ON_LOAD // Neal's quantize on load stuff
+
+ // Paletted target texture surface
+ psize = 1<<bitsperpixel;
+ color_count = 0; // number of colors in the texture
+ for (j = 0; j < height; j++)
+ {
+ // Point to next row in surface
+ lpC = ((char*)ddsd.lpSurface) + ddsd.lPitch * j;
+ CL_Pixel_24 * lpP24 = im24[j];
+ for (i = 0; i < width; i++, lpP24++)
+ {
+ int k;
+ // Get the next red, green and blue values and turn them into a
+ // D3DCOLOR.
+ c = RGB_MAKE(lpP24->r, lpP24->g, lpP24->b);
+ // Search for this color in a table of colors in this texture
+ for (k = 0; k < color_count; k++)
+ if (c == colors[k]) break;
+ if (k == color_count)
+ {
+ // This is a new color, so add it to the list
+ color_count++;
+ // More than 256 and we fail (8-bit)
+ if (color_count > psize)
+ {
+ color_count--;
+ k = color_count - 1;
+ }
+ colors[k] = c;
+ }
+ // Set the "pixel" value on the surface to be the index into the
+ // color table
+ if (psize<256)
+ {
+ unsigned int bitmask;
+ switch (psize)
+ {
+ default:
+ bitmask = 1;
+ break;
+ case 4:
+ bitmask = 3;
+ break;
+ case 2:
+ bitmask = 7;
+ break;
+ }
+ if ((i & bitmask) == 0)
+ *lpC = (char)(k & (psize-1));
+ else
+ *lpC |= (char)((k & (psize-1)) << (i & (psize-1)));
+ if ((~i & bitmask) == 0)
+ lpC++;
+ }
+ else
+ {
+ *lpC = (char)k;
+ lpC++;
+ }
+ }
+ }
+
+ // Close the file and unlock the surface
+
+ lpDDS->Unlock(NULL);
+
+ if (color_count > psize)
+ {
+ // If there are more than 256 colors, we overran our palette
+ #if debug
+ ReleaseDirect3D();
+ exit(0x321123);
+ #else
+ lpDDS->Release();
+ return 0;
+ #endif
+ }
+
+ // Create a palette with the colors in our color table
+
+ memset(ppe, 0, sizeof(PALETTEENTRY) * 256);
+ for (i = 0; i < color_count; i++)
+ {
+ ppe[i].peRed = (unsigned char)RGB_GETRED(colors[i]);
+ ppe[i].peGreen = (unsigned char)RGB_GETGREEN(colors[i]);
+ ppe[i].peBlue = (unsigned char)RGB_GETBLUE(colors[i]);
+ }
+
+ // Set all remaining entry flags to D3DPAL_RESERVED, which are ignored by
+ // the renderer.
+
+ for (; i < 256; i++)
+ ppe[i].peFlags = D3DPAL_RESERVED;
+
+ // Create the palette with the DDPCAPS_ALLOW256 flag because we want to
+ // have access to all entries.
+
+ switch (bitsperpixel)
+ {
+ default:
+ pcaps = DDPCAPS_8BIT | DDPCAPS_ALLOW256;
+ break;
+ case 4:
+ pcaps = DDPCAPS_4BIT;
+ break;
+ case 2:
+ pcaps = DDPCAPS_2BIT;
+ break;
+ case 1:
+ pcaps = DDPCAPS_1BIT;
+ break;
+ }
+
+ ddrval = lpDD->CreatePalette
+ (DDPCAPS_INITIALIZE | pcaps,
+ ppe, &lpDDPPMPal, NULL);
+ LOGDXERR(ddrval);
+
+ if (ddrval != DD_OK)
+ {
+ #if debug
+ ReleaseDirect3D();
+ exit(ddrval);
+ #else
+ lpDDS->Release();
+ return 0;
+ #endif
+ }
+
+ // Finally, bind the palette to the surface
+
+ ddrval = lpDDS->SetPalette(lpDDPPMPal);
+ LOGDXERR(ddrval);
+ if (ddrval != DD_OK)
+ {
+ #if debug
+ ReleaseDirect3D();
+ exit(ddrval);
+ #else
+ lpDDS->Release();
+ lpDDPPMPal->Release();
+ return 0;
+ #endif
+ }
+
+ lpDDPPMPal->Release();
+ }
+ break;
+ #else
+ // Everything's gone pear-shaped...
+ #if debug
+ ReleaseDirect3D();
+ exit(ddrval);
+ #else
+ lpDDS->Unlock(NULL);
+ lpDDS->Release();
+ return 0;
+ #endif
+ }
+ break;
+ case CLM_ATTACHEDPALETTE:
+ #endif
+ case CLM_GLOBALPALETTE:
+ case CLM_TLTPALETTE:
+ // Paletted target texture surface
+
+ psize = 1<<bitsperpixel;
+ ReducePalette(psize); // will do nothing if palette is already small enough
+ // ignore returned error code, because I don't care if it failed
+ for (j = 0; j < height; j++)
+ {
+ // Point to next row in surface
+ lpC = ((char*)ddsd.lpSurface) + ddsd.lPitch * j;
+ unsigned char * lpP8 = im8[j];
+
+ if (psize<256)
+ {
+ unsigned int bitmask;
+ unsigned int nextpixelshift;
+ switch (psize)
+ {
+ default:
+ nextpixelshift = 2;
+ break;
+ case 4:
+ nextpixelshift = 1;
+ break;
+ case 2:
+ nextpixelshift = 0;
+ break;
+ }
+ bitmask = 7 >> nextpixelshift;
+ for (i = 0; i < width; i++)
+ {
+ unsigned char k = *lpP8++;
+ // Set the "pixel" value on the surface to be the index into the
+ // color table
+ if ((i & bitmask) == 0)
+ *lpC = (char) (k & (psize-1));
+ else
+ *lpC |= (char) ((k & (psize-1)) << ((i & bitmask)<<nextpixelshift));
+ if ((~i & bitmask) == 0)
+ lpC++;
+ }
+ }
+ else
+ {
+ memcpy(lpC,lpP8,width);
+ }
+ }
+
+ // Close the file and unlock the surface
+
+ lpDDS->Unlock(NULL);
+
+ // Create a palette with the colors in our color table
+
+ memset(ppe, 0, sizeof(PALETTEENTRY) * 256);
+ for (i = 0; i < palette_size; i++)
+ {
+ ppe[i].peRed = palette[i].r;
+ ppe[i].peGreen = palette[i].g;
+ ppe[i].peBlue = palette[i].b;
+ }
+
+ // Set all remaining entry flags to D3DPAL_RESERVED, which are ignored by
+ // the renderer.
+
+ for (; i < 256; i++)
+ ppe[i].peFlags = D3DPAL_RESERVED;
+
+ // Create the palette with the DDPCAPS_ALLOW256 flag because we want to
+ // have access to all entries.
+
+ switch (bitsperpixel)
+ {
+ default:
+ pcaps = DDPCAPS_8BIT | DDPCAPS_ALLOW256;
+ break;
+ case 4:
+ pcaps = DDPCAPS_4BIT;
+ break;
+ case 2:
+ pcaps = DDPCAPS_2BIT;
+ break;
+ case 1:
+ pcaps = DDPCAPS_1BIT;
+ break;
+ }
+
+ ddrval = lpDD->CreatePalette
+ (DDPCAPS_INITIALIZE | pcaps,
+ ppe, &lpDDPPMPal, NULL);
+ LOGDXERR(ddrval);
+
+ if (ddrval != DD_OK)
+ {
+ #if debug
+ ReleaseDirect3D();
+ exit(ddrval);
+ #else
+ lpDDS->Release();
+ return 0;
+ #endif
+ }
+
+ // Finally, bind the palette to the surface
+
+ ddrval = lpDDS->SetPalette(lpDDPPMPal);
+ LOGDXERR(ddrval);
+ if (ddrval != DD_OK)
+ {
+ #if debug
+ ReleaseDirect3D();
+ exit(ddrval);
+ #else
+ lpDDS->Release();
+ lpDDPPMPal->Release();
+ return 0;
+ #endif
+ }
+
+ lpDDPPMPal->Release();
+ break;
+ default:
+ // Everything's gone pear-shaped...
+ #if debug
+ ReleaseDirect3D();
+ exit(ddrval);
+ #else
+ lpDDS->Unlock(NULL);
+ lpDDS->Release();
+ return 0;
+ #endif
+
+
+ }
+
+ return ddsd.lpSurface;
+}
+
+
generated by cgit v1.3 (git 2.53.0) at 2026-03-22 09:26:00 +0000