mirror of
https://github.com/UberGames/GtkRadiant.git
synced 2024-11-15 00:42:03 +00:00
12b372f89c
git-svn-id: svn://svn.icculus.org/gtkradiant/GtkRadiant@1 8a3a26a2-13c4-0310-b231-cf6edde360e5
372 lines
7.9 KiB
C
372 lines
7.9 KiB
C
/*
|
|
Copyright (C) 1999-2006 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
|