static gl3image_t *
LoadWal(char *origname)
{
miptex_t *mt;
int width, height, ofs;
gl3image_t *image;
char name[256];
Q_strlcpy(name, origname, sizeof(name));
/* Add the extension */
if (strcmp(COM_FileExtension(name), "wal"))
{
Q_strlcat(name, ".wal", sizeof(name));
}
ri.FS_LoadFile(name, (void **)&mt);
if (!mt)
{
R_Printf(PRINT_ALL, "LoadWal: can't load %s\n", name);
return gl3_notexture;
}
width = LittleLong(mt->width);
height = LittleLong(mt->height);
ofs = LittleLong(mt->offsets[0]);
image = GL3_LoadPic(name, (byte *)mt + ofs, width, 0, height, 0, it_wall, 8);
ri.FS_FreeFile((void *)mt);
return image;
}
/*
* origname: the filename to be opened, might be without extension
* type: extension of the type we wanna open ("jpg", "png" or "tga")
* pic: pointer RGBA pixel data will be assigned to
*/
qboolean
LoadSTB(const char *origname, const char* type, byte **pic, int *width, int *height)
{
char filename[256];
Q_strlcpy(filename, origname, sizeof(filename));
/* Add the extension */
if (strcmp(COM_FileExtension(filename), type) != 0)
{
Q_strlcat(filename, ".", sizeof(filename));
Q_strlcat(filename, type, sizeof(filename));
}
*pic = NULL;
byte* rawdata = NULL;
int rawsize = FS_LoadFile(filename, (void **)&rawdata);
if (rawdata == NULL)
{
return false;
}
int w, h, bytesPerPixel;
byte* data = NULL;
data = stbi_load_from_memory(rawdata, rawsize, &w, &h, &bytesPerPixel, STBI_rgb_alpha);
if (data == NULL)
{
VID_Printf(PRINT_ALL, "stb_image couldn't load data from %s: %s!\n", filename, stbi_failure_reason());
FS_FreeFile(rawdata);
return false;
}
FS_FreeFile(rawdata);
VID_Printf(PRINT_DEVELOPER, "LoadSTB() loaded: %s\n", filename);
*pic = data;
*width = w;
*height = h;
return true;
}
static qboolean IconOfSkinExists(char *skin, char **pcxfiles, int npcxfiles)
{
int i;
char scratch[MAX_OSPATH];
COM_StripExtension(scratch, skin, sizeof(scratch));
Q_strlcat(scratch, "_i.pcx", sizeof(scratch));
for (i = 0; i < npcxfiles; i++) {
if (strcmp(pcxfiles[i], scratch) == 0)
return qtrue;
}
return qfalse;
}
/*
==================
COM_DefaultExtension
if path doesn't have .EXT, append extension
(extension should include the .)
==================
*/
size_t COM_DefaultExtension( char *path, const char *ext, size_t size ) {
char *src;
size_t len;
if( *path ) {
len = strlen( path );
src = path + len - 1;
while( *src != '/' && src != path ) {
if( *src == '.' )
return len; // it has an extension
src--;
}
}
len = Q_strlcat( path, ext, size );
return len;
}
void
SV_WriteServerFile(qboolean autosave)
{
FILE *f;
cvar_t *var;
char name[MAX_OSPATH], string[128];
char comment[32];
time_t aclock;
struct tm *newtime;
Com_DPrintf("SV_WriteServerFile(%s)\n", autosave ? "true" : "false");
Com_sprintf(name, sizeof(name), "%s/save/current/server.ssv", FS_Gamedir());
f = fopen(name, "wb");
if (!f)
{
Com_Printf("Couldn't write %s\n", name);
return;
}
/* write the comment field */
memset(comment, 0, sizeof(comment));
if (!autosave)
{
time(&aclock);
newtime = localtime(&aclock);
Com_sprintf(comment, sizeof(comment), "%2i:%i%i %2i/%2i ",
newtime->tm_hour, newtime->tm_min / 10,
newtime->tm_min % 10, newtime->tm_mon + 1,
newtime->tm_mday);
Q_strlcat(comment, sv.configstrings[CS_NAME], sizeof(comment));
}
else
{
/* autosaved */
Com_sprintf(comment, sizeof(comment), "ENTERING %s",
sv.configstrings[CS_NAME]);
}
fwrite(comment, 1, sizeof(comment), f);
/* write the mapcmd */
fwrite(svs.mapcmd, 1, sizeof(svs.mapcmd), f);
/* write all CVAR_LATCH cvars
these will be things like coop,
skill, deathmatch, etc */
for (var = cvar_vars; var; var = var->next)
{
char cvarname[LATCH_CVAR_SAVELENGTH] = {0};
if (!(var->flags & CVAR_LATCH))
{
continue;
}
if ((strlen(var->name) >= sizeof(cvarname) - 1) ||
(strlen(var->string) >= sizeof(string) - 1))
{
Com_Printf("Cvar too long: %s = %s\n", var->name, var->string);
continue;
}
memset(string, 0, sizeof(string));
strcpy(cvarname, var->name);
strcpy(string, var->string);
fwrite(cvarname, 1, sizeof(cvarname), f);
fwrite(string, 1, sizeof(string), f);
}
fclose(f);
/* write game state */
Com_sprintf(name, sizeof(name), "%s/save/current/game.ssv", FS_Gamedir());
ge->WriteGame(name, autosave);
}
void LoadPCX(char *origname, byte **pic, byte **palette, int *width, int *height)
{
byte *raw;
pcx_t *pcx;
int x, y;
int len, full_size;
int pcx_width, pcx_height;
qboolean image_issues = false;
int dataByte, runLength;
byte *out, *pix;
char filename[256];
Q_strlcpy(filename, origname, sizeof(filename));
/* Add the extension */
if (strcmp(COM_FileExtension(filename), "pcx")) {
Q_strlcat(filename, ".pcx", sizeof(filename));
}
*pic = NULL;
if (palette) {
*palette = NULL;
}
/* load the file */
len = FS_LoadFile(filename, (void **) &raw);
if (!raw || len < sizeof(pcx_t)) {
R_Printf(PRINT_DEVELOPER, "Bad pcx file %s\n", filename);
return;
}
/* parse the PCX file */
pcx = (pcx_t *) raw;
pcx->xmin = LittleShort(pcx->xmin);
pcx->ymin = LittleShort(pcx->ymin);
pcx->xmax = LittleShort(pcx->xmax);
pcx->ymax = LittleShort(pcx->ymax);
pcx->hres = LittleShort(pcx->hres);
pcx->vres = LittleShort(pcx->vres);
pcx->bytes_per_line = LittleShort(pcx->bytes_per_line);
pcx->palette_type = LittleShort(pcx->palette_type);
raw = &pcx->data;
pcx_width = pcx->xmax - pcx->xmin;
pcx_height = pcx->ymax - pcx->ymin;
if ((pcx->manufacturer != 0x0a) || (pcx->version != 5) || (pcx->encoding != 1) || (pcx->bits_per_pixel != 8) ||
(pcx_width >= 4096) || (pcx_height >= 4096)) {
R_Printf(PRINT_ALL, "Bad pcx file %s\n", filename);
FS_FreeFile(pcx);
return;
}
full_size = (pcx_height + 1) * (pcx_width + 1);
out = malloc(full_size);
if (!out) {
R_Printf(PRINT_ALL, "Can't allocate\n");
FS_FreeFile(pcx);
return;
}
*pic = out;
pix = out;
if (palette) {
*palette = malloc(768);
if (!(*palette)) {
R_Printf(PRINT_ALL, "Can't allocate\n");
free(out);
FS_FreeFile(pcx);
return;
}
if (len > 768) {
memcpy(*palette, (byte *) pcx + len - 768, 768);
} else {
image_issues = true;
}
}
if (width) {
*width = pcx_width + 1;
}
if (height) {
*height = pcx_height + 1;
}
for (y = 0; y <= pcx_height; y++, pix += pcx_width + 1) {
for (x = 0; x <= pcx_width;) {
if (raw - (byte *) pcx > len) {
// no place for read
image_issues = true;
x = pcx_width;
break;
}
dataByte = *raw++;
if ((dataByte & 0xC0) == 0xC0) {
runLength = dataByte & 0x3F;
if (raw - (byte *) pcx > len) {
// no place for read
image_issues = true;
x = pcx_width;
break;
}
dataByte = *raw++;
} else {
runLength = 1;
}
while (runLength-- > 0) {
if ((*pic + full_size) <= (pix + x)) {
// no place for write
image_issues = true;
x += runLength;
runLength = 0;
} else {
pix[x++] = dataByte;
}
}
}
}
if (raw - (byte *) pcx > len) {
R_Printf(PRINT_DEVELOPER, "PCX file %s was malformed", filename);
free(*pic);
*pic = NULL;
}
if (image_issues) {
R_Printf(PRINT_ALL, "PCX file %s has possible size issues.\n", filename);
}
FS_FreeFile(pcx);
}
