585 lines
14 KiB
C
585 lines
14 KiB
C
//=======================================================================
|
|
// Copyright XashXT Group 2007 ©
|
|
// img_mip.c - hl1 q1 image mips
|
|
//=======================================================================
|
|
|
|
#include "imagelib.h"
|
|
#include "wadfile.h"
|
|
#include "studio.h"
|
|
#include "sprite.h"
|
|
#include "qfont.h"
|
|
|
|
/*
|
|
============
|
|
Image_LoadPAL
|
|
============
|
|
*/
|
|
qboolean Image_LoadPAL( const char *name, const byte *buffer, size_t filesize )
|
|
{
|
|
int rendermode = LUMP_NORMAL;
|
|
|
|
if( filesize != 768 )
|
|
{
|
|
MsgDev( D_ERROR, "Image_LoadPAL: (%s) have invalid size (%d should be %d)\n", name, filesize, 768 );
|
|
return false;
|
|
}
|
|
|
|
if( name[0] == '#' )
|
|
{
|
|
// using palette name as rendermode
|
|
if( com.stristr( name, "normal" ))
|
|
rendermode = LUMP_NORMAL;
|
|
else if( com.stristr( name, "transparent" ))
|
|
rendermode = LUMP_TRANSPARENT;
|
|
else if( com.stristr( name, "decal" ))
|
|
rendermode = LUMP_DECAL;
|
|
else if( com.stristr( name, "qfont" ))
|
|
rendermode = LUMP_QFONT;
|
|
else if( com.stristr( name, "valve" ))
|
|
buffer = NULL; // force to get HL palette
|
|
}
|
|
|
|
// NOTE: image.d_currentpal not cleared with Image_Reset()
|
|
// and stay valid any time before new call of Image_SetPalette
|
|
Image_GetPaletteLMP( buffer, rendermode );
|
|
Image_CopyPalette32bit();
|
|
|
|
image.rgba = NULL; // only palette, not real image
|
|
image.size = 1024; // expanded palette
|
|
image.num_mips = image.depth = 0;
|
|
image.width = image.height = 0;
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
============
|
|
Image_LoadFNT
|
|
============
|
|
*/
|
|
qboolean Image_LoadFNT( const char *name, const byte *buffer, size_t filesize )
|
|
{
|
|
qfont_t font;
|
|
const byte *pal, *fin;
|
|
size_t size;
|
|
int numcolors;
|
|
|
|
if( image.hint == IL_HINT_Q1 )
|
|
return false; // Quake1 doesn't have qfonts
|
|
|
|
if( filesize < sizeof( font ))
|
|
return false;
|
|
Mem_Copy( &font, buffer, sizeof( font ));
|
|
|
|
// last sixty four bytes - what the hell ????
|
|
size = sizeof( qfont_t ) - 4 + ( 128 * font.width * QCHAR_WIDTH ) + sizeof( short ) + 768 + 64;
|
|
|
|
if( size != filesize )
|
|
{
|
|
// oldstyle font: "conchars" or "creditsfont"
|
|
image.width = 256; // hardcoded
|
|
image.height = font.height;
|
|
}
|
|
else
|
|
{
|
|
// Half-Life 1.1.0.0 font style (qfont_t)
|
|
image.width = font.width * QCHAR_WIDTH;
|
|
image.height = font.height;
|
|
}
|
|
|
|
if(!Image_LumpValidSize( name )) return false;
|
|
fin = buffer + sizeof( font ) - 4;
|
|
|
|
pal = fin + (image.width * image.height);
|
|
numcolors = *(short *)pal, pal += sizeof( short );
|
|
image.flags |= IMAGE_HAS_ALPHA; // fonts always have transparency
|
|
|
|
if( numcolors == 768 )
|
|
{
|
|
// newstyle font
|
|
Image_GetPaletteLMP( pal, LUMP_QFONT );
|
|
}
|
|
else if( numcolors == 256 )
|
|
{
|
|
// oldstyle font
|
|
Image_GetPaletteLMP( pal, LUMP_TRANSPARENT );
|
|
}
|
|
else
|
|
{
|
|
if( image.hint == IL_HINT_NO )
|
|
MsgDev( D_ERROR, "Image_LoadFNT: (%s) have invalid palette size %d\n", name, numcolors );
|
|
return false;
|
|
}
|
|
|
|
image.depth = 1;
|
|
image.type = PF_INDEXED_32; // 32-bit palette
|
|
|
|
return FS_AddMipmapToPack( fin, image.width, image.height );
|
|
}
|
|
|
|
/*
|
|
============
|
|
Image_LoadMDL
|
|
============
|
|
*/
|
|
qboolean Image_LoadMDL( const char *name, const byte *buffer, size_t filesize )
|
|
{
|
|
byte *fin;
|
|
size_t pixels;
|
|
mstudiotexture_t *pin;
|
|
int i, flags;
|
|
|
|
pin = (mstudiotexture_t *)buffer;
|
|
flags = pin->flags;
|
|
|
|
image.width = pin->width;
|
|
image.height = pin->height;
|
|
pixels = image.width * image.height;
|
|
fin = (byte *)pin->index; // setup buffer
|
|
|
|
if(!Image_LumpValidSize( name )) return false;
|
|
|
|
if( image.hint != IL_HINT_Q1 && !( flags & STUDIO_NF_QUAKESKIN ))
|
|
{
|
|
if( filesize < ( sizeof( *pin ) + pixels + 768 ))
|
|
return false;
|
|
|
|
if( flags & STUDIO_NF_TRANSPARENT )
|
|
{
|
|
byte *pal = fin + pixels;
|
|
|
|
// make transparent color is black, blue color looks ugly
|
|
if( Sys.app_name == HOST_NORMAL )
|
|
pal[255*3+0] = pal[255*3+1] = pal[255*3+2] = 0;
|
|
|
|
Image_GetPaletteLMP( pal, LUMP_TRANSPARENT );
|
|
image.flags |= IMAGE_HAS_ALPHA;
|
|
}
|
|
else Image_GetPaletteLMP( fin + pixels, LUMP_NORMAL );
|
|
}
|
|
else if( image.hint != IL_HINT_HL && flags & STUDIO_NF_QUAKESKIN )
|
|
{
|
|
if( filesize < ( sizeof( *pin ) + pixels ))
|
|
return false;
|
|
|
|
// alias models setup
|
|
Image_GetPaletteQ1();
|
|
|
|
// check for luma pixels
|
|
for( i = 0; i < pixels; i++ )
|
|
{
|
|
if( fin[i] > 224 )
|
|
{
|
|
Msg( "%s has luma-pixels\n", name );
|
|
image.flags |= IMAGE_HAS_LUMA_Q1;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if( image.hint == IL_HINT_NO )
|
|
MsgDev( D_ERROR, "Image_LoadMDL: lump (%s) is corrupted\n", name );
|
|
return false; // unknown or unsupported mode rejected
|
|
}
|
|
|
|
image.depth = 1;
|
|
image.type = PF_INDEXED_32; // 32-bit palete
|
|
|
|
return FS_AddMipmapToPack( fin, image.width, image.height );
|
|
}
|
|
|
|
/*
|
|
============
|
|
Image_LoadSPR
|
|
============
|
|
*/
|
|
qboolean Image_LoadSPR( const char *name, const byte *buffer, size_t filesize )
|
|
{
|
|
dspriteframe_t *pin; // indetical for q1\hl sprites
|
|
|
|
if( image.hint == IL_HINT_HL )
|
|
{
|
|
if( !image.d_currentpal )
|
|
{
|
|
MsgDev( D_ERROR, "Image_LoadSPR: (%s) palette not installed\n", name );
|
|
return false;
|
|
}
|
|
}
|
|
else if( image.hint == IL_HINT_Q1 )
|
|
{
|
|
Image_GetPaletteQ1();
|
|
}
|
|
else return false; // unknown mode rejected
|
|
|
|
pin = (dspriteframe_t *)buffer;
|
|
image.width = pin->width;
|
|
image.height = pin->height;
|
|
|
|
if( filesize < image.width * image.height )
|
|
{
|
|
MsgDev( D_ERROR, "Image_LoadSPR: file (%s) have invalid size\n", name );
|
|
return false;
|
|
}
|
|
|
|
// sorry, can't validate palette rendermode
|
|
if(!Image_LumpValidSize( name )) return false;
|
|
image.depth = 1;
|
|
image.type = PF_INDEXED_32; // 32-bit palete
|
|
|
|
// detect alpha-channel by palette type
|
|
if( image.d_rendermode == LUMP_DECAL || image.d_rendermode == LUMP_TRANSPARENT )
|
|
image.flags |= IMAGE_HAS_ALPHA;
|
|
|
|
return FS_AddMipmapToPack( (byte *)(pin + 1), image.width, image.height );
|
|
}
|
|
|
|
/*
|
|
==============
|
|
Image_LoadWAL
|
|
==============
|
|
*/
|
|
qboolean Image_LoadWAL( const char *name, const byte *buffer, size_t filesize )
|
|
{
|
|
wal_t wal;
|
|
int pixels, ofs[4], mipsize;
|
|
int i, flags, value, contents; // wal additional parms
|
|
const byte *fin;
|
|
|
|
if( filesize < (int)sizeof( wal ))
|
|
{
|
|
MsgDev( D_ERROR, "Image_LoadWAL: file (%s) have invalid size\n", name );
|
|
return false;
|
|
}
|
|
Mem_Copy( &wal, buffer, sizeof( wal ));
|
|
|
|
flags = wal.flags;
|
|
value = wal.value;
|
|
contents = wal.contents;
|
|
image.width = wal.width;
|
|
image.height = wal.height;
|
|
|
|
Mem_Copy( ofs, wal.offsets, sizeof( ofs ));
|
|
|
|
if( !Image_LumpValidSize( name ))
|
|
return false;
|
|
|
|
pixels = image.width * image.height;
|
|
mipsize = (int)sizeof(wal) + ofs[0] + pixels;
|
|
if( pixels > 256 && filesize < mipsize )
|
|
{
|
|
// NOTE: wal's with dimensions < 32 have invalid sizes.
|
|
MsgDev( D_ERROR, "Image_LoadWAL: file (%s) have invalid size\n", name );
|
|
return false;
|
|
}
|
|
|
|
image.depth = 1;
|
|
image.type = PF_INDEXED_32; // 32-bit palete
|
|
fin = buffer + ofs[0];
|
|
|
|
// check for luma pixels
|
|
for( i = 0; i < image.width * image.height; i++ )
|
|
{
|
|
if( fin[i] > 208 && fin[i] < 240 )
|
|
{
|
|
image.flags |= IMAGE_HAS_LUMA_Q2;
|
|
break;
|
|
}
|
|
}
|
|
|
|
Image_GetPaletteQ2(); // hardcoded
|
|
return FS_AddMipmapToPack( fin, image.width, image.height );
|
|
}
|
|
|
|
/*
|
|
============
|
|
Image_LoadFLT
|
|
============
|
|
*/
|
|
qboolean Image_LoadFLT( const char *name, const byte *buffer, size_t filesize )
|
|
{
|
|
flat_t flat;
|
|
vfile_t *f;
|
|
qboolean result = false;
|
|
int trans_pixels = 0;
|
|
word column_loop, row_loop;
|
|
int i, column_offset, pointer_position, first_pos;
|
|
byte *Data, post, topdelta, length;
|
|
|
|
if( filesize < (int)sizeof( flat ))
|
|
{
|
|
MsgDev( D_ERROR, "Image_LoadFLAT: file (%s) have invalid size\n", name );
|
|
return false;
|
|
}
|
|
|
|
// stupid copypaste from DevIL, but it works
|
|
f = VFS_Create( buffer, filesize );
|
|
first_pos = VFS_Tell( f );
|
|
VFS_Read(f, &flat, sizeof( flat ));
|
|
|
|
image.width = flat.width;
|
|
image.height = flat.height;
|
|
|
|
if( !Image_LumpValidSize( name ))
|
|
return false;
|
|
|
|
Data = (byte *)Mem_Alloc( Sys.imagepool, image.width * image.height );
|
|
Mem_Set( Data, 247, image.width * image.height ); // set default transparency
|
|
image.depth = 1;
|
|
|
|
for( column_loop = 0; column_loop < image.width; column_loop++ )
|
|
{
|
|
VFS_Read(f, &column_offset, sizeof(int));
|
|
pointer_position = VFS_Tell( f );
|
|
VFS_Seek( f, first_pos + column_offset, SEEK_SET );
|
|
|
|
while( 1 )
|
|
{
|
|
if(VFS_Read(f, &topdelta, 1) != 1) goto img_trunc;
|
|
if( topdelta == 255 ) break;
|
|
if(VFS_Read(f, &length, 1) != 1) goto img_trunc;
|
|
if(VFS_Read(f, &post, 1) != 1) goto img_trunc;
|
|
|
|
for( row_loop = 0; row_loop < length; row_loop++ )
|
|
{
|
|
if(VFS_Read(f, &post, 1) != 1) goto img_trunc;
|
|
if(row_loop + topdelta < image.height)
|
|
Data[(row_loop + topdelta) * image.width + column_loop] = post;
|
|
}
|
|
VFS_Read( f, &post, 1 );
|
|
}
|
|
VFS_Seek( f, pointer_position, SEEK_SET );
|
|
}
|
|
VFS_Close( f );
|
|
|
|
// swap colors in image, and check for transparency
|
|
for( i = 0; i < image.width * image.height; i++ )
|
|
{
|
|
if( Data[i] == 247 )
|
|
{
|
|
Data[i] = 255;
|
|
trans_pixels++;
|
|
}
|
|
else if( Data[i] == 255 ) Data[i] = 247;
|
|
}
|
|
|
|
// yes it's really transparent texture
|
|
// otherwise transparency it's a product of lazy designers (or painters ?)
|
|
if( trans_pixels > TRANS_THRESHOLD ) image.flags |= IMAGE_HAS_ALPHA;
|
|
|
|
image.type = PF_INDEXED_32; // 32-bit palete
|
|
Image_GetPaletteD1();
|
|
|
|
result = FS_AddMipmapToPack( Data, image.width, image.height );
|
|
if( Data ) Mem_Free( Data );
|
|
return result;
|
|
img_trunc:
|
|
VFS_Close( f );
|
|
Mem_Free( Data );
|
|
MsgDev( D_NOTE, "Image_LoadFLAT: probably it's not a .flat image)\n" );
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
============
|
|
Image_LoadLMP
|
|
============
|
|
*/
|
|
qboolean Image_LoadLMP( const char *name, const byte *buffer, size_t filesize )
|
|
{
|
|
lmp_t lmp;
|
|
byte *fin, *pal;
|
|
int rendermode;
|
|
int pixels;
|
|
|
|
if( filesize < sizeof( lmp ))
|
|
{
|
|
MsgDev( D_ERROR, "Image_LoadLMP: file (%s) have invalid size\n", name );
|
|
return false;
|
|
}
|
|
|
|
// greatest hack from valve software (particle palette)
|
|
if( com.stristr( name, "palette.lmp" ))
|
|
return Image_LoadPAL( name, buffer, filesize );
|
|
|
|
// greatest hack from id software
|
|
if( image.hint != IL_HINT_HL && com.stristr( name, "conchars" ))
|
|
{
|
|
image.width = image.height = 128;
|
|
image.flags |= IMAGE_HAS_ALPHA;
|
|
rendermode = LUMP_QFONT;
|
|
filesize += sizeof(lmp);
|
|
fin = (byte *)buffer;
|
|
}
|
|
else
|
|
{
|
|
fin = (byte *)buffer;
|
|
Mem_Copy( &lmp, fin, sizeof( lmp ));
|
|
image.width = lmp.width;
|
|
image.height = lmp.height;
|
|
rendermode = LUMP_NORMAL;
|
|
fin += sizeof(lmp);
|
|
}
|
|
pixels = image.width * image.height;
|
|
|
|
if( filesize < sizeof( lmp ) + pixels )
|
|
{
|
|
MsgDev( D_ERROR, "Image_LoadLMP: file (%s) have invalid size %d\n", name, filesize );
|
|
return false;
|
|
}
|
|
|
|
if( !Image_ValidSize( name ))
|
|
return false;
|
|
|
|
image.depth = 1;
|
|
|
|
if( image.hint != IL_HINT_Q1 && filesize > (int)sizeof(lmp) + pixels )
|
|
{
|
|
int numcolors;
|
|
|
|
pal = fin + pixels;
|
|
numcolors = *(short *)pal;
|
|
if( numcolors != 256 ) pal = NULL; // corrupted lump ?
|
|
else pal += sizeof( short );
|
|
}
|
|
else if( image.hint != IL_HINT_HL ) pal = NULL;
|
|
else return false; // unknown mode rejected
|
|
if( fin[0] == 255 ) image.flags |= IMAGE_HAS_ALPHA;
|
|
|
|
Image_GetPaletteLMP( pal, rendermode );
|
|
image.type = PF_INDEXED_32; // 32-bit palete
|
|
return FS_AddMipmapToPack( fin, image.width, image.height );
|
|
}
|
|
|
|
/*
|
|
=============
|
|
Image_LoadMIP
|
|
=============
|
|
*/
|
|
qboolean Image_LoadMIP( const char *name, const byte *buffer, size_t filesize )
|
|
{
|
|
mip_t mip;
|
|
byte *fin, *pal;
|
|
int ofs[4], rendermode;
|
|
int i, pixels, numcolors;
|
|
|
|
if( filesize < sizeof( mip ))
|
|
{
|
|
MsgDev( D_ERROR, "Image_LoadMIP: file (%s) have invalid size\n", name );
|
|
return false;
|
|
}
|
|
|
|
Mem_Copy( &mip, buffer, sizeof( mip ));
|
|
image.width = mip.width;
|
|
image.height = mip.height;
|
|
|
|
if( !Image_ValidSize( name ))
|
|
return false;
|
|
|
|
Mem_Copy( ofs, mip.offsets, sizeof( ofs ));
|
|
pixels = image.width * image.height;
|
|
image.depth = 1;
|
|
|
|
if( image.hint != IL_HINT_Q1 && filesize >= (int)sizeof(mip) + ((pixels * 85)>>6) + sizeof(short) + 768)
|
|
{
|
|
// half-life 1.0.0.1 mip version with palette
|
|
fin = (byte *)buffer + mip.offsets[0];
|
|
pal = (byte *)buffer + mip.offsets[0] + (((image.width * image.height) * 85)>>6);
|
|
numcolors = *(short *)pal;
|
|
if( numcolors != 256 ) pal = NULL; // corrupted mip ?
|
|
else pal += sizeof( short ); // skip colorsize
|
|
|
|
// detect rendermode
|
|
if( com.strrchr( name, '{' ))
|
|
{
|
|
color24 *col = (color24 *)pal;
|
|
|
|
// check for grayscale palette
|
|
for( i = 0; i < 255; i++, col++ )
|
|
{
|
|
if( col->r != col->g || col->g != col->b )
|
|
break;
|
|
}
|
|
|
|
if( i != 255 )
|
|
{
|
|
rendermode = LUMP_TRANSPARENT;
|
|
|
|
// make transparent color is black, blue color looks ugly
|
|
if( Sys.app_name == HOST_NORMAL )
|
|
pal[255*3+0] = pal[255*3+1] = pal[255*3+2] = 0;
|
|
}
|
|
else
|
|
{
|
|
// apply decal palette immediately
|
|
image.flags |= IMAGE_COLORINDEX;
|
|
if( Sys.app_name == HOST_NORMAL )
|
|
rendermode = LUMP_DECAL;
|
|
else rendermode = LUMP_TRANSPARENT;
|
|
}
|
|
image.flags |= IMAGE_HAS_ALPHA;
|
|
}
|
|
else
|
|
{
|
|
int pal_type;
|
|
|
|
// NOTE: we can have luma-pixels if quake1/2 texture
|
|
// converted into the hl texture but palette leave unchanged
|
|
// this is a good reason for using fullbright pixels
|
|
pal_type = Image_ComparePalette( pal );
|
|
|
|
// check for luma pixels
|
|
switch( pal_type )
|
|
{
|
|
case PAL_QUAKE1:
|
|
for( i = 0; i < image.width * image.height; i++ )
|
|
{
|
|
if( fin[i] > 224 )
|
|
{
|
|
image.flags |= IMAGE_HAS_LUMA_Q1;
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
case PAL_QUAKE2:
|
|
for( i = 0; i < image.width * image.height; i++ )
|
|
{
|
|
if( fin[i] > 208 && fin[i] < 240 )
|
|
{
|
|
image.flags |= IMAGE_HAS_LUMA_Q2;
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
rendermode = LUMP_NORMAL;
|
|
}
|
|
}
|
|
else if( image.hint != IL_HINT_HL && filesize >= (int)sizeof(mip) + ((pixels * 85)>>6))
|
|
{
|
|
// quake1 1.01 mip version without palette
|
|
fin = (byte *)buffer + mip.offsets[0];
|
|
pal = NULL; // clear palette
|
|
rendermode = LUMP_NORMAL;
|
|
|
|
// check for luma pixels
|
|
for( i = 0; i < image.width * image.height; i++ )
|
|
{
|
|
if( fin[i] > 224 )
|
|
{
|
|
image.flags |= IMAGE_HAS_LUMA_Q1;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if( image.hint == IL_HINT_NO )
|
|
MsgDev( D_ERROR, "Image_LoadMIP: lump (%s) is corrupted\n", name );
|
|
return false; // unknown or unsupported mode rejected
|
|
}
|
|
|
|
Image_GetPaletteLMP( pal, rendermode );
|
|
image.type = PF_INDEXED_32; // 32-bit palete
|
|
return FS_AddMipmapToPack( fin, image.width, image.height );
|
|
} |