FWGS
/
Xash3DArchive
Archived
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

20 Dec 2007

This commit is contained in:
g-cont 2007-12-20 00:00:00 +03:00 committed by Alibek Omarov
parent 7d6989a167
commit bf912f84f4
6 changed files with 2529 additions and 336 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
changelog.log
View File

@ -10,6 +10,19 @@ SV_Move SV_Trace
SV_ClipMoveToEntity CM_BoxTrace SV_ClipMoveToEntity CM_BoxTrace
SV_ClipToLinks SV_ClipMoveToEntities SV_ClipToLinks SV_ClipMoveToEntities
case TYPE_Q1MIP:
if(FS_Seek(w->file, w->lumps[i].filepos - w->lumps[i].size, SEEK_SET))
{
MsgDev(D_ERROR, "FS_OpenWad3File: corrupt WAD3 file\n");
return NULL;
}
default:
if(FS_Seek(w->file, w->lumps[i].filepos, SEEK_SET))
{
MsgDev(D_ERROR, "FS_OpenWad3File: corrupt WAD3 file\n");
return NULL;
}
studioframeadvance studioframeadvance
studiorewindframe studiorewindframe

89
launch/common/filesystem.c
View File

@ -75,6 +75,7 @@ typedef struct wadfile_s
{ {
char name[64]; char name[64];
int numlumps; int numlumps;
int type; // contains ident
file_t *file; file_t *file;
dlumpinfo_t *lumps; dlumpinfo_t *lumps;
} wadfile_t; } wadfile_t;
@ -981,6 +982,7 @@ static bool FS_AddWad3File( const char *filename )
int infotableofs; int infotableofs;
file_t *file; file_t *file;
int i, numlumps; int i, numlumps;
char type[16];
if(!fs_searchwads) // start from scratch if(!fs_searchwads) // start from scratch
fs_searchwads = Mem_CreateArray( fs_mempool, sizeof(wadfile_t), 16 ); fs_searchwads = Mem_CreateArray( fs_mempool, sizeof(wadfile_t), 16 );
@ -1005,12 +1007,20 @@ static bool FS_AddWad3File( const char *filename )
FS_Close( file ); FS_Close( file );
return false; return false;
} }
if( header.ident != IDWAD2HEADER && header.ident != IDWAD3HEADER )
switch( header.ident )
{ {
case IDWAD2HEADER:
com_strncpy( type, "Quake1", 16 );
break;
case IDWAD3HEADER:
com_strncpy( type, "Half-Life", 16 );
break;
default:
MsgDev(D_ERROR, "FS_AddWad3File: %s have invalid ident\n", filename ); MsgDev(D_ERROR, "FS_AddWad3File: %s have invalid ident\n", filename );
FS_Close( file ); FS_Close( file );
return false; return false;
} }
numlumps = LittleLong( header.numlumps ); numlumps = LittleLong( header.numlumps );
if( numlumps > MAX_FILES_IN_PACK ) if( numlumps > MAX_FILES_IN_PACK )
@ -1031,6 +1041,7 @@ static bool FS_AddWad3File( const char *filename )
w = Mem_AllocElement( fs_searchwads ); w = Mem_AllocElement( fs_searchwads );
com_strncpy( w->name, filename, sizeof(w->name)); com_strncpy( w->name, filename, sizeof(w->name));
w->file = file; w->file = file;
w->type = header.ident;
w->numlumps = numlumps; w->numlumps = numlumps;
w->lumps = Mem_Alloc( fs_mempool, w->numlumps * sizeof(dlumpinfo_t)); w->lumps = Mem_Alloc( fs_mempool, w->numlumps * sizeof(dlumpinfo_t));
@ -1054,7 +1065,7 @@ static bool FS_AddWad3File( const char *filename )
com_strnlwr(w->lumps[i].name, w->lumps[i].name, sizeof(w->lumps[i].name)); com_strnlwr(w->lumps[i].name, w->lumps[i].name, sizeof(w->lumps[i].name));
} }
// and leaves the file open // and leaves the file open
MsgDev(D_INFO, "Adding wadfile: %s (%i lumps)\n", filename, numlumps ); MsgDev(D_INFO, "Adding %s wadfile: %s (%i lumps)\n", type, filename, numlumps );
return true; return true;
} }
@ -1766,7 +1777,7 @@ FS_OpenWad3File
Look for a file in the loaded wadfiles and returns buffer with image lump Look for a file in the loaded wadfiles and returns buffer with image lump
=========== ===========
*/ */
static byte *FS_OpenWad3File( const char *name, fs_offset_t *filesizeptr, int matchtype ) static byte *FS_OpenWadFile( const char *name, fs_offset_t *filesizeptr, int matchtype )
{ {
uint i, k; uint i, k;
wadfile_t *w; wadfile_t *w;
@ -1797,49 +1808,22 @@ static byte *FS_OpenWad3File( const char *name, fs_offset_t *filesizeptr, int ma
{ {
if(!com_strcmp(texname, w->lumps[i].name)) if(!com_strcmp(texname, w->lumps[i].name))
{ {
mip_t *tex;
lmp_t *lmp;
qpic_t *pic;
qfont_t *fnt;
fs_offset_t size;
byte *buf; byte *buf;
size_t size;
if(matchtype != (int)w->lumps[i].type) break; // try next wad if(matchtype != (int)w->lumps[i].type) return NULL; // try next type
if(FS_Seek(w->file, w->lumps[i].filepos, SEEK_SET)) if(FS_Seek(w->file, w->lumps[i].filepos, SEEK_SET))
{ {
MsgDev(D_ERROR, "FS_OpenWad3File: corrupt WAD3 file\n"); MsgDev(D_ERROR, "FS_OpenWadFile: %s probably corrupted\n", texname );
return NULL; return NULL;
} }
switch((int)w->lumps[i].type) buf = (byte *)Mem_Alloc( fs_mempool, w->lumps[i].disksize );
{ size = FS_Read(w->file, buf, w->lumps[i].disksize );
case TYPE_QPIC:
pic = (qpic_t *)Mem_Alloc( fs_mempool, w->lumps[i].disksize );
size = FS_Read(w->file, pic, w->lumps[i].size );
buf = (byte *)((qpic_t *)pic);
break;
case TYPE_QFONT:
fnt = (qfont_t *)Mem_Alloc( fs_mempool, w->lumps[i].disksize );
size = FS_Read(w->file, fnt, w->lumps[i].disksize ); // some gfx.wad requires this
buf = (byte *)((qfont_t *)fnt);
break;
case TYPE_Q1MIP:
if(!com_stricmp( w->lumps[i].name, "conchars" ))
{
// great hack from id software
FS_Seek(w->file, w->lumps[i].filepos - w->lumps[i].size, SEEK_SET);
}
lmp = (lmp_t *)Mem_Alloc( fs_mempool, w->lumps[i].disksize );
size = FS_Read(w->file, lmp, w->lumps[i].size );
buf = (byte *)((lmp_t *)lmp);
case TYPE_HLMIP:
tex = (mip_t *)Mem_Alloc( fs_mempool, w->lumps[i].disksize );
size = FS_Read(w->file, tex, w->lumps[i].size );
buf = (byte *)((mip_t *)tex);
break;
}
if( size < w->lumps[i].disksize ) if( size < w->lumps[i].disksize )
MsgDev(D_WARN, "FS_OpenWad3File: lump %s is corrupt\n", texname ); {
MsgDev(D_WARN, "FS_OpenWadFile: lump %s is corrupt\n", texname );
return NULL;
}
if(filesizeptr) *filesizeptr = w->lumps[i].disksize; if(filesizeptr) *filesizeptr = w->lumps[i].disksize;
return buf; return buf;
} }
@ -2377,27 +2361,28 @@ byte *FS_LoadFile (const char *path, fs_offset_t *filesizeptr )
FS_Read (file, buf, filesize); FS_Read (file, buf, filesize);
FS_Close (file); FS_Close (file);
} }
else if(!com_stricmp("wad3", ext )) else if(!com_stricmp("mip", ext ))
{ {
// probably it's half-life texture // mip-texture form quake1 or half-life
buf = FS_OpenWad3File( path, &filesize, TYPE_HLMIP ); buf = FS_OpenWadFile( path, &filesize, TYPE_MIPTEX );
if(!buf) buf = FS_OpenWadFile( path, &filesize, TYPE_MIPTEX2 );
} }
else if(!com_stricmp("lmp", ext )) else if(!com_stricmp("lmp", ext ))
{ {
// probably it's quake1 texture // qpic from quake1 or half-life
buf = FS_OpenWad3File( path, &filesize, TYPE_Q1MIP ); buf = FS_OpenWadFile( path, &filesize, TYPE_QPIC );
} }
else if(!com_stricmp("qpic", ext )) else if(!com_stricmp("fnt", ext ))
{ {
// probably it's gfx image (q1 or hl) // half-life qfont lump
buf = FS_OpenWad3File( path, &filesize, TYPE_QPIC ); buf = FS_OpenWadFile( path, &filesize, TYPE_QFONT );
} }
else if(!com_stricmp("qfnt", ext )) else if(!com_stricmp("pal", ext ))
{ {
// probably it's image from wad-file // quake1 palette lump
buf = FS_OpenWad3File( path, &filesize, TYPE_QFONT ); buf = FS_OpenWadFile( path, &filesize, TYPE_QPAL );
} }
if(filesizeptr) *filesizeptr = filesize; if(filesizeptr) *filesizeptr = filesize;
return buf; return buf;
} }

3
launch/common/image.h
View File

@ -98,9 +98,6 @@ extern uint image_ptr; // common moveable pointer
// image lib utilites // image lib utilites
extern uint *d_currentpal; extern uint *d_currentpal;
void Image_GetQ1Palette( void );
void Image_GetQ2Palette( void );
void Image_GetPalettePCX( byte *pal );
bool Image_Copy8bitRGBA(const byte *in, byte *out, int pixels); bool Image_Copy8bitRGBA(const byte *in, byte *out, int pixels);
void Image_RoundDimensions(int *scaled_width, int *scaled_height); void Image_RoundDimensions(int *scaled_width, int *scaled_height);
byte *Image_Resample(uint *in, int inwidth, int inheight, int outwidth, int outheight, int in_type); byte *Image_Resample(uint *in, int inwidth, int inheight, int outwidth, int outheight, int in_type);

490
launch/common/imglib.c
View File

@ -60,13 +60,13 @@ bool Image_ValidSize( char *name )
{ {
if(image_width > 4096 || image_height > 4096 || image_width <= 0 || image_height <= 0) if(image_width > 4096 || image_height > 4096 || image_width <= 0 || image_height <= 0)
{ {
MsgWarn( "Image_ValidSize: (%s) image size out of range [%dx%d]\n", name, image_width, image_height ); MsgWarn( "Image_ValidSize: (%s) dimensions out of range [%dx%d]\n", name, image_width, image_height );
return false; return false;
} }
return true; return true;
} }
void Image_GetPalette( byte *pal, uint *d_table ) void Image_SetPalette( byte *pal, uint *d_table )
{ {
int i; int i;
byte rgba[4]; byte rgba[4];
@ -117,39 +117,39 @@ void Image_GetPalette( byte *pal, uint *d_table )
} }
} }
void Image_GetD1Palette( void ) void Image_GetPaletteD1( void )
{ {
d_rendermode = LUMP_NORMAL; d_rendermode = LUMP_NORMAL;
if(!d1palette_init) if(!d1palette_init)
{ {
Image_GetPalette( palette_d1, d_8toD1table ); Image_SetPalette( palette_d1, d_8toD1table );
d_8toD1table[255] = 247; // 247 is transparent d_8toD1table[255] = 247; // 247 is transparent
d1palette_init = true; d1palette_init = true;
} }
d_currentpal = d_8toD1table; d_currentpal = d_8toD1table;
} }
void Image_GetQ1Palette( void ) void Image_GetPaletteQ1( void )
{ {
d_rendermode = LUMP_NORMAL; d_rendermode = LUMP_NORMAL;
if(!q1palette_init) if(!q1palette_init)
{ {
Image_GetPalette( palette_q1, d_8toQ1table ); Image_SetPalette( palette_q1, d_8toQ1table );
d_8toQ1table[255] = 0; // 255 is transparent d_8toQ1table[255] = 0; // 255 is transparent
q1palette_init = true; q1palette_init = true;
} }
d_currentpal = d_8toQ1table; d_currentpal = d_8toQ1table;
} }
void Image_GetQ2Palette( void ) void Image_GetPaletteQ2( void )
{ {
d_rendermode = LUMP_NORMAL; d_rendermode = LUMP_NORMAL;
if(!q2palette_init) if(!q2palette_init)
{ {
Image_GetPalette( palette_q2, d_8toQ2table ); Image_SetPalette( palette_q2, d_8toQ2table );
d_8toQ2table[255] &= LittleLong(0xffffff); d_8toQ2table[255] &= LittleLong(0xffffff);
q2palette_init = true; q2palette_init = true;
} }
@ -162,39 +162,38 @@ void Image_GetPalettePCX( byte *pal )
if(pal) if(pal)
{ {
Image_GetPalette( pal, d_8to24table ); Image_SetPalette( pal, d_8to24table );
d_8to24table[255] &= LittleLong(0xffffff); d_8to24table[255] &= LittleLong(0xffffff);
d_currentpal = d_8to24table; d_currentpal = d_8to24table;
} }
else Image_GetQ2Palette(); else Image_GetPaletteQ2();
} }
void Image_GetPaletteWAD( byte *pal, int rendermode ) void Image_GetPaletteLMP( byte *pal, int rendermode )
{ {
d_rendermode = rendermode; d_rendermode = rendermode;
if( pal ) if( pal )
{ {
Image_GetPalette( pal, d_8to24table ); Image_SetPalette( pal, d_8to24table );
d_8to24table[255] &= LittleLong(0xffffff); d_8to24table[255] &= LittleLong(0xffffff);
d_currentpal = d_8to24table; d_currentpal = d_8to24table;
} }
else if(rendermode == LUMP_QFONT) else if(rendermode == LUMP_QFONT)
{ {
// quake1 base palette and font palette have some diferences // quake1 base palette and font palette have some diferences
Image_GetPalette( palette_q1, d_8to24table ); Image_SetPalette( palette_q1, d_8to24table );
d_8to24table[0] = 0; d_8to24table[0] = 0;
d_currentpal = d_8to24table; d_currentpal = d_8to24table;
} }
else Image_GetQ1Palette(); else Image_GetPaletteQ1(); // default quake palette
} }
/* /*
============ ============
Image_Copy8bitRGBA Image_Copy8bitRGBA
NOTE: must call Image_GetQ2Palette or Image_GetQ1Palette NOTE: must call Image_GetPaletteXXX before used
before used
============ ============
*/ */
bool Image_Copy8bitRGBA(const byte *in, byte *out, int pixels) bool Image_Copy8bitRGBA(const byte *in, byte *out, int pixels)
@ -206,6 +205,11 @@ bool Image_Copy8bitRGBA(const byte *in, byte *out, int pixels)
MsgDev(D_ERROR,"Image_Copy8bitRGBA: no palette set\n"); MsgDev(D_ERROR,"Image_Copy8bitRGBA: no palette set\n");
return false; return false;
} }
if(!in)
{
MsgDev(D_ERROR,"Image_Copy8bitRGBA: no input image\n");
return false;
}
while (pixels >= 8) while (pixels >= 8)
{ {
@ -237,7 +241,7 @@ bool Image_Copy8bitRGBA(const byte *in, byte *out, int pixels)
in += 2; in += 2;
iout += 2; iout += 2;
} }
if (pixels & 1) if (pixels & 1) // last byte
iout[0] = d_currentpal[in[0]]; iout[0] = d_currentpal[in[0]];
return true; return true;
@ -346,211 +350,24 @@ bool Image_Processing( const char *name, rgbdata_t **pix )
return false; return false;
} }
/*
==============
LoadWAL
==============
*/
bool LoadWAL( char *name, char *buffer, int filesize )
{
wal_t wal;
int pixels, ofs[4], mipsize;// FIXME, adding four mips ?
int i, flags, value, contents; // wal additional parms
if (filesize < (int)sizeof(wal))
{
MsgWarn("LoadWAL: file (%s) have invalid size\n", name );
return false;
}
Mem_Copy(&wal, buffer, sizeof(wal));
flags = LittleLong(wal.flags);
value = LittleLong(wal.value);
contents = LittleLong(wal.contents);
image_width = LittleLong(wal.width);
image_height = LittleLong(wal.height);
for(i = 0; i < 4; i++) ofs[i] = LittleLong(wal.offsets[i]);
if(!Image_ValidSize( 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.
MsgWarn("LoadWAL: file (%s) have invalid size\n", name );
return false;
}
image_num_layers = 1;
image_type = PF_RGBA_32;
Image_GetQ2Palette(); // hardcoded
return FS_AddMipmapToPack( buffer + ofs[0], image_width, image_height );
}
/* /*
============ ============
LoadLMP LoadPAL
============ ============
*/ */
bool LoadLMP( char *name, char *buffer, int filesize ) bool LoadPAL( char *name, char *buffer, int filesize )
{ {
lmp_t lmp; if( filesize != 768 )
byte *fin, *pal;
int i, pixels;
int rendermode;
if (filesize < (int)sizeof(lmp))
{ {
MsgWarn("LoadLMP: file (%s) have invalid size\n", name ); MsgWarn("LoadPAL: file (%s) have invalid size\n", name );
return false; return false;
} }
fin = buffer;
// great hack from id software
if(!com_stricmp( name, "conchars" ))
{
image_width = image_height = 128;
pixels = image_width * image_height;
image_flags |= IMAGE_HAS_ALPHA;
rendermode = LUMP_QFONT;
}
else
{
Mem_Copy(&lmp, fin, sizeof(lmp));
image_width = LittleLong(lmp.width);
image_height = LittleLong(lmp.height);
fin += sizeof(lmp);
pixels = image_width * image_height;
if (filesize < (int)sizeof(lmp) + pixels)
{
MsgWarn("LoadLMP: file (%s) have invalid size %d\n", name, filesize );
return false;
}
rendermode = LUMP_NORMAL;
}
if(!Image_ValidSize( name )) return false;
image_size = pixels * 4;
image_num_mips = 1;
image_rgba = (byte *)Mem_Alloc(Sys.imagepool, image_size );
image_num_layers = 1;
image_type = PF_RGBA_32;
// try to find transparent pixels
for(i = 0; i < pixels; i++)
{
if(fin[i] != 255) continue;
image_flags |= IMAGE_HAS_ALPHA;
rendermode = LUMP_TRANSPARENT;
break; // found
}
// half-life 1.0.0.1 lmp version with palette
if( filesize == (int)sizeof(lmp) + pixels + sizeof(short) + 768)
{
int numcolors;
pal = fin + pixels;
numcolors = BuffLittleShort( pal ), pal += 2;
if( numcolors != 256 ) pal = NULL; // corrupted lump ?
}
else pal = NULL;
Image_GetPaletteWAD( pal, rendermode );
Image_Copy8bitRGBA( fin, image_rgba, pixels );
// not a real image, just palette lump
Image_GetPaletteLMP( buffer, LUMP_NORMAL );
return true; return true;
} }
/*
============
LoadMIP
============
*/
bool LoadMIP( char *name, char *buffer, int filesize )
{
mip_t mip;
int i, ofs[4], mipsize;
if (filesize < (int)sizeof(mip))
{
MsgWarn("LoadMIP: file (%s) have invalid size\n", name );
return false;
}
Mem_Copy(&mip, buffer, sizeof(mip));
image_width = LittleLong(mip.width);
image_height = LittleLong(mip.height);
for(i = 0; i < 4; i++) ofs[i] = LittleLong(mip.offsets[i]);
if(!Image_ValidSize( name )) return false;
mipsize = image_width * image_height;
if (filesize < (int)sizeof(mip) + mipsize)
{
MsgWarn("LoadMIP: file (%s) have invalid size\n", name );
return false;
}
image_num_layers = 1;
image_type = PF_RGBA_32;
Image_GetQ1Palette();// hardcoded
return FS_AddMipmapToPack( buffer + ofs[0], image_width, image_height );
}
/*
============
LoadPIC
============
*/
bool LoadPIC( char *name, char *buffer, int filesize )
{
qpic_t pic;
byte *pal, *fin;
int numcolors;
int pixels;
if(filesize < (int)sizeof(pic))
{
MsgWarn("LoadPIC: file (%s) have invalid size\n", name );
return false;
}
Mem_Copy(&pic, buffer, sizeof(pic));
image_width = LittleShort(pic.width);
image_height = LittleShort(pic.height);
if(!Image_ValidSize( name )) return false;
pixels = image_width * image_height;
fin = buffer + sizeof(pic) - 4;
image_num_layers = 1;
image_type = PF_RGBA_32;
// half-life qlmpy version with palette
if( filesize == (int)sizeof(pic) - 2 + pixels + sizeof(short) + 768)
{
pal = fin + pixels;
numcolors = BuffLittleShort(pal);
if(numcolors != 256)
{
MsgWarn("LoadPIC: file (%s) have invalid palette size %d\n", name, numcolors );
return false;
}
pal += 2; // skip colorsize
}
else pal = NULL; // quake1 pic
if(fin[0] == 255) image_flags |= IMAGE_HAS_ALPHA;
Image_GetPaletteWAD( pal, LUMP_NORMAL );
return FS_AddMipmapToPack( fin, image_width, image_height );
}
bool LoadTEST( char *name, char *buffer, int filesize )
{
return false;
}
/* /*
============ ============
LoadFNT LoadFNT
@ -586,50 +403,159 @@ bool LoadFNT( char *name, char *buffer, int filesize )
if( fullsize != filesize ) if( fullsize != filesize )
{ {
// probably it's "creditsfont" or "conchars" // oldstyle font: "conchars" or "creditsfont"
MsgWarn("LoadFNT: (%s) it's not a qfont_t structure\n", name ); image_width = 256; // hardcoded
return LoadTEST( name, buffer, filesize ); 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;
} }
// setup font dimensions
image_width = font.width * QCHAR_WIDTH;
image_height = font.height;
image_num_layers = 1; image_num_layers = 1;
image_type = PF_RGBA_32; image_type = PF_RGBA_32;
if(!Image_ValidSize( name )) return false; if(!Image_ValidSize( name )) return false;
fin = buffer + sizeof(font) - 4;
pixels = ( image_width * image_height ); pixels = ( image_width * image_height );
fin = buffer + sizeof(font) - 4, pal = fin + pixels; pal = fin + pixels;
numcolors = BuffLittleShort( pal ), pal += 2; numcolors = BuffLittleShort( pal ), pal += sizeof(short);
image_flags |= IMAGE_HAS_ALPHA; // fonts always have transparency image_flags |= IMAGE_HAS_ALPHA; // fonts always have transparency
if(numcolors != 768) if( numcolors == 768 )
{
// newstyle font
Image_GetPaletteLMP( pal, LUMP_QFONT );
}
else if( numcolors == 256 )
{
// oldstyle font
Image_GetPaletteLMP( pal, LUMP_TRANSPARENT );
}
else
{ {
MsgWarn("LoadFNT: file (%s) have invalid palette size %d\n", name, numcolors ); MsgWarn("LoadFNT: file (%s) have invalid palette size %d\n", name, numcolors );
return false; return false;
} }
// FIXME: convert this to quake-style conchars ? // FIXME: convert this to quake-style conchars ?
Image_GetPaletteWAD( pal, LUMP_QFONT );
return FS_AddMipmapToPack( fin, image_width, image_height ); return FS_AddMipmapToPack( fin, image_width, image_height );
} }
/*
==============
LoadWAL
==============
*/
bool LoadWAL( char *name, char *buffer, int filesize )
{
wal_t wal;
int pixels, ofs[4], mipsize;
int i, flags, value, contents; // wal additional parms
if (filesize < (int)sizeof(wal))
{
MsgWarn("LoadWAL: file (%s) have invalid size\n", name );
return false;
}
Mem_Copy(&wal, buffer, sizeof(wal));
flags = LittleLong(wal.flags);
value = LittleLong(wal.value);
contents = LittleLong(wal.contents);
image_width = LittleLong(wal.width);
image_height = LittleLong(wal.height);
for(i = 0; i < 4; i++) ofs[i] = LittleLong(wal.offsets[i]);
if(!Image_ValidSize( 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.
MsgWarn("LoadWAL: file (%s) have invalid size\n", name );
return false;
}
image_num_layers = 1;
image_type = PF_RGBA_32;
Image_GetPaletteQ2(); // hardcoded
return FS_AddMipmapToPack( buffer + ofs[0], image_width, image_height );
}
/* /*
============ ============
LoadWAD LoadLMP
============ ============
*/ */
bool LoadWAD( char *name, char *buffer, int filesize ) bool LoadLMP( char *name, char *buffer, int filesize )
{
lmp_t lmp;
byte *fin, *pal;
int pixels;
if (filesize < (int)sizeof(lmp))
{
MsgWarn("LoadLMP: file (%s) have invalid size\n", name );
return false;
}
fin = buffer;
Mem_Copy(&lmp, fin, sizeof(lmp));
image_width = LittleLong(lmp.width);
image_height = LittleLong(lmp.height);
fin += sizeof(lmp);
pixels = image_width * image_height;
if (filesize < (int)sizeof(lmp) + pixels)
{
MsgWarn("LoadLMP: file (%s) have invalid size %d\n", name, filesize );
return false;
}
if(!Image_ValidSize( name )) return false;
image_size = pixels * 4;
image_num_mips = 1;
image_rgba = (byte *)Mem_Alloc(Sys.imagepool, image_size );
image_num_layers = 1;
image_type = PF_RGBA_32;
// half-life 1.0.0.1 lmp version with palette
if( filesize > (int)sizeof(lmp) + pixels )
{
int numcolors;
pal = fin + pixels;
numcolors = BuffLittleShort( pal );
if( numcolors != 256 ) pal = NULL; // corrupted lump ?
else pal += sizeof(short);
}
else pal = NULL;
if(fin[0] == 255) image_flags |= IMAGE_HAS_ALPHA;
Image_GetPaletteLMP( pal, LUMP_NORMAL );
Image_Copy8bitRGBA( fin, image_rgba, pixels );
return true;
}
/*
============
LoadMIP
============
*/
bool LoadMIP( char *name, char *buffer, int filesize )
{ {
mip_t mip; mip_t mip;
byte *pal; byte *fin, *pal;
int ofs[4], rendermode; int ofs[4], rendermode;
int i, numcolors; int i, pixels, numcolors;
if (filesize < (int)sizeof(mip)) if (filesize < (int)sizeof(mip))
{ {
MsgWarn("LoadWAD_3: file (%s) have invalid size\n", name ); MsgWarn("LoadMIP: file (%s) have invalid size\n", name );
return false; return false;
} }
@ -637,39 +563,61 @@ bool LoadWAD( char *name, char *buffer, int filesize )
image_width = LittleLong(mip.width); image_width = LittleLong(mip.width);
image_height = LittleLong(mip.height); image_height = LittleLong(mip.height);
for(i = 0; i < 4; i++) ofs[i] = LittleLong(mip.offsets[i]); for(i = 0; i < 4; i++) ofs[i] = LittleLong(mip.offsets[i]);
if(!Image_ValidSize( name )) return false; pixels = image_width * image_height;
pal = buffer + mip.offsets[0] + (((image_width * image_height) * 85)>>6);
numcolors = BuffLittleShort( pal ), pal += 2; // skip colorsize
if(numcolors != 256)
{
MsgWarn("LoadWAD_3: file (%s) have invalid palette size %d\n", name, numcolors );
return false;
}
image_num_layers = 1; image_num_layers = 1;
image_type = PF_RGBA_32; // always exctracted to 32-bit buffer image_type = PF_RGBA_32;
// detect rendermode if(!com_stricmp( name, "conchars" ))
if( name[0] == '{' )
{ {
// note: i trying determine transparent miptex by last color in palette // greatest hack from id software
// e.g. valve used in their textures blue color (0,0,255) image_width = image_height = 128;
// other cases for red (255,0,0) ang green (0,255,0) colors,
// otherwise - it will use decal palette with ugly results. ughgrrr..
if(pal[255*3+0] == 0 && pal[255*3+1] == 0 && pal[255*3+2] == 255 && pal[255*3+3] == 0)
rendermode = LUMP_TRANSPARENT;
else if(pal[255*3+0] == 0 && pal[255*3+1] == 255 && pal[255*3+2] == 0 && pal[255*3+3] == 0)
rendermode = LUMP_TRANSPARENT;
else if(pal[255*3+0] == 255 && pal[255*3+1] == 0 && pal[255*3+2] == 0 && pal[255*3+3] == 0)
rendermode = LUMP_TRANSPARENT;
else rendermode = LUMP_DECAL;
image_flags |= IMAGE_HAS_ALPHA; image_flags |= IMAGE_HAS_ALPHA;
rendermode = LUMP_QFONT;
pal = NULL; // clear palette
fin = buffer;
} }
else rendermode = LUMP_NORMAL; else if(filesize >= (int)sizeof(mip) + ((pixels * 85)>>6) + sizeof(short) + 768)
Image_GetPaletteWAD( pal, rendermode ); {
return FS_AddMipmapToPack( buffer + mip.offsets[0], image_width, image_height ); // half-life 1.0.0.1 mip version with palette
fin = buffer + mip.offsets[0];
pal = buffer + mip.offsets[0] + (((image_width * image_height) * 85)>>6);
numcolors = BuffLittleShort( pal );
if(numcolors != 256) pal = NULL; // corrupted mip ?
else pal += sizeof(short); // skip colorsize
// detect rendermode
if( name[0] == '{' )
{
// note: i trying determine transparent miptex by last color in palette
// e.g. valve used in their textures blue color (0,0,255)
// other cases for red (255,0,0) ang green (0,255,0) colors,
// otherwise - it will use decal palette with ugly results. ughgrrr..
if(pal[255*3+0] == 0 && pal[255*3+1] == 0 && pal[255*3+2] == 255 && pal[255*3+3] == 0)
rendermode = LUMP_TRANSPARENT;
else if(pal[255*3+0] == 0 && pal[255*3+1] == 255 && pal[255*3+2] == 0 && pal[255*3+3] == 0)
rendermode = LUMP_TRANSPARENT;
else if(pal[255*3+0] == 255 && pal[255*3+1] == 0 && pal[255*3+2] == 0 && pal[255*3+3] == 0)
rendermode = LUMP_TRANSPARENT;
else rendermode = LUMP_DECAL;
image_flags |= IMAGE_HAS_ALPHA;
}
else rendermode = LUMP_NORMAL;
}
else if(filesize >= (int)sizeof(mip) + ((pixels * 85)>>6))
{
// quake1 1.01 mip version without palette
pal = NULL; // clear palette
rendermode = LUMP_NORMAL;
fin = buffer + mip.offsets[0];
}
else
{
MsgWarn("LoadMIP: lump (%s) is corrupted\n", name );
return false;
}
if(!Image_ValidSize( name )) return false;
Image_GetPaletteLMP( pal, rendermode );
return FS_AddMipmapToPack( fin, image_width, image_height );
} }
/* /*
@ -1889,23 +1837,21 @@ loadformat_t load_formats[] =
{"textures/%s%s.%s", "dds", LoadDDS}, {"textures/%s%s.%s", "dds", LoadDDS},
{"textures/%s%s.%s", "tga", LoadTGA}, {"textures/%s%s.%s", "tga", LoadTGA},
{"textures/%s%s.%s", "jpg", LoadJPG}, {"textures/%s%s.%s", "jpg", LoadJPG},
{"textures/%s%s.%s", "wad3",LoadWAD},
{"textures/%s%s.%s", "qpic",LoadPIC},
{"textures/%s%s.%s", "pcx", LoadPCX},
{"textures/%s%s.%s", "wal", LoadWAL},
{"textures/%s%s.%s", "lmp", LoadLMP},
{"textures/%s%s.%s", "mip", LoadMIP}, {"textures/%s%s.%s", "mip", LoadMIP},
{"textures/%s%s.%s", "qfnt",LoadFNT}, {"textures/%s%s.%s", "wal", LoadWAL},
{"textures/%s%s.%s", "pcx", LoadPCX},
{"textures/%s%s.%s", "lmp", LoadLMP},
{"textures/%s%s.%s", "fnt", LoadFNT},
{"textures/%s%s.%s", "pal", LoadPAL},
{"%s%s.%s", "dds", LoadDDS}, {"%s%s.%s", "dds", LoadDDS},
{"%s%s.%s", "tga", LoadTGA}, {"%s%s.%s", "tga", LoadTGA},
{"%s%s.%s", "jpg", LoadJPG}, {"%s%s.%s", "jpg", LoadJPG},
{"%s%s.%s", "wad3",LoadWAD},
{"%s%s.%s", "qpic",LoadPIC},
{"%s%s.%s", "pcx", LoadPCX},
{"%s%s.%s", "wal", LoadWAL},
{"%s%s.%s", "lmp", LoadLMP},
{"%s%s.%s", "mip", LoadMIP}, {"%s%s.%s", "mip", LoadMIP},
{"%s%s.%s", "qfnt",LoadFNT}, {"%s%s.%s", "wal", LoadWAL},
{"%s%s.%s", "pcx", LoadPCX},
{"%s%s.%s", "lmp", LoadLMP},
{"%s%s.%s", "fnt", LoadFNT},
{"%s%s.%s", "pal", LoadPAL},
{NULL, NULL} {NULL, NULL}
}; };
@ -2089,12 +2035,12 @@ rgbdata_t *FS_LoadImage(const char *filename, char *buffer, int buffsize )
// this name will be used only for tell user about problems // this name will be used only for tell user about problems
FS_FileBase( loadname, texname ); FS_FileBase( loadname, texname );
if( format->loadfunc(texname, buffer, buffsize )) if( format->loadfunc(texname, buffer, buffsize ))
return ImagePack();// loaded return ImagePack(); // loaded
} }
} }
} }
MsgDev(D_WARN, "couldn't load %s\n", texname ); MsgDev(D_WARN, "FS_LoadImage: couldn't load \"%s\"\n", texname );
return NULL; return NULL;
} }
@ -2140,10 +2086,14 @@ bool SaveTGA( const char *filename, byte *data, int width, int height, bool alph
const byte *bufend, *in; const byte *bufend, *in;
byte *buffer, *out; byte *buffer, *out;
const char *comment = "Generated by Xash ImageLib\0"; const char *comment = "Generated by Xash ImageLib\0";
char mergedname[MAX_SYSPATH];
if(alpha) outsize = width * height * 4 + 18 + com_strlen(comment); if(alpha) outsize = width * height * 4 + 18 + com_strlen(comment);
else outsize = width * height * 3 + 18 + com_strlen(comment); else outsize = width * height * 3 + 18 + com_strlen(comment);
com_strncpy(mergedname, filename, MAX_SYSPATH );
if(mergedname[0] == '*') mergedname[0] = '!'; // quake1 issues
buffer = (byte *)Malloc( outsize ); buffer = (byte *)Malloc( outsize );
memset (buffer, 0, 18); memset (buffer, 0, 18);
@ -2199,8 +2149,8 @@ bool SaveTGA( const char *filename, byte *data, int width, int height, bool alph
} }
} }
MsgDev(D_NOTE, "Writing %s[%d]\n", filename, alpha ? 32 : 24 ); MsgDev(D_NOTE, "Writing %s[%d]\n", mergedname, alpha ? 32 : 24 );
FS_WriteFile (filename, buffer, outsize ); FS_WriteFile( mergedname, buffer, outsize );
Mem_Free( buffer ); Mem_Free( buffer );
return true; return true;

2252
launch/common/imglib.c.old Normal file
View File

File diff suppressed because it is too large Load Diff

18
public/stdref.h
View File

@ -1577,9 +1577,10 @@ typedef struct mip_s
#define IDWAD3HEADER (('3'<<24)+('D'<<16)+('A'<<8)+'W') // little-endian "WAD3" half-life wads #define IDWAD3HEADER (('3'<<24)+('D'<<16)+('A'<<8)+'W') // little-endian "WAD3" half-life wads
#define WAD3_NAMELEN 16 #define WAD3_NAMELEN 16
#define TYPE_QPIC 66 // quake1 and hl pic (qpic_t) #define TYPE_QPAL 64
#define TYPE_HLMIP 67 // half-life textures (mip_t) TYP_SOUND for Quake1, but never used for it #define TYPE_QPIC 66 // quake1 and hl pic (lmp_t)
#define TYPE_Q1MIP 68 // quake1 textures (mip_t) #define TYPE_MIPTEX2 67 // half-life (mip_t) previous TYP_SOUND but never used in quake1
#define TYPE_MIPTEX 68 // quake1 (mip_t)
#define TYPE_QFONT 70 // half-life font (qfont_t) #define TYPE_QFONT 70 // half-life font (qfont_t)
#define QCHAR_WIDTH 16 #define QCHAR_WIDTH 16
@ -1588,11 +1589,12 @@ typedef struct mip_s
typedef struct typedef struct
{ {
int ident; // should be WAD3 int ident; // should be IWAD or WAD2 or WAD3
int numlumps; int numlumps;
int infotableofs; int infotableofs;
} dwadinfo_t; } dwadinfo_t;
// quake1 and half-life lump header
typedef struct typedef struct
{ {
int filepos; int filepos;
@ -1602,15 +1604,9 @@ typedef struct
char compression; // probably not used char compression; // probably not used
char pad1; char pad1;
char pad2; char pad2;
char name[WAD3_NAMELEN]; // must be null terminated char name[16]; // must be null terminated
} dlumpinfo_t; } dlumpinfo_t;
typedef struct
{
int width, height;
byte data[4]; // variably sized
} qpic_t;
typedef struct typedef struct
{ {
short startoffset; short startoffset;