mirror of https://github.com/TTimo/GtkRadiant.git
699 lines
14 KiB
C
699 lines
14 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"
|
|
#include "flex.h"
|
|
|
|
#define MAXFILES 2048
|
|
|
|
typedef struct
|
|
{
|
|
int x;
|
|
int y;
|
|
int w;
|
|
int h;
|
|
int cw;
|
|
int ch;
|
|
int rw;
|
|
int index;
|
|
int depth;
|
|
int col;
|
|
int baseline;
|
|
char name[128];
|
|
} Coords;
|
|
|
|
int filenum;
|
|
int valid;
|
|
Coords in[MAXFILES];
|
|
Coords out;
|
|
char outscript[256];
|
|
char sourcedir[256];
|
|
char outusage[256];
|
|
char root[32];
|
|
|
|
int destsize = 0;
|
|
byte *pixels = NULL; // Buffer to load image
|
|
long *outpixels = NULL; // Buffer to store combined textures
|
|
long *usagemap = NULL; // Buffer of usage map
|
|
void *bmptemp = NULL; // Buffer of usage map
|
|
byte *map = NULL;
|
|
|
|
int xcharsize;
|
|
int ycharsize;
|
|
int dosort = 0;
|
|
int missed = 0;
|
|
int overlap = 0;
|
|
int nobaseline = 0;
|
|
int percent;
|
|
|
|
//////////////////////////////////////////////////
|
|
// Setting the char based usage map //
|
|
//////////////////////////////////////////////////
|
|
|
|
byte TryPlace(Coords *coord)
|
|
{
|
|
int x, y;
|
|
byte entry = 0;
|
|
byte *mapitem;
|
|
|
|
mapitem = map + (coord->x / xcharsize) + ((coord->y / ycharsize) * out.cw);
|
|
|
|
for (y = 0; y < coord->ch; y++, mapitem += out.cw - coord->cw)
|
|
{
|
|
for (x = 0; x < coord->cw; x++)
|
|
{
|
|
if (entry |= *mapitem++ & 8)
|
|
{
|
|
return(entry);
|
|
}
|
|
}
|
|
}
|
|
return(entry);
|
|
}
|
|
|
|
void SetMap(Coords *coord)
|
|
{
|
|
int x, y;
|
|
byte *mapitem;
|
|
|
|
mapitem = map + (coord->x / xcharsize) + ((coord->y / ycharsize) * out.cw);
|
|
|
|
for (y = 0; y < coord->ch; y++, mapitem += out.cw - coord->cw)
|
|
for (x = 0; x < coord->cw; x++)
|
|
*mapitem++ |= 8;
|
|
}
|
|
|
|
//////////////////////////////////////////////////
|
|
// Setting the pixel based usage map //
|
|
//////////////////////////////////////////////////
|
|
|
|
void CheckOverlap(Coords *coord)
|
|
{
|
|
int x;
|
|
int y;
|
|
long *dest;
|
|
|
|
x = coord->x;
|
|
y = coord->y;
|
|
|
|
dest = (long *)(usagemap + x + (y * out.w));
|
|
|
|
for (y = 0; y < coord->h; y++, dest += out.w - coord->w)
|
|
{
|
|
for (x = 0; x < coord->w; x++)
|
|
{
|
|
if (*dest++)
|
|
{
|
|
overlap++;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void SetUsageMap(Coords *coord)
|
|
{
|
|
int x;
|
|
int y;
|
|
long *dest;
|
|
|
|
x = coord->x;
|
|
y = coord->y;
|
|
|
|
dest = (long *)(usagemap + x + (y * out.w));
|
|
|
|
for (y = 0; y < coord->h; y++, dest += out.w - coord->w)
|
|
{
|
|
for (x = 0; x < coord->w; x++)
|
|
{
|
|
*dest++ = coord->col;
|
|
}
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////////////
|
|
// Flips the BMP image to the correct way up //
|
|
//////////////////////////////////////////////////
|
|
|
|
void CopyLine(byte *dest, byte *src, int size)
|
|
{
|
|
int x;
|
|
|
|
for (x = 0; x < size; x++)
|
|
*dest++ = *src++;
|
|
}
|
|
|
|
/****************************************************/
|
|
/* Printing headers etc */
|
|
/****************************************************/
|
|
|
|
void RemoveLeading(char *name)
|
|
{
|
|
int i;
|
|
char temp[128];
|
|
|
|
for(i = strlen(name) - 1; i > 0; i--)
|
|
{
|
|
if((name[i] == '\\') || (name[i] == '/'))
|
|
{
|
|
strcpy(temp, name + i + 1);
|
|
strcpy(name, temp);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
void RemoveExt(char *name)
|
|
{
|
|
while ((*name != '.') && *name)
|
|
name++;
|
|
*name = 0;
|
|
}
|
|
|
|
/****************************************************/
|
|
/* Misc calcualtions */
|
|
/****************************************************/
|
|
|
|
int TotalArea()
|
|
{
|
|
int i;
|
|
int total = 0;
|
|
|
|
for (i = 0; i < (filenum + 2); i++)
|
|
total += in[i].w * in[i].h;
|
|
|
|
return(total);
|
|
}
|
|
|
|
/****************************************************/
|
|
/* Setup and checking of all info */
|
|
/****************************************************/
|
|
|
|
void InitVars()
|
|
{
|
|
filenum = 0;
|
|
valid = 0;
|
|
dosort = 0;
|
|
missed = 0;
|
|
overlap = 0;
|
|
nobaseline = 0;
|
|
|
|
memset(outscript, 0, sizeof(outscript));
|
|
memset(outscript, 0, sizeof(sourcedir));
|
|
memset(outscript, 0, sizeof(outusage));
|
|
memset(outscript, 0, sizeof(root));
|
|
|
|
memset(in, 0, sizeof(in));
|
|
memset(&out, 0, sizeof(out));
|
|
}
|
|
void Cleanup()
|
|
{
|
|
if (pixels)
|
|
free(pixels);
|
|
if (usagemap)
|
|
free(usagemap);
|
|
if (outpixels)
|
|
free(outpixels);
|
|
if (bmptemp)
|
|
free(bmptemp);
|
|
if (map)
|
|
free(map);
|
|
}
|
|
|
|
typedef struct glxy_s
|
|
{
|
|
float xl, yt, xr, yb;
|
|
int w, h, baseline;
|
|
} glxy_t;
|
|
|
|
int SaveScript(char *name)
|
|
{
|
|
FILE *fp;
|
|
int i, j;
|
|
glxy_t buff;
|
|
|
|
if(fp = fopen(name, "wb"))
|
|
{
|
|
for (j = 0; j < filenum; j++)
|
|
{
|
|
for (i = 0; i < filenum; i++)
|
|
{
|
|
if (in[i].index == j)
|
|
{
|
|
if (in[i].depth)
|
|
{
|
|
buff.xl = (float)in[i].x / (float)out.w;
|
|
buff.yt = (float)in[i].y / (float)out.h;
|
|
buff.xr = ((float)in[i].w + (float)in[i].x) / (float)out.w;
|
|
buff.yb = ((float)in[i].h + (float)in[i].y) / (float)out.h;
|
|
buff.w = in[i].w;
|
|
buff.h = in[i].h;
|
|
buff.baseline = in[i].baseline;
|
|
}
|
|
else
|
|
{
|
|
memset(&buff, 0, sizeof(glxy_t));
|
|
}
|
|
fwrite(&buff, 1, sizeof(glxy_t), fp);
|
|
i = filenum;
|
|
}
|
|
}
|
|
}
|
|
fclose(fp);
|
|
return(true);
|
|
}
|
|
else
|
|
return(false);
|
|
}
|
|
|
|
int GetScriptInfo(char *name)
|
|
{
|
|
FILE *fp;
|
|
char buffer[256];
|
|
char tempbuff[256];
|
|
char delims[] = {" \t,\n"};
|
|
|
|
printf("Opening script file %s.\n", name);
|
|
|
|
if (fp = fopen(name, "r"))
|
|
{
|
|
while(fgets(buffer, 256, fp))
|
|
{
|
|
if (strncmp(buffer, "//", 2) && strncmp(buffer, "\n", 1))
|
|
{
|
|
strupr(buffer);
|
|
strcpy(tempbuff, buffer);
|
|
if (strcmp(strtok(tempbuff, delims), "OUTPUT") == 0)
|
|
{
|
|
strcpy(out.name, strtok(NULL, delims));
|
|
strlwr(out.name);
|
|
}
|
|
|
|
strcpy(tempbuff, buffer);
|
|
if (strcmp(strtok(tempbuff, delims), "SOURCEDIR") == 0)
|
|
{
|
|
strcpy(tempbuff, strtok(NULL, delims));
|
|
strcpy(sourcedir, ExpandPathAndArchive(tempbuff));
|
|
}
|
|
|
|
strcpy(tempbuff, buffer);
|
|
if (strcmp(strtok(tempbuff, delims), "DOSORT") == 0)
|
|
dosort = 1;
|
|
|
|
strcpy(tempbuff, buffer);
|
|
if (strcmp(strtok(tempbuff, delims), "XCHARSIZE") == 0)
|
|
xcharsize = strtol(strtok(NULL, delims), NULL, 0);
|
|
|
|
strcpy(tempbuff, buffer);
|
|
if (strcmp(strtok(tempbuff, delims), "YCHARSIZE") == 0)
|
|
ycharsize = strtol(strtok(NULL, delims), NULL, 0);
|
|
|
|
strcpy(tempbuff, buffer);
|
|
if (strcmp(strtok(tempbuff, delims), "OUTSCRIPT") == 0)
|
|
{
|
|
strcpy(outscript, strtok(NULL, delims));
|
|
strlwr(outscript);
|
|
}
|
|
|
|
strcpy(tempbuff, buffer);
|
|
if (strcmp(strtok(tempbuff, delims), "OUTUSAGE") == 0)
|
|
strcpy(outusage, strtok(NULL, delims));
|
|
|
|
strcpy(tempbuff, buffer);
|
|
if (strcmp(strtok(tempbuff, delims), "POS") == 0)
|
|
{
|
|
out.w = strtol(strtok(NULL, delims), NULL, 0);
|
|
out.h = strtol(strtok(NULL, delims), NULL, 0);
|
|
}
|
|
|
|
strcpy(tempbuff, buffer);
|
|
if (strcmp(strtok(tempbuff, delims), "FILE") == 0)
|
|
{
|
|
strcpy(in[filenum].name, strtok(NULL, delims));
|
|
in[filenum].x = strtol(strtok(NULL, delims), NULL, 0);
|
|
in[filenum].y = strtol(strtok(NULL, delims), NULL, 0);
|
|
in[filenum].col = strtol(strtok(NULL, delims), NULL, 0);
|
|
filenum++;
|
|
}
|
|
}
|
|
}
|
|
fclose(fp);
|
|
return(true);
|
|
}
|
|
else
|
|
{
|
|
printf("ERROR : Could not open script file.\n");
|
|
return(false);
|
|
}
|
|
}
|
|
|
|
int CheckVars()
|
|
{
|
|
int i;
|
|
|
|
if (out.name[0] == 0)
|
|
{
|
|
printf("ERROR : No output name specified.\n");
|
|
return(false);
|
|
}
|
|
if ((out.w <= 0) || (out.h <= 0))
|
|
{
|
|
printf("ERROR : Invalid VRAM coordinates.\n");
|
|
return(false);
|
|
}
|
|
if (filenum == 0)
|
|
{
|
|
printf("ERROR : No input files specified.\n");
|
|
return(false);
|
|
}
|
|
for (i = 0; i < filenum; i++)
|
|
if (in[i].name[0] == 0)
|
|
{
|
|
printf("ERROR : Input filename invalid.\n");
|
|
return(false);
|
|
}
|
|
return(true);
|
|
}
|
|
|
|
// Makes sure texture is totally within the output area
|
|
|
|
int CheckCoords(Coords *coord)
|
|
{
|
|
if ((coord->x + coord->w) > out.w)
|
|
return(false);
|
|
if ((coord->y + coord->h) > out.h)
|
|
return(false);
|
|
|
|
return(true);
|
|
}
|
|
// Gets the width, height, palette width and palette height of each BMP file
|
|
|
|
int GetFileDimensions()
|
|
{
|
|
int i;
|
|
int width, height;
|
|
char name[128];
|
|
|
|
for (i = 0; i < filenum; i++)
|
|
{
|
|
in[i].index = i;
|
|
|
|
strcpy(name, sourcedir);
|
|
strcat(name, in[i].name);
|
|
printf("Getting file dimensions, file : %s \r", in[i].name);
|
|
if(FileExists(name))
|
|
{
|
|
LoadAnyImage(name, NULL, NULL, &width, &height);
|
|
in[i].depth = 32;
|
|
in[i].rw = width;
|
|
in[i].w = width; // makes it width in
|
|
in[i].h = height;
|
|
in[i].cw = (in[i].w + (xcharsize - 1)) / xcharsize;
|
|
in[i].ch = (in[i].h + (ycharsize - 1)) / ycharsize;
|
|
|
|
if (!CheckCoords(&in[i]) && (in[i].x >= 0))
|
|
{
|
|
printf("Error : texture %s out of bounds.\n", in[i].name);
|
|
return(false);
|
|
}
|
|
valid++;
|
|
}
|
|
else
|
|
{
|
|
in[i].depth = 0;
|
|
in[i].x = -1;
|
|
in[i].y = -1;
|
|
in[i].w = 0;
|
|
in[i].h = 0;
|
|
}
|
|
}
|
|
printf("\n\n");
|
|
return(true);
|
|
}
|
|
|
|
// Sorts files into order for optimal space finding
|
|
// Fixed position ones first, followed by the others in descending size
|
|
// The theory being that it is easier to find space for smaller textures.
|
|
// size = (width + height)
|
|
// For space finding it is easier to place a 32x32 than a 128x2
|
|
|
|
#define WEIGHT 0x8000
|
|
|
|
void Swap(Coords *a, Coords *b)
|
|
{
|
|
Coords c;
|
|
|
|
c = *a;
|
|
*a = *b;
|
|
*b = c;
|
|
}
|
|
|
|
void SortInNames()
|
|
{
|
|
int i, j;
|
|
int largest, largcount;
|
|
int size;
|
|
|
|
printf("Sorting filenames by size.\n\n");
|
|
|
|
for (j = 0; j < filenum; j++)
|
|
{
|
|
largest = -1;
|
|
largcount = -1;
|
|
|
|
for (i = j; i < filenum; i++)
|
|
{
|
|
if (in[i].depth)
|
|
{
|
|
size = in[i].w + in[i].h;
|
|
|
|
if ((in[i].x < 0) && (size > largest))
|
|
{
|
|
largcount = i;
|
|
largest = size;
|
|
}
|
|
}
|
|
}
|
|
if ((largcount >= 0) && (largcount != j))
|
|
Swap(&in[j], &in[largcount]);
|
|
}
|
|
}
|
|
|
|
int SetVars(char *name)
|
|
{
|
|
if (!GetScriptInfo(name))
|
|
return(false);
|
|
|
|
if (!CheckVars())
|
|
return(false);
|
|
|
|
destsize = out.w * out.h;
|
|
|
|
out.cw = out.w / xcharsize;
|
|
out.ch = out.h / ycharsize;
|
|
|
|
if ((usagemap = (long *)SafeMalloc(destsize * 4, "")) == NULL)
|
|
return(false);
|
|
if ((outpixels = (long *)SafeMalloc(destsize * 4, "")) == NULL)
|
|
return(false);
|
|
if ((bmptemp = (void *)SafeMalloc(destsize * 4, "")) == NULL)
|
|
return(false);
|
|
if ((map = (byte *)SafeMalloc(destsize / (xcharsize * ycharsize), "")) == NULL)
|
|
return(false);
|
|
|
|
if (GetFileDimensions() == false)
|
|
return(false);
|
|
|
|
if (dosort)
|
|
SortInNames();
|
|
|
|
return(true);
|
|
}
|
|
/****************************************************/
|
|
/* Actual copying routines */
|
|
/****************************************************/
|
|
|
|
int FindCoords(Coords *coord)
|
|
{
|
|
int tx, ty;
|
|
|
|
if (coord->x >= 0)
|
|
{
|
|
SetMap(coord);
|
|
return(true);
|
|
}
|
|
else
|
|
{
|
|
for (ty = 0; ty < out.ch; ty++)
|
|
{
|
|
for (tx = 0; tx < out.cw; tx++)
|
|
{
|
|
coord->x = (tx * xcharsize);
|
|
coord->y = (ty * ycharsize);
|
|
|
|
if (CheckCoords(coord) && !TryPlace(coord))
|
|
{
|
|
SetMap(coord);
|
|
return(true);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
coord->x = -1;
|
|
coord->y = -1;
|
|
|
|
return(false);
|
|
}
|
|
|
|
void CheckBaseline(int i)
|
|
{
|
|
int y;
|
|
long *pix;
|
|
|
|
in[i].baseline = -1;
|
|
pix = (long *)pixels;
|
|
|
|
for(y = 0; y < in[i].h; y++, pix += in[i].w)
|
|
{
|
|
if((*pix & 0x00ffffff) == 0x00ff00ff)
|
|
{
|
|
in[i].baseline = y;
|
|
break;
|
|
}
|
|
}
|
|
pix = (long *)pixels;
|
|
for(y = 0; y < in[i].w * in[i].h; y++, pix++)
|
|
{
|
|
if((*pix & 0x00ffffff) == 0x00ff00ff)
|
|
{
|
|
*pix = 0;
|
|
}
|
|
}
|
|
|
|
if(in[i].baseline == -1)
|
|
{
|
|
printf("\nERROR : %s has no baseline\n", in[i].name);
|
|
nobaseline++;
|
|
}
|
|
}
|
|
|
|
void CopyToMain32(Coords *coord)
|
|
{
|
|
int x;
|
|
int y;
|
|
long *source;
|
|
long *dest;
|
|
|
|
x = coord->x;
|
|
y = coord->y;
|
|
|
|
source = (long *)pixels;
|
|
dest = (long *)(outpixels + x + (y * out.w));
|
|
|
|
for (y = 0; y < coord->h; y++, dest += out.w - coord->w)
|
|
{
|
|
for (x = 0; x < coord->w; x++)
|
|
{
|
|
*dest++ = *source++;
|
|
}
|
|
}
|
|
}
|
|
|
|
void CreateMain()
|
|
{
|
|
int i, count;
|
|
int width, height;
|
|
char name[128];
|
|
|
|
for (i = 0, count = 0; i < filenum; i++)
|
|
{
|
|
if (in[i].depth)
|
|
{
|
|
printf("\rProcessing %d of %d (%d missed, %d overlapping, %d nobase)\r", count + 1, valid, missed, overlap, nobaseline);
|
|
count++;
|
|
if (!FindCoords(&in[i]))
|
|
missed++;
|
|
else
|
|
{
|
|
strcpy(name, sourcedir);
|
|
strcat(name, in[i].name);
|
|
LoadAnyImage(name, &pixels, NULL, &width, &height);
|
|
CheckBaseline(i);
|
|
CheckOverlap(&in[i]);
|
|
CopyToMain32(&in[i]);
|
|
SetUsageMap(&in[i]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void Cmd_TextureMix()
|
|
{
|
|
miptex32_t *qtex32;
|
|
char filename[1024];
|
|
int size;
|
|
|
|
InitVars();
|
|
|
|
GetScriptToken (false);
|
|
|
|
strcpy(root, token);
|
|
RemoveExt(root);
|
|
RemoveLeading(root);
|
|
|
|
strcpy(filename, ExpandPathAndArchive(token));
|
|
if (SetVars(filename))
|
|
{
|
|
// Create combined texture
|
|
percent = ((TotalArea() * 100) / (out.w * out.h));
|
|
printf("Total area consumed : %d%%\n", percent);
|
|
printf("Texture resolution : %dx%d pixels.\n", xcharsize, ycharsize);
|
|
CreateMain();
|
|
|
|
// Save image as m32
|
|
sprintf (filename, "%spics/misc/%s.m32", gamedir, out.name);
|
|
qtex32 = CreateMip32((unsigned *)outpixels, out.w, out.h, &size, false);
|
|
|
|
qtex32->contents = 0;
|
|
qtex32->value = 0;
|
|
qtex32->scale_x = 1.0;
|
|
qtex32->scale_y = 1.0;
|
|
sprintf (qtex32->name, "misc/%s", out.name);
|
|
|
|
printf ("\n\nwriting %s\n", filename);
|
|
SaveFile (filename, (byte *)qtex32, size);
|
|
free (qtex32);
|
|
|
|
// Save out script file
|
|
sprintf (filename, "%spics/misc/%s.fnt", gamedir, outscript);
|
|
printf("Writing %s as script file\n", filename);
|
|
if (!SaveScript(filename))
|
|
{
|
|
printf("Unable to save output script.\n");
|
|
}
|
|
}
|
|
printf("Everythings groovy.\n");
|
|
Cleanup();
|
|
}
|
|
|
|
// end
|
|
|