mirror of
https://github.com/UberGames/GtkRadiant.git
synced 2024-11-22 20:02:42 +00:00
364 lines
8.1 KiB
C
364 lines
8.1 KiB
C
/*
|
|
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"
|
|
|
|
byte *byteimage, *lbmpalette;
|
|
int byteimagewidth, byteimageheight;
|
|
|
|
qboolean TrueColorImage;
|
|
int longimagewidth, longimageheight;
|
|
|
|
char book_prefix[1024];
|
|
byte buffer[640 * 480];
|
|
unsigned long bufferl[640 * 480];
|
|
|
|
miptex_t *CreateBook8( byte *buffer, int w, int h, byte *palette, int *FinalSize ){
|
|
miptex_t *mp;
|
|
int i, j;
|
|
byte *pos;
|
|
int size;
|
|
|
|
size = sizeof( *mp ) + ( w * h );
|
|
mp = (miptex_t *)SafeMalloc( size, "CreateBook8" );
|
|
memset( mp, 0, size );
|
|
|
|
mp->version = MIP_VERSION;
|
|
|
|
for ( i = j = 0; i < 256; i++,j += 3 )
|
|
{
|
|
mp->palette[i].r = palette[j];
|
|
mp->palette[i].g = palette[j + 1];
|
|
mp->palette[i].b = palette[j + 2];
|
|
}
|
|
pos = (byte *)( mp + 1 );
|
|
|
|
mp->width[0] = w;
|
|
mp->height[0] = h;
|
|
mp->offsets[0] = sizeof( *mp );
|
|
memcpy( pos, buffer, w * h );
|
|
|
|
*FinalSize = size;
|
|
return( mp );
|
|
}
|
|
|
|
miptex32_t *CreateBook32( long *buffer, int w, int h, int *FinalSize ){
|
|
miptex32_t *mp;
|
|
byte *pos;
|
|
int size;
|
|
|
|
size = sizeof( *mp ) + ( w * h * 4 );
|
|
mp = (miptex32_t *)SafeMalloc( size, "CreateBook32" );
|
|
memset( mp, 0, size );
|
|
|
|
mp->version = MIP32_VERSION;
|
|
|
|
pos = (byte *)( mp + 1 );
|
|
|
|
mp->width[0] = w;
|
|
mp->height[0] = h;
|
|
mp->offsets[0] = sizeof( *mp );
|
|
memcpy( pos, buffer, w * h * 4 );
|
|
|
|
*FinalSize = size;
|
|
return( mp );
|
|
}
|
|
|
|
|
|
// Routines to chop a random sized image into gl texture friendly chunks
|
|
|
|
typedef struct rect_s
|
|
{
|
|
int x, y;
|
|
int w, h;
|
|
char name[4];
|
|
} rect_t;
|
|
|
|
int GetCoords( int x, int store[MAX_MD2SKINS] ){
|
|
int index, start, delta;
|
|
|
|
index = 0;
|
|
start = 0;
|
|
delta = 256;
|
|
|
|
store[index++] = start;
|
|
while ( x )
|
|
{
|
|
if ( x >= delta ) {
|
|
start += delta;
|
|
store[index++] = start;
|
|
x -= delta;
|
|
}
|
|
else
|
|
{
|
|
delta >>= 1;
|
|
}
|
|
}
|
|
return( index );
|
|
}
|
|
|
|
int ChopImage( int w, int h, rect_t coords[MAX_MD2SKINS] ){
|
|
int xs[MAX_MD2SKINS], ys[MAX_MD2SKINS];
|
|
int xcount, ycount, x, y, index;
|
|
|
|
index = 0;
|
|
xcount = GetCoords( w, xs ) - 1;
|
|
ycount = GetCoords( h, ys ) - 1;
|
|
|
|
for ( y = 0; y < ycount; y++ )
|
|
{
|
|
for ( x = 0; x < xcount; x++, index++ )
|
|
{
|
|
coords[index].x = xs[x];
|
|
coords[index].y = ys[y];
|
|
coords[index].w = xs[x + 1] - xs[x];
|
|
coords[index].h = ys[y + 1] - ys[y];
|
|
coords[index].name[0] = x + '0';
|
|
coords[index].name[1] = y + '0';
|
|
coords[index].name[2] = 0;
|
|
}
|
|
}
|
|
return( index );
|
|
}
|
|
|
|
/*
|
|
===============
|
|
Cmd_Pic
|
|
===============
|
|
*/
|
|
|
|
void Cmd_Book(){
|
|
int xl,yl,xh,yh,w,h;
|
|
byte *dest, *source;
|
|
int flags, value, contents;
|
|
char lumpname[64];
|
|
char filename[1024];
|
|
unsigned long *destl, *sourcel;
|
|
int linedelta, x, y;
|
|
int size;
|
|
miptex_t *qtex;
|
|
miptex32_t *qtex32;
|
|
float scale_x, scale_y;
|
|
int numrects, i;
|
|
rect_t coords[MAX_MD2SKINS];
|
|
bookframe_t bframes[MAX_MD2SKINS];
|
|
bookframe_t *bf;
|
|
book_t book;
|
|
|
|
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 & 7 ) || ( h & 7 ) ) {
|
|
Error( "line %i: miptex sizes must be multiples of 8", scriptline );
|
|
}
|
|
|
|
flags = 0;
|
|
contents = 0;
|
|
value = 0;
|
|
|
|
scale_x = scale_y = 0.5;
|
|
|
|
if ( g_release ) {
|
|
return;
|
|
}
|
|
|
|
if ( TrueColorImage ) {
|
|
xh = xl + w;
|
|
yh = yl + h;
|
|
|
|
if ( xl >= longimagewidth || xh > longimagewidth ||
|
|
yl >= longimageheight || yh > longimageheight ) {
|
|
Error( "line %i: bad clip dimmensions (%d,%d) (%d,%d) > image (%d,%d)", scriptline, xl,yl,w,h,longimagewidth,longimageheight );
|
|
}
|
|
|
|
sourcel = (unsigned long *) longimage + ( yl * longimagewidth ) + xl;
|
|
destl = (unsigned long *) longimage;
|
|
linedelta = ( longimagewidth - w );
|
|
|
|
for ( y = yl; y < yh; y++ )
|
|
{
|
|
for ( x = xl; x < xh; x++ )
|
|
{
|
|
*destl++ = *sourcel++; // RGBA
|
|
}
|
|
sourcel += linedelta;
|
|
}
|
|
|
|
// Get rectangles to chop into
|
|
numrects = ChopImage( w, h, coords );
|
|
|
|
bf = bframes;
|
|
for ( i = 0; i < numrects; i++, bf++ )
|
|
{
|
|
// Copy section of image to buffer
|
|
sourcel = (unsigned long *) longimage + ( coords[i].y * w ) + coords[i].x;
|
|
destl = bufferl;
|
|
linedelta = w - coords[i].w;
|
|
|
|
for ( y = 0; y < coords[i].h; y++ )
|
|
{
|
|
for ( x = 0; x < coords[i].w; x++ )
|
|
{
|
|
*destl++ = *sourcel++;
|
|
}
|
|
sourcel += linedelta;
|
|
}
|
|
|
|
qtex32 = CreateBook32( bufferl, coords[i].w, coords[i].h, &size );
|
|
|
|
qtex32->flags = flags;
|
|
qtex32->contents = contents;
|
|
qtex32->value = value;
|
|
qtex32->scale_x = scale_x;
|
|
qtex32->scale_y = scale_y;
|
|
|
|
sprintf( filename, "%sbook/%s/%s_%s.m32", gamedir, book_prefix, lumpname, coords[i].name );
|
|
sprintf( qtex32->name, "%s/%s_%s.m32", book_prefix, lumpname, coords[i].name );
|
|
|
|
strcpy( bf->name, qtex32->name );
|
|
bf->x = coords[i].x;
|
|
bf->y = coords[i].y;
|
|
bf->w = coords[i].w;
|
|
bf->h = coords[i].h;
|
|
//
|
|
// write it out
|
|
//
|
|
printf( "writing %s\n", filename );
|
|
SaveFile( filename, (byte *)qtex32, size );
|
|
|
|
free( qtex32 );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
xh = xl + w;
|
|
yh = yl + h;
|
|
|
|
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 );
|
|
}
|
|
|
|
// Copy image to top left
|
|
source = byteimage + yl * byteimagewidth + xl;
|
|
dest = byteimage;
|
|
linedelta = byteimagewidth - w;
|
|
|
|
for ( y = yl; y < yh; y++ )
|
|
{
|
|
for ( x = xl; x < xh; x++ )
|
|
{
|
|
*dest++ = *source++;
|
|
}
|
|
source += linedelta;
|
|
}
|
|
|
|
// Get rectangles to chop into
|
|
numrects = ChopImage( w, h, coords );
|
|
|
|
bf = bframes;
|
|
for ( i = 0; i < numrects; i++, bf++ )
|
|
{
|
|
// Copy section of image to buffer
|
|
source = byteimage + ( coords[i].y * w ) + coords[i].x;
|
|
dest = buffer;
|
|
linedelta = w - coords[i].w;
|
|
|
|
for ( y = 0; y < coords[i].h; y++ )
|
|
{
|
|
for ( x = 0; x < coords[i].w; x++ )
|
|
{
|
|
*dest++ = *source++;
|
|
}
|
|
source += linedelta;
|
|
}
|
|
|
|
qtex = CreateBook8( buffer, coords[i].w, coords[i].h, lbmpalette, &size );
|
|
|
|
qtex->flags = flags;
|
|
qtex->contents = contents;
|
|
qtex->value = value;
|
|
|
|
sprintf( filename, "%sbook/%s/%s_%s.m8", gamedir, book_prefix, lumpname, coords[i].name );
|
|
sprintf( qtex->name, "%s/%s_%s.m8", book_prefix, lumpname, coords[i].name );
|
|
|
|
strcpy( bf->name, qtex->name );
|
|
bf->x = coords[i].x;
|
|
bf->y = coords[i].y;
|
|
bf->w = coords[i].w;
|
|
bf->h = coords[i].h;
|
|
//
|
|
// write it out
|
|
//
|
|
printf( "writing %s\n", filename );
|
|
SaveFile( filename, (byte *)qtex, size );
|
|
|
|
free( qtex );
|
|
}
|
|
}
|
|
// Set up descriptor
|
|
size = sizeof( bookframe_t ) * numrects;
|
|
|
|
book.bheader.ident = IDBOOKHEADER;
|
|
book.bheader.version = BOOK_VERSION;
|
|
book.bheader.num_segments = numrects;
|
|
book.bheader.total_w = w;
|
|
book.bheader.total_h = h;
|
|
memcpy( book.bframes, bframes, size );
|
|
|
|
// Save out segment descriptor
|
|
sprintf( filename, "%sBook/%s/%s.bk", gamedir, book_prefix, lumpname );
|
|
printf( "writing %s\n", filename );
|
|
SaveFile( filename, (byte *)&book, size + sizeof( bookheader_t ) );
|
|
}
|
|
|
|
/*
|
|
===============
|
|
Cmd_picdir
|
|
===============
|
|
*/
|
|
void Cmd_Bookdir( void ){
|
|
char filename[1024];
|
|
|
|
GetScriptToken( false );
|
|
strcpy( book_prefix, token );
|
|
// create the directory if needed
|
|
sprintf( filename, "%sBook", gamedir );
|
|
Q_mkdir( filename );
|
|
sprintf( filename, "%sBook/%s", gamedir, book_prefix );
|
|
Q_mkdir( filename );
|
|
}
|
|
|
|
// end
|