ubergames
/
gtkradiant
mirror of https://github.com/UberGames/GtkRadiant.git
0
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
gtkradiant/tools/quake2/qdata_heretic2/images.c

1406 lines
32 KiB
C
Raw Blame History

/*
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.
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.
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
*/
#include "qdata.h"
#ifdef _WIN32
#include <windows.h>
#endif
#include <GL/gl.h>
#if 1
extern char *g_outputDir;
#endif // _QDATA
char mip_prefix[1024]; // directory to dump the textures in
qboolean colormap_issued;
byte colormap_palette[768];
unsigned total_x = 0;
unsigned total_y = 0;
unsigned total_textures = 0;
#define MAX_IMAGE_SIZE 512
#if 0
/*
==============
RemapZero
Replaces all 0 bytes in an image with the closest palette entry.
This is because NT won't let us change index 0, so any palette
animation leaves those pixels untouched.
==============
*/
void RemapZero( byte *pixels, byte *palette, int width, int height ){
int i, c;
int alt_zero;
int value, best;
alt_zero = 0;
best = 9999999;
for ( i = 1 ; i < 255 ; i++ )
{
value = palette[i * 3 + 0] + palette[i * 3 + 1] + palette[i * 3 + 2];
if ( value < best ) {
best = value;
alt_zero = i;
}
}
c = width * height;
for ( i = 0 ; i < c ; i++ )
if ( pixels[i] == 0 ) {
pixels[i] = alt_zero;
}
}
#endif
// ********************************************************************
// ** Mip Map Pre-Processing Routines
// ********************************************************************
#define intensity_value 1
static unsigned image_pal[256];
#define MAX_LAST 25
long palette_r[256], palette_g[256], palette_b[256];
long last_r[MAX_LAST],last_g[MAX_LAST],last_b[MAX_LAST], last_i[MAX_LAST], last_place;
long cached;
void PrepareConvert( unsigned *palette ){
int i;
for ( i = 0; i < 256; i++ )
{
palette_r[i] = ( palette[i] & 0x00ff0000 ) >> 16;
palette_g[i] = ( palette[i] & 0x0000ff00 ) >> 8;
palette_b[i] = ( palette[i] & 0x000000ff );
}
for ( i = 0; i < MAX_LAST; i++ )
last_r[i] = -1;
last_place = -1;
}
int ConvertTrueColorToPal( unsigned r, unsigned g, unsigned b ){
int i;
long min_dist;
int min_index;
long dist;
long dr, dg, db, biggest_delta;
for ( i = 0; i < MAX_LAST; i++ )
if ( r == last_r[i] && g == last_g[i] && b == last_b[i] ) {
cached++;
return last_i[i];
}
min_dist = 256 * 256 + 256 * 256 + 256 * 256;
biggest_delta = 256 * 256;
min_index = 0;
for ( i = 0; i < 256; i++ )
{
dr = abs( palette_r[i] - r );
if ( dr > biggest_delta ) {
continue;
}
dg = abs( palette_g[i] - g );
if ( dg > biggest_delta ) {
continue;
}
db = abs( palette_b[i] - b );
if ( db > biggest_delta ) {
continue;
}
dist = dr * dr + dg * dg + db * db;
if ( dist < min_dist ) {
min_dist = dist;
min_index = i;
if ( min_dist == 0 ) {
break;
}
dist = dr;
if ( dg > dist ) {
dist = dg;
}
if ( db > dist ) {
dist = db;
}
if ( dist < biggest_delta ) {
biggest_delta = dist;
}
}
}
last_place++;
if ( last_place >= MAX_LAST ) {
last_place = 0;
}
last_r[last_place] = r;
last_g[last_place] = g;
last_b[last_place] = b;
last_i[last_place] = min_index;
return min_index;
}
void GL_ResampleTexture8P( byte *in, int inwidth, int inheight, byte *out,
int outwidth, int outheight, palette_t *palette ){
int i, j;
byte *inrow, *inrow2;
unsigned frac, fracstep;
unsigned p1[1024], p2[1024], *p1p, *p2p;
palette_t *c1,*c2,*c3,*c4;
unsigned r,g,b;
fracstep = inwidth * 0x10000 / outwidth;
frac = fracstep >> 2;
for ( i = 0 ; i < outwidth ; i++ )
{
p1[i] = frac >> 16;
frac += fracstep;
}
frac = 3 * ( fracstep >> 2 );
for ( i = 0 ; i < outwidth ; i++ )
{
p2[i] = frac >> 16;
frac += fracstep;
}
cached = 0;
for ( i = 0 ; i < outheight ; i++ ) //, out += outwidth)
{
inrow = in + inwidth * (int)( ( i + 0.25 ) * inheight / outheight );
inrow2 = in + inwidth * (int)( ( i + 0.75 ) * inheight / outheight );
p1p = p1;
p2p = p2;
for ( j = 0 ; j < outwidth ; j++ )
{
c1 = &palette[*( (byte *)inrow + ( *p1p ) )];
c2 = &palette[*( (byte *)inrow + ( *p2p ) )];
c3 = &palette[*( (byte *)inrow2 + ( *p1p++ ) )];
c4 = &palette[*( (byte *)inrow2 + ( *p2p++ ) )];
r = ( (unsigned)c1->r + (unsigned)c2->r + (unsigned)c3->r + (unsigned)c4->r ) >> 2;
g = ( (unsigned)c1->g + (unsigned)c2->g + (unsigned)c3->g + (unsigned)c4->g ) >> 2;
b = ( (unsigned)c1->b + (unsigned)c2->b + (unsigned)c3->b + (unsigned)c4->b ) >> 2;
*out++ = ConvertTrueColorToPal( r,g,b );
}
}
}
void GL_MipMap8P( byte *out, byte *in, int width, int height, palette_t *palette ){
int i, j;
palette_t *c1,*c2,*c3,*c4;
unsigned r,g,b;
cached = 0;
memset( out, 0, 256 * 256 );
width <<= 1;
height <<= 1;
for ( i = 0; i < height; i += 2, in += width )
{
for ( j = 0; j < width; j += 2 )
{
c1 = &palette[in[0]];
c3 = &palette[in[width]];
in++;
c2 = &palette[in[0]];
c4 = &palette[in[width]];
in++;
r = ( (unsigned)c1->r + (unsigned)c2->r + (unsigned)c3->r + (unsigned)c4->r ) >> 2;
g = ( (unsigned)c1->g + (unsigned)c2->g + (unsigned)c3->g + (unsigned)c4->g ) >> 2;
b = ( (unsigned)c1->b + (unsigned)c2->b + (unsigned)c3->b + (unsigned)c4->b ) >> 2;
*out++ = ConvertTrueColorToPal( r, g, b );
}
}
}
miptex_t *CreateMip( byte *data, unsigned width, unsigned height, byte *palette, int *FinalSize, qboolean mip ){
int scaled_width, scaled_height;
int i,j,r,g,b;
byte intensitytable[256];
byte scaled[256 * 256];
byte out[256 * 256];
int miplevel;
miptex_t *mp;
byte *pos;
int size;
for ( i = 0 ; i < 256 ; i++ )
{
j = i * intensity_value;
if ( j > 255 ) {
j = 255;
}
intensitytable[i] = j;
}
for ( scaled_width = 1 ; scaled_width < width ; scaled_width <<= 1 )
;
if ( 1 && scaled_width > width && 1 ) {
scaled_width >>= 1;
}
for ( scaled_height = 1 ; scaled_height < height ; scaled_height <<= 1 )
;
if ( 1 && scaled_height > height && 1 ) {
scaled_height >>= 1;
}
// don't ever bother with >256 textures
if ( scaled_width > 256 ) {
scaled_width = 256;
}
if ( scaled_height > 256 ) {
scaled_height = 256;
}
if ( scaled_width < 1 ) {
scaled_width = 1;
}
if ( scaled_height < 1 ) {
scaled_height = 1;
}
size = sizeof( *mp ) + ( scaled_width * scaled_height * 3 );
mp = (miptex_t *)SafeMalloc( size, "CreateMip" );
memset( mp,0,size );
mp->version = MIP_VERSION;
for ( i = j = 0; i < 256; i++,j += 3 )
{
mp->palette[i].r = r = intensitytable[palette[j]];
mp->palette[i].g = g = intensitytable[palette[j + 1]];
mp->palette[i].b = b = intensitytable[palette[j + 2]];
image_pal[i] = 0xff000000 | ( r << 16 ) | ( g << 8 ) | ( b );
}
PrepareConvert( image_pal );
if ( scaled_width == width && scaled_height == height ) {
memcpy( scaled, data, width * height );
}
else{
GL_ResampleTexture8P( data, width, height, scaled, scaled_width, scaled_height, mp->palette );
}
pos = (byte *)( mp + 1 );
miplevel = 0;
while ( ( scaled_width >= 1 || scaled_height >= 1 ) && ( miplevel <= MIPLEVELS - 1 ) && ( !miplevel || mip ) )
{
if ( scaled_width < 1 ) {
scaled_width = 1;
}
if ( scaled_height < 1 ) {
scaled_height = 1;
}
if ( miplevel > 0 ) {
GL_MipMap8P( out, (byte *)scaled, scaled_width, scaled_height, mp->palette );
}
else{
memcpy( out, scaled, 256 * 256 );
}
mp->width[miplevel] = scaled_width;
mp->height[miplevel] = scaled_height;
mp->offsets[miplevel] = pos - ( (byte *)( mp ) );
memcpy( pos, out, scaled_width * scaled_height );
memcpy( scaled, out, 256 * 256 );
pos += scaled_width * scaled_height;
scaled_width >>= 1;
scaled_height >>= 1;
miplevel++;
}
*FinalSize = pos - ( (byte *)( mp ) );
return mp;
}
void GL_ResampleTexture( unsigned *in, int inwidth, int inheight, unsigned *out, int outwidth, int outheight ){
int i, j;
unsigned *inrow, *inrow2;
unsigned frac, fracstep;
unsigned p1[1024], p2[1024];
byte *pix1, *pix2, *pix3, *pix4;
fracstep = inwidth * 0x10000 / outwidth;
frac = fracstep >> 2;
for ( i = 0 ; i < outwidth ; i++ )
{
p1[i] = 4 * ( frac >> 16 );
frac += fracstep;
}
frac = 3 * ( fracstep >> 2 );
for ( i = 0 ; i < outwidth ; i++ )
{
p2[i] = 4 * ( frac >> 16 );
frac += fracstep;
}
for ( i = 0 ; i < outheight ; i++, out += outwidth )
{
inrow = in + inwidth * (int)( ( i + 0.25 ) * inheight / outheight );
inrow2 = in + inwidth * (int)( ( i + 0.75 ) * inheight / outheight );
frac = fracstep >> 1;
for ( j = 0 ; j < outwidth ; j++ )
{
pix1 = (byte *)inrow + p1[j];
pix2 = (byte *)inrow + p2[j];
pix3 = (byte *)inrow2 + p1[j];
pix4 = (byte *)inrow2 + p2[j];
( (byte *)( out + j ) )[0] = ( pix1[0] + pix2[0] + pix3[0] + pix4[0] ) >> 2;
( (byte *)( out + j ) )[1] = ( pix1[1] + pix2[1] + pix3[1] + pix4[1] ) >> 2;
( (byte *)( out + j ) )[2] = ( pix1[2] + pix2[2] + pix3[2] + pix4[2] ) >> 2;
( (byte *)( out + j ) )[3] = ( pix1[3] + pix2[3] + pix3[3] + pix4[3] ) >> 2;
}
}
}
void GL_MipMap( byte *out, byte *in, int width, int height ){
int i, j;
width <<= 3;
height <<= 1;
for ( i = 0 ; i < height ; i++, in += width )
{
for ( j = 0 ; j < width ; j += 8, out += 4, in += 8 )
{
out[0] = ( in[0] + in[4] + in[width + 0] + in[width + 4] ) >> 2;
out[1] = ( in[1] + in[5] + in[width + 1] + in[width + 5] ) >> 2;
out[2] = ( in[2] + in[6] + in[width + 2] + in[width + 6] ) >> 2;
out[3] = ( in[3] + in[7] + in[width + 3] + in[width + 7] ) >> 2;
}
}
}
miptex32_t *CreateMip32( unsigned *data, unsigned width, unsigned height, int *FinalSize, qboolean mip ){
int scaled_width, scaled_height;
unsigned scaled[MAX_IMAGE_SIZE * MAX_IMAGE_SIZE];
unsigned out[MAX_IMAGE_SIZE * MAX_IMAGE_SIZE];
int miplevel;
miptex32_t *mp;
byte *pos;
int size;
paletteRGBA_t *test;
for ( scaled_width = 1 ; scaled_width < width ; scaled_width <<= 1 )
;
if ( 1 && scaled_width > width && 1 ) {
scaled_width >>= 1;
}
for ( scaled_height = 1 ; scaled_height < height ; scaled_height <<= 1 )
;
if ( 1 && scaled_height > height && 1 ) {
scaled_height >>= 1;
}
// don't ever bother with >256 textures
if ( scaled_width > MAX_IMAGE_SIZE ) {
scaled_width = MAX_IMAGE_SIZE;
}
if ( scaled_height > MAX_IMAGE_SIZE ) {
scaled_height = MAX_IMAGE_SIZE;
}
if ( scaled_width < 1 ) {
scaled_width = 1;
}
if ( scaled_height < 1 ) {
scaled_height = 1;
}
size = sizeof( *mp ) + ( scaled_width * scaled_height * 3 * 4 );
mp = (miptex32_t *)SafeMalloc( size, "CreateMip" );
memset( mp,0,size );
mp->version = MIP32_VERSION;
size = width * height;
test = (paletteRGBA_t *)data;
while ( size )
{
if ( test->a != 255 ) {
mp->flags |= LittleLong( SURF_ALPHA_TEXTURE );
break;
}
size--;
test++;
}
if ( scaled_width == width && scaled_height == height ) {
memcpy( scaled, data, width * height * 4 );
}
else{
GL_ResampleTexture( data, width, height, scaled, scaled_width, scaled_height );
}
pos = (byte *)( mp + 1 );
miplevel = 0;
while ( ( scaled_width >= 1 || scaled_height >= 1 ) && ( miplevel <= MIPLEVELS - 1 ) && ( !miplevel || mip ) )
{
if ( scaled_width < 1 ) {
scaled_width = 1;
}
if ( scaled_height < 1 ) {
scaled_height = 1;
}
if ( miplevel > 0 ) {
GL_MipMap( (byte *)out, (byte *)scaled, scaled_width, scaled_height );
}
else
{
memcpy( out, scaled, MAX_IMAGE_SIZE * MAX_IMAGE_SIZE * 4 );
}
mp->width[miplevel] = scaled_width;
mp->height[miplevel] = scaled_height;
mp->offsets[miplevel] = pos - ( (byte *)( mp ) );
memcpy( pos, out, scaled_width * scaled_height * 4 );
memcpy( scaled, out, MAX_IMAGE_SIZE * MAX_IMAGE_SIZE * 4 );
pos += scaled_width * scaled_height * 4;
scaled_width >>= 1;
scaled_height >>= 1;
miplevel++;
}
*FinalSize = pos - ( (byte *)( mp ) );
return mp;
}
/*
==============
Cmd_Grab
$grab filename x y width height
==============
*/
void Cmd_Grab( void ){
int xl,yl,w,h,y;
byte *cropped;
char savename[1024];
char dest[1024];
GetScriptToken( false );
if ( token[0] == '/' || token[0] == '\\' ) {
sprintf( savename, "%s%s.pcx", gamedir, token + 1 );
}
else{
sprintf( savename, "%spics/%s.pcx", gamedir, token );
}
if ( g_release ) {
if ( token[0] == '/' || token[0] == '\\' ) {
sprintf( dest, "%s.pcx", token + 1 );
}
else{
sprintf( dest, "pics/%s.pcx", token );
}
ReleaseFile( dest );
return;
}
GetScriptToken( false );
xl = atoi( token );
GetScriptToken( false );
yl = atoi( token );
GetScriptToken( false );
w = atoi( token );
GetScriptToken( false );
h = atoi( token );
if ( xl < 0 || yl < 0 || w < 0 || h < 0 || xl + w > byteimagewidth || yl + h > byteimageheight ) {
Error( "GrabPic: Bad size: %i, %i, %i, %i",xl,yl,w,h );
}
// crop it to the proper size
cropped = (byte *) SafeMalloc( w * h, "Cmd_Grab" );
for ( y = 0 ; y < h ; y++ )
{
memcpy( cropped + y * w, byteimage + ( y + yl ) * byteimagewidth + xl, w );
}
// save off the new image
printf( "saving %s\n", savename );
CreatePath( savename );
WritePCXfile( savename, cropped, w, h, lbmpalette );
free( cropped );
}
/*
==============
Cmd_Raw
$grab filename x y width height
==============
*/
void Cmd_Raw( void ){
int xl,yl,w,h,y;
byte *cropped;
char savename[1024];
char dest[1024];
GetScriptToken( false );
sprintf( savename, "%s%s.lmp", gamedir, token );
if ( g_release ) {
sprintf( dest, "%s.lmp", token );
ReleaseFile( dest );
return;
}
GetScriptToken( false );
xl = atoi( token );
GetScriptToken( false );
yl = atoi( token );
GetScriptToken( false );
w = atoi( token );
GetScriptToken( false );
h = atoi( token );
if ( xl < 0 || yl < 0 || w < 0 || h < 0 || xl + w > byteimagewidth || yl + h > byteimageheight ) {
Error( "GrabPic: Bad size: %i, %i, %i, %i",xl,yl,w,h );
}
// crop it to the proper size
cropped = (byte *) SafeMalloc( w * h, "Cmd_Raw" );
for ( y = 0 ; y < h ; y++ )
{
memcpy( cropped + y * w, byteimage + ( y + yl ) * byteimagewidth + xl, w );
}
// save off the new image
printf( "saving %s\n", savename );
CreatePath( savename );
SaveFile( savename, cropped, w * h );
free( cropped );
}
/*
=============================================================================
COLORMAP GRABBING
=============================================================================
*/
/*
===============
BestColor
===============
*/
byte BestColor( int r, int g, int b, int start, int stop ){
int i;
int dr, dg, db;
int bestdistortion, distortion;
int bestcolor;
byte *pal;
//
// let any color go to 0 as a last resort
//
bestdistortion = 256 * 256 * 4;
bestcolor = 0;
pal = colormap_palette + start * 3;
for ( i = start ; i <= stop ; i++ )
{
dr = r - (int)pal[0];
dg = g - (int)pal[1];
db = b - (int)pal[2];
pal += 3;
distortion = dr * dr + dg * dg + db * db;
if ( distortion < bestdistortion ) {
if ( !distortion ) {
return i; // perfect match
}
bestdistortion = distortion;
bestcolor = i;
}
}
return bestcolor;
}
/*
==============
Cmd_Colormap
$colormap filename
the brightes colormap is first in the table (FIXME: reverse this now?)
64 rows of 256 : lightmaps
256 rows of 256 : translucency table
==============
*/
void Cmd_Colormap( void ){
int levels, brights;
int l, c;
float frac, red, green, blue;
float range;
byte *cropped, *lump_p;
char savename[1024];
char dest[1024];
colormap_issued = true;
if ( !g_release ) {
memcpy( colormap_palette, lbmpalette, 768 );
}
if ( !ScriptTokenAvailable() ) { // just setting colormap_issued
return;
}
GetScriptToken( false );
sprintf( savename, "%spics/%s.pcx", gamedir, token );
if ( g_release ) {
sprintf( dest, "pics/%s.pcx", token );
ReleaseFile( dest );
return;
}
range = 2;
levels = 64;
brights = 1; // ignore 255 (transparent)
cropped = (byte *) SafeMalloc( ( levels + 256 ) * 256, "Cmd_ColorMap" );
lump_p = cropped;
// shaded levels
for ( l = 0; l < levels; l++ )
{
frac = range - range * (float)l / ( levels - 1 );
for ( c = 0 ; c < 256 - brights ; c++ )
{
red = lbmpalette[c * 3];
green = lbmpalette[c * 3 + 1];
blue = lbmpalette[c * 3 + 2];
red = (int)( red * frac + 0.5 );
green = (int)( green * frac + 0.5 );
blue = (int)( blue * frac + 0.5 );
//
// note: 254 instead of 255 because 255 is the transparent color, and we
// don't want anything remapping to that
// don't use color 0, because NT can't remap that (or 255)
//
*lump_p++ = BestColor( red,green,blue, 1, 254 );
}
// fullbrights allways stay the same
for ( ; c < 256 ; c++ )
*lump_p++ = c;
}
// 66% transparancy table
for ( l = 0; l < 255; l++ )
{
for ( c = 0 ; c < 255 ; c++ )
{
red = lbmpalette[c * 3] * 0.33 + lbmpalette[l * 3] * 0.66;
green = lbmpalette[c * 3 + 1] * 0.33 + lbmpalette[l * 3 + 1] * 0.66;
blue = lbmpalette[c * 3 + 2] * 0.33 + lbmpalette[l * 3 + 2] * 0.66;
*lump_p++ = BestColor( red,green,blue, 1, 254 );
}
*lump_p++ = 255;
}
for ( c = 0 ; c < 256 ; c++ )
*lump_p++ = 255;
// save off the new image
printf( "saving %s\n", savename );
CreatePath( savename );
WritePCXfile( savename, cropped, 256, levels + 256, lbmpalette );
free( cropped );
}
/*
=============================================================================
MIPTEX GRABBING
=============================================================================
*/
byte pixdata[256];
int d_red, d_green, d_blue;
byte palmap[32][32][32];
qboolean palmap_built;
/*
=============
FindColor
=============
*/
int FindColor( int r, int g, int b ){
int bestcolor;
if ( r > 255 ) {
r = 255;
}
if ( r < 0 ) {
r = 0;
}
if ( g > 255 ) {
g = 255;
}
if ( g < 0 ) {
g = 0;
}
if ( b > 255 ) {
b = 255;
}
if ( b < 0 ) {
b = 0;
}
#ifndef TABLECOLORS
bestcolor = BestColor( r, g, b, 0, 254 );
#else
bestcolor = palmap[r >> 3][g >> 3][b >> 3];
#endif
return bestcolor;
}
void BuildPalmap( void ){
#ifdef TABLECOLORS
int r, g, b;
int bestcolor;
if ( palmap_built ) {
return;
}
palmap_built = true;
for ( r = 4 ; r < 256 ; r += 8 )
{
for ( g = 4 ; g < 256 ; g += 8 )
{
for ( b = 4 ; b < 256 ; b += 8 )
{
bestcolor = BestColor( r, g, b, 1, 254 );
palmap[r >> 3][g >> 3][b >> 3] = bestcolor;
}
}
}
#endif
if ( !colormap_issued ) {
Error( "You must issue a $colormap command first" );
}
}
/*
=============
AveragePixels
=============
*/
byte AveragePixels( int count ){
int r,g,b;
int i;
int vis;
int pix;
int bestcolor;
byte *pal;
int fullbright;
vis = 0;
r = g = b = 0;
fullbright = 0;
for ( i = 0 ; i < count ; i++ )
{
pix = pixdata[i];
r += lbmpalette[pix * 3];
g += lbmpalette[pix * 3 + 1];
b += lbmpalette[pix * 3 + 2];
vis++;
}
r /= vis;
g /= vis;
b /= vis;
// error diffusion
r += d_red;
g += d_green;
b += d_blue;
//
// find the best color
//
bestcolor = FindColor( r, g, b );
// error diffusion
pal = colormap_palette + bestcolor * 3;
d_red = r - (int)pal[0];
d_green = g - (int)pal[1];
d_blue = b - (int)pal[2];
return bestcolor;
}
typedef enum
{
pt_contents,
pt_flags,
pt_animvalue,
pt_altnamevalue,
pt_damagenamevalue,
pt_flagvalue,
pt_materialvalue,
pt_scale,
pt_mip,
pt_detail,
pt_gl,
pt_nomip,
pt_detailer,
} parmtype_t;
typedef struct
{
char *name;
int flags;
parmtype_t type;
} mipparm_t;
mipparm_t mipparms[] =
{
// utility content attributes
{"pushpull",CONTENTS_PUSHPULL, pt_contents},
{"water", CONTENTS_WATER, pt_contents},
{"slime", CONTENTS_SLIME, pt_contents}, // mildly damaging
{"lava", CONTENTS_LAVA, pt_contents}, // very damaging
{"window", CONTENTS_WINDOW, pt_contents}, // solid, but doesn't eat internal textures
{"mist", CONTENTS_MIST, pt_contents}, // non-solid window
{"origin", CONTENTS_ORIGIN, pt_contents}, // center of rotating brushes
{"playerclip", CONTENTS_PLAYERCLIP, pt_contents},
{"monsterclip", CONTENTS_MONSTERCLIP, pt_contents},
// utility surface attributes
{"hint", SURF_HINT, pt_flags},
{"skip", SURF_SKIP, pt_flags},
{"light", SURF_LIGHT, pt_flagvalue}, // value is the light quantity
{"animspeed",SURF_ANIMSPEED, pt_flagvalue}, // value will hold the anim speed in fps
// texture chaining
{"anim", 0, pt_animvalue}, // animname is the next animation
{"alt", 0, pt_altnamevalue}, // altname is the alternate texture
{"damage", 0, pt_damagenamevalue}, // damagename is the damage texture
{"scale", 0, pt_scale}, // next two values are for scale
{"mip", 0, pt_mip},
{"detail", 0, pt_detail},
{"GL_ZERO", GL_ZERO, pt_gl},
{"GL_ONE", GL_ONE, pt_gl},
{"GL_SRC_COLOR", GL_SRC_COLOR, pt_gl},
{"GL_ONE_MINUS_SRC_COLOR", GL_ONE_MINUS_SRC_COLOR, pt_gl},
{"GL_DST_COLOR", GL_DST_COLOR, pt_gl},
{"GL_ONE_MINUS_DST_COLOR", GL_ONE_MINUS_DST_COLOR, pt_gl},
{"GL_SRC_ALPHA", GL_SRC_ALPHA, pt_gl},
{"GL_ONE_MINUS_SRC_ALPHA", GL_ONE_MINUS_SRC_ALPHA, pt_gl},
{"GL_DST_ALPHA", GL_DST_ALPHA, pt_gl},
{"GL_ONE_MINUS_DST_ALPHA", GL_ONE_MINUS_DST_ALPHA, pt_gl},
{"GL_SRC_ALPHA_SATURATE", GL_SRC_ALPHA_SATURATE, pt_gl},
// server attributes
{"slick", SURF_SLICK, pt_flags},
// drawing attributes
{"sky", SURF_SKY, pt_flags},
{"warping", SURF_WARP, pt_flags}, // only valid with 64x64 textures
{"trans33", SURF_TRANS33, pt_flags}, // translucent should allso set fullbright
{"trans66", SURF_TRANS66, pt_flags},
{"flowing", SURF_FLOWING, pt_flags}, // flow direction towards angle 0
{"nodraw", SURF_NODRAW, pt_flags}, // for clip textures and trigger textures
{"alpha", SURF_ALPHA_TEXTURE, pt_flags},
{"undulate", SURF_UNDULATE, pt_flags}, // rock surface up and down...
{"skyreflect", SURF_SKYREFLECT, pt_flags}, // liquid will somewhat reflect the sky - not quite finished....
{"material", SURF_MATERIAL, pt_materialvalue},
{"metal", SURF_TYPE_METAL, pt_flags},
{"stone", SURF_TYPE_STONE, pt_flags},
{"wood", SURF_TYPE_WOOD, pt_flags},
{"m_nomip", 0, pt_nomip},
{"m_detail", 0, pt_detailer},
{NULL, 0, pt_contents}
};
/*
==============
Cmd_Mip
$mip filename x y width height <OPTIONS>
must be multiples of sixteen
SURF_WINDOW
==============
*/
void Cmd_Mip( void ){
int xl,yl,xh,yh,w,h;
byte *dest, *source;
int flags, value, contents;
mipparm_t *mp;
char lumpname[128];
char altname[128];
char animname[128];
char damagename[128];
byte buffer[MAX_IMAGE_SIZE * MAX_IMAGE_SIZE];
unsigned bufferl[MAX_IMAGE_SIZE * MAX_IMAGE_SIZE];
materialtype_t *mat;
char filename[1024];
unsigned *destl, *sourcel;
int linedelta, x, y;
int size;
miptex_t *qtex;
miptex32_t *qtex32;
float scale_x, scale_y;
int mip_scale;
// detail texturing
char dt_name[128];
float dt_scale_x, dt_scale_y;
float dt_u, dt_v;
float dt_alpha;
int dt_src_blend_mode, dt_dst_blend_mode;
int flags2;
GetScriptToken( false );
strcpy( lumpname, token );
GetScriptToken( false );
xl = atoi( token );
GetScriptToken( false );
yl = atoi( token );
GetScriptToken( false );
w = atoi( token );
GetScriptToken( false );
h = atoi( token );
total_x += w;
total_y += h;
total_textures++;
if ( ( w & 15 ) || ( h & 15 ) ) {
Error( "line %i: miptex sizes must be multiples of 16", scriptline );
}
flags = 0;
flags2 = 0;
contents = 0;
value = 0;
mip_scale = 0;
altname[0] = animname[0] = damagename[0] = 0;
scale_x = scale_y = 0.5;
// detail texturing
dt_name[0] = 0;
dt_scale_x = dt_scale_y = 0.0;
dt_u = dt_v = 0.0;
dt_alpha = 0.0;
dt_src_blend_mode = dt_dst_blend_mode = 0;
// get optional flags and values
while ( ScriptTokenAvailable() )
{
GetScriptToken( false );
for ( mp = mipparms ; mp->name ; mp++ )
{
if ( !strcmp( mp->name, token ) ) {
switch ( mp->type )
{
case pt_animvalue:
GetScriptToken( false ); // specify the next animation frame
strcpy( animname, token );
break;
case pt_altnamevalue:
GetScriptToken( false ); // specify the alternate texture
strcpy( altname, token );
break;
case pt_damagenamevalue:
GetScriptToken( false ); // specify the damage texture
strcpy( damagename, token );
break;
case pt_flags:
flags |= mp->flags;
break;
case pt_contents:
contents |= mp->flags;
break;
case pt_flagvalue:
flags |= mp->flags;
GetScriptToken( false ); // specify the light value
value = atoi( token );
break;
case pt_materialvalue:
GetScriptToken( false );
for ( mat = materialtypes ; mat->name ; mat++ )
{
if ( !strcmp( mat->name, token ) ) {
// assumes SURF_MATERIAL is in top 8 bits
flags = ( flags & 0x0FFFFFF ) | ( mat->value << 24 );
break;
}
}
break;
case pt_scale:
GetScriptToken( false ); // specify the x scale
scale_x = atof( token );
GetScriptToken( false ); // specify the y scale
scale_y = atof( token );
break;
case pt_mip:
mip_scale = 1;
break;
case pt_detailer:
flags2 |= MIP32_DETAILER_FLAG2;
break;
case pt_nomip:
flags2 |= MIP32_NOMIP_FLAG2;
break;
case pt_detail:
GetScriptToken( false );
strcpy( dt_name, token );
GetScriptToken( false );
dt_scale_x = atof( token );
GetScriptToken( false );
dt_scale_y = atof( token );
GetScriptToken( false );
dt_u = atof( token );
GetScriptToken( false );
dt_v = atof( token );
GetScriptToken( false );
dt_alpha = atof( token );
GetScriptToken( false );
for ( mp = mipparms ; mp->name ; mp++ )
{
if ( !strcmp( mp->name, token ) ) {
if ( mp->type == pt_gl ) {
dt_src_blend_mode = mp->flags;
break;
}
}
}
if ( !mp->name ) {
Error( "line %i: invalid gl blend mode %s", scriptline, token );
}
GetScriptToken( false );
for ( mp = mipparms ; mp->name ; mp++ )
{
if ( !strcmp( mp->name, token ) ) {
if ( mp->type == pt_gl ) {
dt_dst_blend_mode = mp->flags;
break;
}
}
}
if ( !mp->name ) {
Error( "line %i: invalid gl blend mode %s", scriptline, token );
}
break;
}
break;
}
}
if ( !mp->name ) {
Error( "line %i: unknown parm %s", scriptline, token );
}
}
if ( g_release ) {
return; // textures are only released by $maps
}
xh = xl + w;
yh = yl + h;
if ( xh * yh > MAX_IMAGE_SIZE * MAX_IMAGE_SIZE ) {
Error( "line %i image %s: image is too big!", scriptline, lumpname );
}
if ( TrueColorImage ) {
if ( xl >= longimagewidth || xh > longimagewidth ||
yl >= longimageheight || yh > longimageheight ) {
Error( "line %i image %s: bad clip dimmensions (%d,%d) (%d,%d) > image (%d,%d)", scriptline, lumpname, xl,yl,w,h,longimagewidth,longimageheight );
}
sourcel = longimage + ( yl * longimagewidth ) + xl;
destl = bufferl;
linedelta = ( longimagewidth - w );
for ( y = yl ; y < yh ; y++ )
{
for ( x = xl ; x < xh ; x++ )
{
*destl++ = *sourcel++; // RGBA
}
sourcel += linedelta;
}
qtex32 = CreateMip32( bufferl, w, h, &size, true );
qtex32->flags |= LittleLong( flags );
qtex32->flags2 |= LittleLong( flags2 );
qtex32->contents = LittleLong( contents );
qtex32->value = LittleLong( value );
qtex32->scale_x = scale_x;
qtex32->scale_y = scale_y;
qtex32->mip_scale = mip_scale;
sprintf( qtex32->name, "%s/%s", mip_prefix, lumpname );
if ( animname[0] ) {
sprintf( qtex32->animname, "%s/%s", mip_prefix, animname );
}
if ( altname[0] ) {
sprintf( qtex32->altname, "%s/%s", mip_prefix, altname );
}
if ( damagename[0] ) {
sprintf( qtex32->damagename, "%s/%s", mip_prefix, damagename );
}
if ( dt_name[0] & ( ( flags2 & MIP32_DETAILER_FLAG2 ) == 0 ) ) {
sprintf( qtex32->dt_name, "%s/%s", mip_prefix, dt_name );
qtex32->dt_scale_x = dt_scale_x;
qtex32->dt_scale_y = dt_scale_y;
qtex32->dt_u = dt_u;
qtex32->dt_v = dt_v;
qtex32->dt_alpha = dt_alpha;
qtex32->dt_src_blend_mode = dt_src_blend_mode;
qtex32->dt_dst_blend_mode = dt_dst_blend_mode;
}
//
// write it out
//
sprintf( filename, "%stextures/%s/%s.m32", g_outputDir, mip_prefix, lumpname );
if ( qtex32->flags & ( SURF_ALPHA_TEXTURE ) ) {
printf( "writing %s with ALPHA\n", filename );
}
else{
printf( "writing %s\n", filename );
}
SaveFile( filename, (byte *)qtex32, size );
free( qtex32 );
}
else
{
if ( xl >= byteimagewidth || xh > byteimagewidth ||
yl >= byteimageheight || yh > byteimageheight ) {
Error( "line %i: bad clip dimmensions (%d,%d) (%d,%d) > image (%d,%d)", scriptline, xl,yl,w,h,byteimagewidth,byteimageheight );
}
source = byteimage + yl * byteimagewidth + xl;
dest = buffer;
linedelta = byteimagewidth - w;
for ( y = yl ; y < yh ; y++ )
{
for ( x = xl ; x < xh ; x++ )
{
*dest++ = *source++;
}
source += linedelta;
}
qtex = CreateMip( buffer, w, h, lbmpalette, &size, true );
qtex->flags = LittleLong( flags );
qtex->contents = LittleLong( contents );
qtex->value = LittleLong( value );
sprintf( qtex->name, "%s/%s", mip_prefix, lumpname );
if ( animname[0] ) {
sprintf( qtex->animname, "%s/%s", mip_prefix, animname );
}
//
// write it out
//
sprintf( filename, "%stextures/%s/%s.m8", g_outputDir, mip_prefix, lumpname );
printf( "writing %s\n", filename );
SaveFile( filename, (byte *)qtex, size );
free( qtex );
}
}
/*
===============
Cmd_Mippal
===============
*/
void Cmd_Mippal( void ){
colormap_issued = true;
if ( g_release ) {
return;
}
memcpy( colormap_palette, lbmpalette, 768 );
BuildPalmap();
}
/*
===============
Cmd_Mipdir
===============
*/
void Cmd_Mipdir( void ){
char filename[1024];
GetScriptToken( false );
strcpy( mip_prefix, token );
// create the directory if needed
sprintf( filename, "%stextures", g_outputDir );
Q_mkdir( filename );
sprintf( filename, "%stextures/%s", g_outputDir, mip_prefix );
Q_mkdir( filename );
}
/*
=============================================================================
ENVIRONMENT MAP GRABBING
Creates six pcx files from tga files without any palette edge seams
also copies the tga files for GL rendering.
=============================================================================
*/
// 3dstudio environment map suffixes
char *suf[6] = {"rt", "ft", "lf", "bk", "up", "dn"};
/*
=================
Cmd_Environment
=================
*/
void Cmd_Environment( void ){
char name[1024];
int i, x, y;
byte image[256 * 256];
byte *tga;
GetScriptToken( false );
if ( g_release ) {
for ( i = 0 ; i < 6 ; i++ )
{
sprintf( name, "env/%s%s.pcx", token, suf[i] );
ReleaseFile( name );
sprintf( name, "env/%s%s.tga", token, suf[i] );
ReleaseFile( name );
}
return;
}
// get the palette
BuildPalmap();
sprintf( name, "%senv/", gamedir );
CreatePath( name );
// convert the images
for ( i = 0 ; i < 6 ; i++ )
{
sprintf( name, "%senv/%s%s.tga", gamedir, token, suf[i] );
printf( "loading %s...\n", name );
LoadTGA( name, &tga, NULL, NULL );
for ( y = 0 ; y < 256 ; y++ )
{
for ( x = 0 ; x < 256 ; x++ )
{
image[y * 256 + x] = FindColor( tga[( y * 256 + x ) * 4 + 0],tga[( y * 256 + x ) * 4 + 1],tga[( y * 256 + x ) * 4 + 2] );
}
}
free( tga );
sprintf( name, "%senv/%s%s.pcx", gamedir, token, suf[i] );
if ( FileTime( name ) != -1 ) {
printf( "%s already exists, not overwriting.\n", name );
}
else{
WritePCXfile( name, image, 256, 256, colormap_palette );
}
}
}
Reference in New Issue View Git Blame Copy Permalink