/*
-Copyright (C) 1999-2007 id Software, Inc. and contributors.
-For a list of contributors, see the accompanying CONTRIBUTORS file.
+ Copyright (C) 1999-2007 id Software, Inc. and contributors.
+ For a list of contributors, see the accompanying CONTRIBUTORS file.
-This file is part of GtkRadiant.
+ This file is part of GtkRadiant.
-GtkRadiant is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
+ GtkRadiant is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
-GtkRadiant 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.
+ GtkRadiant 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 GtkRadiant; if not, write to the Free Software
-Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
-*/
+ You should have received a copy of the GNU General Public License
+ along with GtkRadiant; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
// lbmlib.c
typedef struct
{
- byte r;
- byte g;
- byte b;
+ byte r;
+ byte g;
+ byte b;
} paletteRGB_t;
-void CorrectPalette(byte *pal)
-{
- paletteRGB_t *p;
+void CorrectPalette( byte *pal ){
+ paletteRGB_t *p;
p = (paletteRGB_t *)pal;
// Color 0 always transparent
}
/*
-============================================================================
+ ============================================================================
- LBM STUFF
+ LBM STUFF
-============================================================================
-*/
+ ============================================================================
+ */
-typedef unsigned char UBYTE;
+typedef unsigned char UBYTE;
//conflicts with windows typedef short WORD;
-typedef unsigned short UWORD;
-typedef long LONG;
+typedef unsigned short UWORD;
+typedef long LONG;
typedef enum
{
typedef struct
{
- UWORD w,h;
- short x,y;
- UBYTE nPlanes;
- UBYTE masking;
- UBYTE compression;
- UBYTE pad1;
- UWORD transparentColor;
- UBYTE xAspect,yAspect;
- short pageWidth,pageHeight;
+ UWORD w,h;
+ short x,y;
+ UBYTE nPlanes;
+ UBYTE masking;
+ UBYTE compression;
+ UBYTE pad1;
+ UWORD transparentColor;
+ UBYTE xAspect,yAspect;
+ short pageWidth,pageHeight;
} bmhd_t;
-extern bmhd_t bmhd; // will be in native byte order
+extern bmhd_t bmhd; // will be in native byte order
-#define FORMID ('F'+('O'<<8)+((int)'R'<<16)+((int)'M'<<24))
-#define ILBMID ('I'+('L'<<8)+((int)'B'<<16)+((int)'M'<<24))
-#define PBMID ('P'+('B'<<8)+((int)'M'<<16)+((int)' '<<24))
-#define BMHDID ('B'+('M'<<8)+((int)'H'<<16)+((int)'D'<<24))
-#define BODYID ('B'+('O'<<8)+((int)'D'<<16)+((int)'Y'<<24))
-#define CMAPID ('C'+('M'<<8)+((int)'A'<<16)+((int)'P'<<24))
+#define FORMID ( 'F' + ( 'O' << 8 ) + ( (int)'R' << 16 ) + ( (int)'M' << 24 ) )
+#define ILBMID ( 'I' + ( 'L' << 8 ) + ( (int)'B' << 16 ) + ( (int)'M' << 24 ) )
+#define PBMID ( 'P' + ( 'B' << 8 ) + ( (int)'M' << 16 ) + ( (int)' ' << 24 ) )
+#define BMHDID ( 'B' + ( 'M' << 8 ) + ( (int)'H' << 16 ) + ( (int)'D' << 24 ) )
+#define BODYID ( 'B' + ( 'O' << 8 ) + ( (int)'D' << 16 ) + ( (int)'Y' << 24 ) )
+#define CMAPID ( 'C' + ( 'M' << 8 ) + ( (int)'A' << 16 ) + ( (int)'P' << 24 ) )
-bmhd_t bmhd;
+bmhd_t bmhd;
-int Align (int l)
-{
- if (l&1)
- return l+1;
+int Align( int l ){
+ if ( l & 1 ) {
+ return l + 1;
+ }
return l;
}
/*
-================
-LBMRLEdecompress
+ ================
+ LBMRLEdecompress
-Source must be evenly aligned!
-================
-*/
-byte *LBMRLEDecompress (byte *source,byte *unpacked, int bpwidth)
-{
- int count;
- byte b,rept;
+ Source must be evenly aligned!
+ ================
+ */
+byte *LBMRLEDecompress( byte *source,byte *unpacked, int bpwidth ){
+ int count;
+ byte b,rept;
count = 0;
{
rept = *source++;
- if (rept > 0x80)
- {
- rept = (rept^0xff)+2;
+ if ( rept > 0x80 ) {
+ rept = ( rept ^ 0xff ) + 2;
b = *source++;
- memset(unpacked,b,rept);
+ memset( unpacked,b,rept );
unpacked += rept;
}
- else if (rept < 0x80)
- {
+ else if ( rept < 0x80 ) {
rept++;
- memcpy(unpacked,source,rept);
+ memcpy( unpacked,source,rept );
unpacked += rept;
source += rept;
}
- else
+ else{
rept = 0; // rept of 0x80 is NOP
+ }
count += rept;
- } while (count<bpwidth);
+ } while ( count < bpwidth );
- if (count>bpwidth)
- Error ("Decompression exceeded width!\n");
+ if ( count > bpwidth ) {
+ Error( "Decompression exceeded width!\n" );
+ }
return source;
/*
-=================
-LoadLBM
-=================
-*/
-void LoadLBM (char *filename, byte **picture, byte **palette)
-{
+ =================
+ LoadLBM
+ =================
+ */
+void LoadLBM( char *filename, byte **picture, byte **palette ){
byte *LBMbuffer, *picbuffer, *cmapbuffer;
- int y;
+ int y;
byte *LBM_P, *LBMEND_P;
byte *pic_p;
byte *body_p;
- int formtype,formlength;
- int chunktype,chunklength;
+ int formtype,formlength;
+ int chunktype,chunklength;
// qiet compiler warnings
picbuffer = NULL;
//
// load the LBM
//
- LoadFile (filename, (void **)&LBMbuffer);
+ LoadFile( filename, (void **)&LBMbuffer );
//
// parse the LBM header
//
LBM_P = LBMbuffer;
- if ( *(int *)LBMbuffer != LittleLong(FORMID) )
- Error ("No FORM ID at start of file!\n");
+ if ( *(int *)LBMbuffer != LittleLong( FORMID ) ) {
+ Error( "No FORM ID at start of file!\n" );
+ }
LBM_P += 4;
formlength = BigLong( *(int *)LBM_P );
LBM_P += 4;
- LBMEND_P = LBM_P + Align(formlength);
+ LBMEND_P = LBM_P + Align( formlength );
- formtype = LittleLong(*(int *)LBM_P);
+ formtype = LittleLong( *(int *)LBM_P );
- if (formtype != ILBMID && formtype != PBMID)
- Error ("Unrecognized form type: %c%c%c%c\n", formtype&0xff
- ,(formtype>>8)&0xff,(formtype>>16)&0xff,(formtype>>24)&0xff);
+ if ( formtype != ILBMID && formtype != PBMID ) {
+ Error( "Unrecognized form type: %c%c%c%c\n", formtype & 0xff
+ ,( formtype >> 8 ) & 0xff,( formtype >> 16 ) & 0xff,( formtype >> 24 ) & 0xff );
+ }
LBM_P += 4;
// parse chunks
//
- while (LBM_P < LBMEND_P)
+ while ( LBM_P < LBMEND_P )
{
- chunktype = LBM_P[0] + (LBM_P[1]<<8) + (LBM_P[2]<<16) + (LBM_P[3]<<24);
+ chunktype = LBM_P[0] + ( LBM_P[1] << 8 ) + ( LBM_P[2] << 16 ) + ( LBM_P[3] << 24 );
LBM_P += 4;
- chunklength = LBM_P[3] + (LBM_P[2]<<8) + (LBM_P[1]<<16) + (LBM_P[0]<<24);
+ chunklength = LBM_P[3] + ( LBM_P[2] << 8 ) + ( LBM_P[1] << 16 ) + ( LBM_P[0] << 24 );
LBM_P += 4;
switch ( chunktype )
{
case BMHDID:
- memcpy (&bmhd,LBM_P,sizeof(bmhd));
- bmhd.w = BigShort(bmhd.w);
- bmhd.h = BigShort(bmhd.h);
- bmhd.x = BigShort(bmhd.x);
- bmhd.y = BigShort(bmhd.y);
- bmhd.pageWidth = BigShort(bmhd.pageWidth);
- bmhd.pageHeight = BigShort(bmhd.pageHeight);
+ memcpy( &bmhd,LBM_P,sizeof( bmhd ) );
+ bmhd.w = BigShort( bmhd.w );
+ bmhd.h = BigShort( bmhd.h );
+ bmhd.x = BigShort( bmhd.x );
+ bmhd.y = BigShort( bmhd.y );
+ bmhd.pageWidth = BigShort( bmhd.pageWidth );
+ bmhd.pageHeight = BigShort( bmhd.pageHeight );
break;
case CMAPID:
- cmapbuffer = malloc (768);
- memset (cmapbuffer, 0, 768);
- memcpy (cmapbuffer, LBM_P, chunklength);
- CorrectPalette(cmapbuffer);
+ cmapbuffer = malloc( 768 );
+ memset( cmapbuffer, 0, 768 );
+ memcpy( cmapbuffer, LBM_P, chunklength );
+ CorrectPalette( cmapbuffer );
break;
case BODYID:
body_p = LBM_P;
- pic_p = picbuffer = malloc (bmhd.w*bmhd.h);
- if (formtype == PBMID)
- {
- //
- // unpack PBM
- //
- for (y=0 ; y<bmhd.h ; y++, pic_p += bmhd.w)
+ pic_p = picbuffer = malloc( bmhd.w * bmhd.h );
+ if ( formtype == PBMID ) {
+ //
+ // unpack PBM
+ //
+ for ( y = 0 ; y < bmhd.h ; y++, pic_p += bmhd.w )
{
- if (bmhd.compression == cm_rle1)
- body_p = LBMRLEDecompress ((byte *)body_p
- , pic_p , bmhd.w);
- else if (bmhd.compression == cm_none)
- {
- memcpy (pic_p,body_p,bmhd.w);
- body_p += Align(bmhd.w);
+ if ( bmhd.compression == cm_rle1 ) {
+ body_p = LBMRLEDecompress( (byte *)body_p
+ , pic_p, bmhd.w );
+ }
+ else if ( bmhd.compression == cm_none ) {
+ memcpy( pic_p,body_p,bmhd.w );
+ body_p += Align( bmhd.w );
}
}
}
else
{
- //
- // unpack ILBM
- //
- Error ("%s is an interlaced LBM, not packed", filename);
+ //
+ // unpack ILBM
+ //
+ Error( "%s is an interlaced LBM, not packed", filename );
}
break;
}
- LBM_P += Align(chunklength);
+ LBM_P += Align( chunklength );
}
- free (LBMbuffer);
+ free( LBMbuffer );
*picture = picbuffer;
- if (palette)
+ if ( palette ) {
*palette = cmapbuffer;
+ }
}
/*
-============================================================================
+ ============================================================================
- WRITE LBM
+ WRITE LBM
-============================================================================
-*/
+ ============================================================================
+ */
/*
-==============
-WriteLBMfile
-==============
-*/
-void WriteLBMfile (char *filename, byte *data,
- int width, int height, byte *palette)
-{
+ ==============
+ WriteLBMfile
+ ==============
+ */
+void WriteLBMfile( char *filename, byte *data,
+ int width, int height, byte *palette ){
byte *lbm, *lbmptr;
int *formlength, *bmhdlength, *cmaplength, *bodylength;
- int length;
- bmhd_t basebmhd;
+ int length;
+ bmhd_t basebmhd;
- lbm = lbmptr = malloc (width*height+1000);
+ lbm = lbmptr = malloc( width * height + 1000 );
//
// start FORM
*lbmptr++ = 'M';
formlength = (int*)lbmptr;
- lbmptr+=4; // leave space for length
+ lbmptr += 4; // leave space for length
*lbmptr++ = 'P';
*lbmptr++ = 'B';
*lbmptr++ = 'D';
bmhdlength = (int *)lbmptr;
- lbmptr+=4; // leave space for length
-
- memset (&basebmhd,0,sizeof(basebmhd));
- basebmhd.w = BigShort((short)width);
- basebmhd.h = BigShort((short)height);
- basebmhd.nPlanes = BigShort(8);
- basebmhd.xAspect = BigShort(5);
- basebmhd.yAspect = BigShort(6);
- basebmhd.pageWidth = BigShort((short)width);
- basebmhd.pageHeight = BigShort((short)height);
-
- memcpy (lbmptr,&basebmhd,sizeof(basebmhd));
- lbmptr += sizeof(basebmhd);
-
- length = lbmptr-(byte *)bmhdlength-4;
- *bmhdlength = BigLong(length);
- if (length&1)
+ lbmptr += 4; // leave space for length
+
+ memset( &basebmhd,0,sizeof( basebmhd ) );
+ basebmhd.w = BigShort( (short)width );
+ basebmhd.h = BigShort( (short)height );
+ basebmhd.nPlanes = BigShort( 8 );
+ basebmhd.xAspect = BigShort( 5 );
+ basebmhd.yAspect = BigShort( 6 );
+ basebmhd.pageWidth = BigShort( (short)width );
+ basebmhd.pageHeight = BigShort( (short)height );
+
+ memcpy( lbmptr,&basebmhd,sizeof( basebmhd ) );
+ lbmptr += sizeof( basebmhd );
+
+ length = lbmptr - (byte *)bmhdlength - 4;
+ *bmhdlength = BigLong( length );
+ if ( length & 1 ) {
*lbmptr++ = 0; // pad chunk to even offset
+ }
//
// write CMAP
//
*lbmptr++ = 'P';
cmaplength = (int *)lbmptr;
- lbmptr+=4; // leave space for length
+ lbmptr += 4; // leave space for length
- memcpy (lbmptr,palette,768);
+ memcpy( lbmptr,palette,768 );
lbmptr += 768;
- length = lbmptr-(byte *)cmaplength-4;
- *cmaplength = BigLong(length);
- if (length&1)
+ length = lbmptr - (byte *)cmaplength - 4;
+ *cmaplength = BigLong( length );
+ if ( length & 1 ) {
*lbmptr++ = 0; // pad chunk to even offset
+ }
//
// write BODY
//
*lbmptr++ = 'Y';
bodylength = (int *)lbmptr;
- lbmptr+=4; // leave space for length
+ lbmptr += 4; // leave space for length
- memcpy (lbmptr,data,width*height);
- lbmptr += width*height;
+ memcpy( lbmptr,data,width * height );
+ lbmptr += width * height;
- length = lbmptr-(byte *)bodylength-4;
- *bodylength = BigLong(length);
- if (length&1)
+ length = lbmptr - (byte *)bodylength - 4;
+ *bodylength = BigLong( length );
+ if ( length & 1 ) {
*lbmptr++ = 0; // pad chunk to even offset
+ }
//
// done
//
- length = lbmptr-(byte *)formlength-4;
- *formlength = BigLong(length);
- if (length&1)
+ length = lbmptr - (byte *)formlength - 4;
+ *formlength = BigLong( length );
+ if ( length & 1 ) {
*lbmptr++ = 0; // pad chunk to even offset
+ }
//
// write output file
//
- SaveFile (filename, lbm, lbmptr-lbm);
- free (lbm);
+ SaveFile( filename, lbm, lbmptr - lbm );
+ free( lbm );
}
/*
-============================================================================
+ ============================================================================
-LOAD PCX
+ LOAD PCX
-============================================================================
-*/
+ ============================================================================
+ */
typedef struct
{
- char manufacturer;
- char version;
- char encoding;
- char bits_per_pixel;
- unsigned short xmin,ymin,xmax,ymax;
- unsigned short hres,vres;
- unsigned char palette[48];
- char reserved;
- char color_planes;
- unsigned short bytes_per_line;
- unsigned short palette_type;
- char filler[58];
- unsigned char data; // unbounded
+ char manufacturer;
+ char version;
+ char encoding;
+ char bits_per_pixel;
+ unsigned short xmin,ymin,xmax,ymax;
+ unsigned short hres,vres;
+ unsigned char palette[48];
+ char reserved;
+ char color_planes;
+ unsigned short bytes_per_line;
+ unsigned short palette_type;
+ char filler[58];
+ unsigned char data; // unbounded
} pcx_t;
/*
-==============
-LoadPCX
-==============
-*/
-void LoadPCX (char *filename, byte **pic, byte **palette, int *width, int *height)
-{
- byte *raw;
- pcx_t *pcx;
- int x, y;
- int len;
- int dataByte, runLength;
- byte *out, *pix;
+ ==============
+ LoadPCX
+ ==============
+ */
+void LoadPCX( char *filename, byte **pic, byte **palette, int *width, int *height ){
+ byte *raw;
+ pcx_t *pcx;
+ int x, y;
+ int len;
+ int dataByte, runLength;
+ byte *out, *pix;
//
// load the file
//
- len = LoadFile (filename, (void **)&raw);
+ len = LoadFile( filename, (void **)&raw );
//
// parse the PCX file
pcx = (pcx_t *)raw;
raw = &pcx->data;
- pcx->xmin = LittleShort(pcx->xmin);
- pcx->ymin = LittleShort(pcx->ymin);
- pcx->xmax = LittleShort(pcx->xmax);
- pcx->ymax = LittleShort(pcx->ymax);
- pcx->hres = LittleShort(pcx->hres);
- pcx->vres = LittleShort(pcx->vres);
- pcx->bytes_per_line = LittleShort(pcx->bytes_per_line);
- pcx->palette_type = LittleShort(pcx->palette_type);
-
- if (pcx->manufacturer != 0x0a
- || pcx->version != 5
- || pcx->encoding != 1
- || pcx->bits_per_pixel != 8
- || pcx->xmax >= 640
- || pcx->ymax >= 480)
- Error ("Bad pcx file %s", filename);
-
- if (palette)
- {
- *palette = malloc(768);
- memcpy (*palette, (byte *)pcx + len - 768, 768);
- CorrectPalette(*palette);
+ pcx->xmin = LittleShort( pcx->xmin );
+ pcx->ymin = LittleShort( pcx->ymin );
+ pcx->xmax = LittleShort( pcx->xmax );
+ pcx->ymax = LittleShort( pcx->ymax );
+ pcx->hres = LittleShort( pcx->hres );
+ pcx->vres = LittleShort( pcx->vres );
+ pcx->bytes_per_line = LittleShort( pcx->bytes_per_line );
+ pcx->palette_type = LittleShort( pcx->palette_type );
+
+ if ( pcx->manufacturer != 0x0a
+ || pcx->version != 5
+ || pcx->encoding != 1
+ || pcx->bits_per_pixel != 8
+ || pcx->xmax >= 640
+ || pcx->ymax >= 480 ) {
+ Error( "Bad pcx file %s", filename );
}
- if (width)
- *width = pcx->xmax+1;
- if (height)
- *height = pcx->ymax+1;
+ if ( palette ) {
+ *palette = malloc( 768 );
+ memcpy( *palette, (byte *)pcx + len - 768, 768 );
+ CorrectPalette( *palette );
+ }
+
+ if ( width ) {
+ *width = pcx->xmax + 1;
+ }
+ if ( height ) {
+ *height = pcx->ymax + 1;
+ }
- if (!pic)
+ if ( !pic ) {
return;
+ }
- out = malloc ( (pcx->ymax+1) * (pcx->xmax+1) );
- if (!out)
- Error ("Skin_Cache: couldn't allocate");
+ out = malloc( ( pcx->ymax + 1 ) * ( pcx->xmax + 1 ) );
+ if ( !out ) {
+ Error( "Skin_Cache: couldn't allocate" );
+ }
*pic = out;
pix = out;
- for (y=0 ; y<=pcx->ymax ; y++, pix += pcx->xmax+1)
+ for ( y = 0 ; y <= pcx->ymax ; y++, pix += pcx->xmax + 1 )
{
- for (x=0 ; x<=pcx->xmax ; )
+ for ( x = 0 ; x <= pcx->xmax ; )
{
dataByte = *raw++;
- if((dataByte & 0xC0) == 0xC0)
- {
+ if ( ( dataByte & 0xC0 ) == 0xC0 ) {
runLength = dataByte & 0x3F;
dataByte = *raw++;
}
- else
+ else{
runLength = 1;
+ }
- while(runLength-- > 0)
+ while ( runLength-- > 0 )
pix[x++] = dataByte;
}
}
- if ( raw - (byte *)pcx > len)
- Error ("PCX file %s was malformed", filename);
+ if ( raw - (byte *)pcx > len ) {
+ Error( "PCX file %s was malformed", filename );
+ }
- free (pcx);
+ free( pcx );
}
-/*
-==============
-WritePCXfile
-==============
-*/
+/*
+ ==============
+ WritePCXfile
+ ==============
+ */
-void StuffPackedByte(int curRepCount, byte curByte, byte** packPtr)
-{
+void StuffPackedByte( int curRepCount, byte curByte, byte** packPtr ){
byte* pack;
-
+
pack = *packPtr;
- while(curRepCount > 0)
+ while ( curRepCount > 0 )
{
- if (curRepCount == 1)
- {
- if ((curByte & 0xc0) != 0xc0)
- {
+ if ( curRepCount == 1 ) {
+ if ( ( curByte & 0xc0 ) != 0xc0 ) {
*pack++ = curByte;
}
else
}
break;
}
- if (curRepCount < 0x0040)
- {
- *pack++ = (0x00c0 | curRepCount);
+ if ( curRepCount < 0x0040 ) {
+ *pack++ = ( 0x00c0 | curRepCount );
curRepCount = 0;
}
else
*packPtr = pack;
}
-void WritePCXfile (char *filename, byte *data,
- int width, int height, byte *palette)
-{
- int i, j, length;
- pcx_t *pcx;
- byte *pack;
- byte curByte;
- int curRepCount;
-
- pcx = malloc (width*height*2+1000);
- memset (pcx, 0, sizeof(*pcx));
-
- pcx->manufacturer = 0x0a; // PCX id
- pcx->version = 5; // 256 color
- pcx->encoding = 1; // RLE
- pcx->bits_per_pixel = 8; // 256 color
+void WritePCXfile( char *filename, byte *data,
+ int width, int height, byte *palette ){
+ int i, j, length;
+ pcx_t *pcx;
+ byte *pack;
+ byte curByte;
+ int curRepCount;
+
+ pcx = malloc( width * height * 2 + 1000 );
+ memset( pcx, 0, sizeof( *pcx ) );
+
+ pcx->manufacturer = 0x0a; // PCX id
+ pcx->version = 5; // 256 color
+ pcx->encoding = 1; // RLE
+ pcx->bits_per_pixel = 8; // 256 color
pcx->xmin = 0;
pcx->ymin = 0;
- pcx->xmax = LittleShort((short)(width-1));
- pcx->ymax = LittleShort((short)(height-1));
- pcx->hres = LittleShort((short)width);
- pcx->vres = LittleShort((short)height);
- pcx->color_planes = 1; // chunky image
- pcx->bytes_per_line = LittleShort((short)width);
- pcx->palette_type = LittleShort(1); // not a grey scale
+ pcx->xmax = LittleShort( (short)( width - 1 ) );
+ pcx->ymax = LittleShort( (short)( height - 1 ) );
+ pcx->hres = LittleShort( (short)width );
+ pcx->vres = LittleShort( (short)height );
+ pcx->color_planes = 1; // chunky image
+ pcx->bytes_per_line = LittleShort( (short)width );
+ pcx->palette_type = LittleShort( 1 ); // not a grey scale
// pack the image
pack = &pcx->data;
-
+
/* for (i=0 ; i<height ; i++)
- {
- for (j=0 ; j<width ; j++)
- {
- if ( (*data & 0xc0) != 0xc0)
- *pack++ = *data++;
- else
- {
- *pack++ = 0xc1;
- *pack++ = *data++;
- }
- }
- }
-*/
- for (i=0 ; i<height ; i++)
+ {
+ for (j=0 ; j<width ; j++)
+ {
+ if ( (*data & 0xc0) != 0xc0)
+ *pack++ = *data++;
+ else
+ {
+ *pack++ = 0xc1;
+ *pack++ = *data++;
+ }
+ }
+ }
+ */
+ for ( i = 0 ; i < height ; i++ )
{
curByte = *data;
curRepCount = 0;
- for (j=0 ; j<width ; j++)
+ for ( j = 0 ; j < width ; j++ )
{
- if (*data == curByte)
- {
+ if ( *data == curByte ) {
curRepCount++;
data++;
continue;
}
- StuffPackedByte(curRepCount, curByte, &pack);
+ StuffPackedByte( curRepCount, curByte, &pack );
curByte = *data++;
curRepCount = 1;
}
- StuffPackedByte(curRepCount, curByte, &pack);
+ StuffPackedByte( curRepCount, curByte, &pack );
}
// write the palette
- *pack++ = 0x0c; // palette ID byte
- for (i=0 ; i<768 ; i++)
+ *pack++ = 0x0c; // palette ID byte
+ for ( i = 0 ; i < 768 ; i++ )
*pack++ = *palette++;
-
-// write output file
+
+// write output file
length = pack - (byte *)pcx;
- SaveFile (filename, pcx, length);
+ SaveFile( filename, pcx, length );
+
+ free( pcx );
+}
- free (pcx);
-}
-
/*
-============================================================================
+ ============================================================================
-LOAD IMAGE
+ LOAD IMAGE
-============================================================================
-*/
+ ============================================================================
+ */
/*
-==============
-Load256Image
-
-Will load either an lbm or pcx, depending on extension.
-Any of the return pointers can be NULL if you don't want them.
-==============
-*/
-void Load256Image (char *name, byte **pixels, byte **palette,
- int *width, int *height)
-{
- char ext[128];
-
- ExtractFileExtension (name, ext);
- if (!Q_strcasecmp (ext, "lbm"))
- {
- LoadLBM (name, pixels, palette);
- if (width)
+ ==============
+ Load256Image
+
+ Will load either an lbm or pcx, depending on extension.
+ Any of the return pointers can be NULL if you don't want them.
+ ==============
+ */
+void Load256Image( char *name, byte **pixels, byte **palette,
+ int *width, int *height ){
+ char ext[128];
+
+ ExtractFileExtension( name, ext );
+ if ( !Q_strcasecmp( ext, "lbm" ) ) {
+ LoadLBM( name, pixels, palette );
+ if ( width ) {
*width = bmhd.w;
- if (height)
+ }
+ if ( height ) {
*height = bmhd.h;
+ }
}
- else if (!Q_strcasecmp (ext, "pcx"))
- {
- LoadPCX (name, pixels, palette, width, height);
+ else if ( !Q_strcasecmp( ext, "pcx" ) ) {
+ LoadPCX( name, pixels, palette, width, height );
+ }
+ else{
+ Error( "%s doesn't have a known image extension", name );
}
- else
- Error ("%s doesn't have a known image extension", name);
}
/*
-==============
-Save256Image
-
-Will save either an lbm or pcx, depending on extension.
-==============
-*/
-void Save256Image (char *name, byte *pixels, byte *palette,
- int width, int height)
-{
- char ext[128];
-
- ExtractFileExtension (name, ext);
- if (!Q_strcasecmp (ext, "lbm"))
- {
- WriteLBMfile (name, pixels, width, height, palette);
+ ==============
+ Save256Image
+
+ Will save either an lbm or pcx, depending on extension.
+ ==============
+ */
+void Save256Image( char *name, byte *pixels, byte *palette,
+ int width, int height ){
+ char ext[128];
+
+ ExtractFileExtension( name, ext );
+ if ( !Q_strcasecmp( ext, "lbm" ) ) {
+ WriteLBMfile( name, pixels, width, height, palette );
}
- else if (!Q_strcasecmp (ext, "pcx"))
- {
- WritePCXfile (name, pixels, width, height, palette);
+ else if ( !Q_strcasecmp( ext, "pcx" ) ) {
+ WritePCXfile( name, pixels, width, height, palette );
+ }
+ else{
+ Error( "%s doesn't have a known image extension", name );
}
- else
- Error ("%s doesn't have a known image extension", name);
}
/*
-============================================================================
+ ============================================================================
-TARGA IMAGE
+ TARGA IMAGE
-============================================================================
-*/
+ ============================================================================
+ */
typedef struct _TargaHeader
{
- unsigned char id_length, colormap_type, image_type;
- unsigned short colormap_index, colormap_length;
- unsigned char colormap_size;
- unsigned short x_origin, y_origin, width, height;
- unsigned char pixel_size, attributes;
+ unsigned char id_length, colormap_type, image_type;
+ unsigned short colormap_index, colormap_length;
+ unsigned char colormap_size;
+ unsigned short x_origin, y_origin, width, height;
+ unsigned char pixel_size, attributes;
} TargaHeader;
-int fgetLittleShort (FILE *f)
-{
- byte b1, b2;
+int fgetLittleShort( FILE *f ){
+ byte b1, b2;
- b1 = fgetc(f);
- b2 = fgetc(f);
+ b1 = fgetc( f );
+ b2 = fgetc( f );
- return((short)(b1 + (b2 << 8)));
+ return( (short)( b1 + ( b2 << 8 ) ) );
}
-int fgetLittleLong (FILE *f)
-{
- byte b1, b2, b3, b4;
+int fgetLittleLong( FILE *f ){
+ byte b1, b2, b3, b4;
- b1 = fgetc(f);
- b2 = fgetc(f);
- b3 = fgetc(f);
- b4 = fgetc(f);
+ b1 = fgetc( f );
+ b2 = fgetc( f );
+ b3 = fgetc( f );
+ b4 = fgetc( f );
- return(b1 + (b2 << 8) + (b3 << 16) + (b4 << 24));
+ return( b1 + ( b2 << 8 ) + ( b3 << 16 ) + ( b4 << 24 ) );
}
/*
-=============
-LoadTGA
-=============
-*/
-void LoadTGA(char *name, byte **pixels, int *width, int *height)
-{
- int columns, rows, numPixels;
- byte *pixbuf;
- byte *rowBuf;
- int row, column;
- FILE *fin;
- byte *targa_rgba;
- TargaHeader targa_header;
- unsigned char red, green, blue, alphabyte;
- unsigned char packetHeader, packetSize, j;
- int flip;
- int mirror;
- int rowOffset;
- int pixDirection;
-
- fin = fopen(name, "rb");
- if (!fin)
- Error ("Couldn't read %s", name);
-
- targa_header.id_length = fgetc(fin);
- targa_header.colormap_type = fgetc(fin);
- targa_header.image_type = fgetc(fin);
-
- targa_header.colormap_index = fgetLittleShort(fin);
- targa_header.colormap_length = fgetLittleShort(fin);
- targa_header.colormap_size = fgetc(fin);
- targa_header.x_origin = fgetLittleShort(fin);
- targa_header.y_origin = fgetLittleShort(fin);
- targa_header.width = fgetLittleShort(fin);
- targa_header.height = fgetLittleShort(fin);
- targa_header.pixel_size = fgetc(fin);
- targa_header.attributes = fgetc(fin);
- flip = (targa_header.attributes & 0x020) == 0;
- mirror = (targa_header.attributes & 0x010) != 0;
-
- if ((targa_header.image_type != 2) && (targa_header.image_type != 10))
- Error ("LoadTGA: Only type 2 and 10 targa RGB images supported\n");
-
- if (targa_header.colormap_type || ((targa_header.pixel_size != 32) && (targa_header.pixel_size != 24)))
- Error ("Texture_LoadTGA: Only 32 or 24 bit images supported (no colormaps)\n");
+ =============
+ LoadTGA
+ =============
+ */
+void LoadTGA( char *name, byte **pixels, int *width, int *height ){
+ int columns, rows, numPixels;
+ byte *pixbuf;
+ byte *rowBuf;
+ int row, column;
+ FILE *fin;
+ byte *targa_rgba;
+ TargaHeader targa_header;
+ unsigned char red, green, blue, alphabyte;
+ unsigned char packetHeader, packetSize, j;
+ int flip;
+ int mirror;
+ int rowOffset;
+ int pixDirection;
+
+ fin = fopen( name, "rb" );
+ if ( !fin ) {
+ Error( "Couldn't read %s", name );
+ }
+
+ targa_header.id_length = fgetc( fin );
+ targa_header.colormap_type = fgetc( fin );
+ targa_header.image_type = fgetc( fin );
+
+ targa_header.colormap_index = fgetLittleShort( fin );
+ targa_header.colormap_length = fgetLittleShort( fin );
+ targa_header.colormap_size = fgetc( fin );
+ targa_header.x_origin = fgetLittleShort( fin );
+ targa_header.y_origin = fgetLittleShort( fin );
+ targa_header.width = fgetLittleShort( fin );
+ targa_header.height = fgetLittleShort( fin );
+ targa_header.pixel_size = fgetc( fin );
+ targa_header.attributes = fgetc( fin );
+ flip = ( targa_header.attributes & 0x020 ) == 0;
+ mirror = ( targa_header.attributes & 0x010 ) != 0;
+
+ if ( ( targa_header.image_type != 2 ) && ( targa_header.image_type != 10 ) ) {
+ Error( "LoadTGA: Only type 2 and 10 targa RGB images supported\n" );
+ }
+
+ if ( targa_header.colormap_type || ( ( targa_header.pixel_size != 32 ) && ( targa_header.pixel_size != 24 ) ) ) {
+ Error( "Texture_LoadTGA: Only 32 or 24 bit images supported (no colormaps)\n" );
+ }
columns = targa_header.width;
rows = targa_header.height;
numPixels = columns * rows;
- if (width)
+ if ( width ) {
*width = columns;
- if (height)
+ }
+ if ( height ) {
*height = rows;
+ }
- if(!pixels)
+ if ( !pixels ) {
return;
+ }
- targa_rgba = malloc(numPixels * 4);
+ targa_rgba = malloc( numPixels * 4 );
*pixels = targa_rgba;
- if (flip)
- {
- pixbuf = targa_rgba + ((rows - 1) * columns * 4);
+ if ( flip ) {
+ pixbuf = targa_rgba + ( ( rows - 1 ) * columns * 4 );
rowOffset = -columns * 4;
}
else
pixbuf = targa_rgba;
rowOffset = columns * 4;
}
- if (mirror)
- {
+ if ( mirror ) {
pixDirection = -4;
- pixbuf += ((columns - 1) * 4);
+ pixbuf += ( ( columns - 1 ) * 4 );
}
else
{
pixDirection = 4;
}
- if (targa_header.id_length)
- fseek(fin, targa_header.id_length, SEEK_CUR); // skip TARGA image comment
-
- if (targa_header.image_type == 2)
- { // Uncompressed, RGB images
- for(row = 0; row < rows; row++)
+ if ( targa_header.id_length ) {
+ fseek( fin, targa_header.id_length, SEEK_CUR ); // skip TARGA image comment
+
+ }
+ if ( targa_header.image_type == 2 ) { // Uncompressed, RGB images
+ for ( row = 0; row < rows; row++ )
{
rowBuf = pixbuf;
- for(column = 0; column < columns; column++)
+ for ( column = 0; column < columns; column++ )
{
- switch (targa_header.pixel_size)
+ switch ( targa_header.pixel_size )
{
- case 24:
- blue = getc(fin);
- green = getc(fin);
- red = getc(fin);
- rowBuf[0] = red;
- rowBuf[1] = green;
- rowBuf[2] = blue;
- rowBuf[3] = 255;
- rowBuf += pixDirection;
+ case 24:
+ blue = getc( fin );
+ green = getc( fin );
+ red = getc( fin );
+ rowBuf[0] = red;
+ rowBuf[1] = green;
+ rowBuf[2] = blue;
+ rowBuf[3] = 255;
+ rowBuf += pixDirection;
break;
- case 32:
- blue = getc(fin);
- green = getc(fin);
- red = getc(fin);
- alphabyte = getc(fin);
- rowBuf[0] = red;
- rowBuf[1] = green;
- rowBuf[2] = blue;
- rowBuf[3] = alphabyte;
- rowBuf += pixDirection;
+ case 32:
+ blue = getc( fin );
+ green = getc( fin );
+ red = getc( fin );
+ alphabyte = getc( fin );
+ rowBuf[0] = red;
+ rowBuf[1] = green;
+ rowBuf[2] = blue;
+ rowBuf[3] = alphabyte;
+ rowBuf += pixDirection;
break;
}
}
pixbuf += rowOffset;
}
}
- else if(targa_header.image_type == 10)
- { // Runlength encoded RGB images
- for(row = 0; row < rows; row++)
+ else if ( targa_header.image_type == 10 ) { // Runlength encoded RGB images
+ for ( row = 0; row < rows; row++ )
{
rowBuf = pixbuf;
- for(column = 0; column < columns; )
+ for ( column = 0; column < columns; )
{
- packetHeader = getc(fin);
- packetSize = 1 + (packetHeader & 0x7f);
- if (packetHeader & 0x80)
- { // run-length packet
- switch (targa_header.pixel_size)
+ packetHeader = getc( fin );
+ packetSize = 1 + ( packetHeader & 0x7f );
+ if ( packetHeader & 0x80 ) { // run-length packet
+ switch ( targa_header.pixel_size )
{
- case 24:
- blue = getc(fin);
- green = getc(fin);
- red = getc(fin);
- alphabyte = 255;
- break;
- case 32:
- blue = getc(fin);
- green = getc(fin);
- red = getc(fin);
- alphabyte = getc(fin);
- break;
+ case 24:
+ blue = getc( fin );
+ green = getc( fin );
+ red = getc( fin );
+ alphabyte = 255;
+ break;
+ case 32:
+ blue = getc( fin );
+ green = getc( fin );
+ red = getc( fin );
+ alphabyte = getc( fin );
+ break;
}
-
- for(j = 0; j < packetSize; j++)
+
+ for ( j = 0; j < packetSize; j++ )
{
rowBuf[0] = red;
rowBuf[1] = green;
rowBuf[3] = alphabyte;
rowBuf += pixDirection;
column++;
- if(column == columns)
- { // run spans across rows
+ if ( column == columns ) { // run spans across rows
column = 0;
row++;
- if (row >= rows)
+ if ( row >= rows ) {
goto breakOut;
+ }
pixbuf += rowOffset;
rowBuf = pixbuf;
}
}
}
else
- { // non run-length packet
- for(j = 0; j < packetSize; j++)
+ { // non run-length packet
+ for ( j = 0; j < packetSize; j++ )
{
- switch (targa_header.pixel_size)
+ switch ( targa_header.pixel_size )
{
- case 24:
- blue = getc(fin);
- green = getc(fin);
- red = getc(fin);
- rowBuf[0] = red;
- rowBuf[1] = green;
- rowBuf[2] = blue;
- rowBuf[3] = 255;
- rowBuf += pixDirection;
+ case 24:
+ blue = getc( fin );
+ green = getc( fin );
+ red = getc( fin );
+ rowBuf[0] = red;
+ rowBuf[1] = green;
+ rowBuf[2] = blue;
+ rowBuf[3] = 255;
+ rowBuf += pixDirection;
break;
- case 32:
- blue = getc(fin);
- green = getc(fin);
- red = getc(fin);
- alphabyte = getc(fin);
- rowBuf[0] = red;
- rowBuf[1] = green;
- rowBuf[2] = blue;
- rowBuf[3] = alphabyte;
- rowBuf += pixDirection;
+ case 32:
+ blue = getc( fin );
+ green = getc( fin );
+ red = getc( fin );
+ alphabyte = getc( fin );
+ rowBuf[0] = red;
+ rowBuf[1] = green;
+ rowBuf[2] = blue;
+ rowBuf[3] = alphabyte;
+ rowBuf += pixDirection;
break;
}
column++;
- if (column == columns)
- { // pixel packet run spans across rows
+ if ( column == columns ) { // pixel packet run spans across rows
column = 0;
row++;
- if (row >= rows)
+ if ( row >= rows ) {
goto breakOut;
+ }
pixbuf += rowOffset;
rowBuf = pixbuf;
- }
+ }
}
}
}
- breakOut:;
+breakOut:;
pixbuf += rowOffset;
}
}
- fclose(fin);
+ fclose( fin );
}
-void MergeAlpha(byte *pix, byte *alpha, byte *pal, byte **out, int width, int height)
-{
- int size, i;
- byte *data, *src, *srca;
+void MergeAlpha( byte *pix, byte *alpha, byte *pal, byte **out, int width, int height ){
+ int size, i;
+ byte *data, *src, *srca;
size = width * height;
- data = malloc(size * 4);
- if(!data)
- Error("Could not allocate memory for true color image");
+ data = malloc( size * 4 );
+ if ( !data ) {
+ Error( "Could not allocate memory for true color image" );
+ }
*out = data;
src = pix;
srca = alpha;
- for(i = 0; i < size; i++, src++, srca++)
+ for ( i = 0; i < size; i++, src++, srca++ )
{
- *data++ = pal[*src * 3 + 0]; // r
- *data++ = pal[*src * 3 + 1]; // g
- *data++ = pal[*src * 3 + 2]; // b
- *data++ = *srca; // a
+ *data++ = pal[*src * 3 + 0]; // r
+ *data++ = pal[*src * 3 + 1]; // g
+ *data++ = pal[*src * 3 + 2]; // b
+ *data++ = *srca; // a
}
- free(pix);
- free(alpha);
- free(pal);
+ free( pix );
+ free( alpha );
+ free( pal );
}
/*
-==============
-LoadAnyImage
-
-Return Value:
- false: paletted texture
- true: true color RGBA image (no palette)
-==============
-*/
-qboolean LoadAnyImage (char *name, byte **pixels, byte **palette, int *width, int *height)
-{
- char ext[128];
- int len;
- int alpha_width, alpha_height;
- char alpha_name[128];
- byte *alpha_pixels;
-
- ExtractFileExtension (name, ext);
-
- if(palette)
- {
+ ==============
+ LoadAnyImage
+
+ Return Value:
+ false: paletted texture
+ true: true color RGBA image (no palette)
+ ==============
+ */
+qboolean LoadAnyImage( char *name, byte **pixels, byte **palette, int *width, int *height ){
+ char ext[128];
+ int len;
+ int alpha_width, alpha_height;
+ char alpha_name[128];
+ byte *alpha_pixels;
+
+ ExtractFileExtension( name, ext );
+
+ if ( palette ) {
*palette = NULL;
}
- if (!Q_strcasecmp (ext, "lbm"))
- {
- LoadLBM (name, pixels, palette);
- if (width)
+ if ( !Q_strcasecmp( ext, "lbm" ) ) {
+ LoadLBM( name, pixels, palette );
+ if ( width ) {
*width = bmhd.w;
- if (height)
+ }
+ if ( height ) {
*height = bmhd.h;
+ }
return false;
}
- else if (!Q_strcasecmp (ext, "pcx"))
- {
- len = strlen(name);
- strcpy(alpha_name, name);
- strcpy(&alpha_name[len - 4], "_a.pcx"); // Alpha map name (may not exist)
-
- if(FileExists(alpha_name))
- {
- LoadPCX (name, pixels, palette, width, height); // Load in image
- LoadPCX (alpha_name, &alpha_pixels, NULL, &alpha_width, &alpha_height); // Load in alpha map
- if((*width != alpha_width) || (*height != alpha_height))
- {
- Error("Alpha image dimensions not equal to graphic image dimensions");
+ else if ( !Q_strcasecmp( ext, "pcx" ) ) {
+ len = strlen( name );
+ strcpy( alpha_name, name );
+ strcpy( &alpha_name[len - 4], "_a.pcx" ); // Alpha map name (may not exist)
+
+ if ( FileExists( alpha_name ) ) {
+ LoadPCX( name, pixels, palette, width, height ); // Load in image
+ LoadPCX( alpha_name, &alpha_pixels, NULL, &alpha_width, &alpha_height ); // Load in alpha map
+ if ( ( *width != alpha_width ) || ( *height != alpha_height ) ) {
+ Error( "Alpha image dimensions not equal to graphic image dimensions" );
}
- MergeAlpha(*pixels, alpha_pixels, *palette, pixels, *width, *height);
- *palette = NULL;//Merge Frees pal
+ MergeAlpha( *pixels, alpha_pixels, *palette, pixels, *width, *height );
+ *palette = NULL; //Merge Frees pal
return true;
}
else
{
- LoadPCX (name, pixels, palette, width, height); // Load in image
+ LoadPCX( name, pixels, palette, width, height ); // Load in image
return false;
}
}
- else if (!Q_strcasecmp (ext, "tga"))
- {
- LoadTGA(name, pixels, width, height);
- if (palette)
- {
+ else if ( !Q_strcasecmp( ext, "tga" ) ) {
+ LoadTGA( name, pixels, width, height );
+ if ( palette ) {
*palette = NULL;
}
return true;
}
- else
- Error ("%s doesn't have a known image extension", name);
+ else{
+ Error( "%s doesn't have a known image extension", name );
+ }
return false;
}
-
projects / xonotic / netradiant.git / blobdiff