void M_ScreenShot(void)
{
static int shot;
char *lbmname = NULL;
int startshot;
int success = 0;
if (!access_3ds(SCREENSHOT_DIR, 2))
{
startshot = shot; // CPhipps - prevent infinite loop
do {
int size = doom_snprintf(NULL, 0, "%s/doom%02d" SCREENSHOT_EXT, SCREENSHOT_DIR, shot);
lbmname = realloc(lbmname, size+1);
doom_snprintf(lbmname, size+1, "%s/doom%02d" SCREENSHOT_EXT, SCREENSHOT_DIR, shot);
shot++;
} while (!access_3ds(lbmname, 0) && (shot != startshot) && (shot < 10000));
if (access_3ds(lbmname, 0))
{
S_StartSound(NULL,gamemode==commercial ? sfx_radio : sfx_tink);
M_DoScreenShot(lbmname); // cph
success = 1;
}
free(lbmname);
if (success) return;
}
doom_printf ("M_ScreenShot: Couldn't create screenshot");
return;
}
void Z_DumpMemory(void)
{
static int dump;
char *buf;
int len;
FILE* fp;
size_t total_cache = 0, total_free = 0, total_malloc = 0;
int tag;
len = doom_snprintf(NULL, 0, "%s/memdump.%d", HEAPDUMP_DIR, dump);
buf = malloc(len+1);
doom_snprintf(buf, len+1, "%s/memdump.%d", HEAPDUMP_DIR, dump);
fp = fopen(buf, "w");
for (tag = PU_FREE; tag < PU_MAX; tag++)
{
memblock_t* end_block, *block;
block = blockbytag[tag];
if (!block)
continue;
end_block = block->prev;
while (1)
{
switch (block->tag) {
case PU_FREE:
fprintf(fp, "free %d\n", block->size);
total_free += block->size;
break;
case PU_CACHE:
fprintf(fp, "cache %s:%d:%d\n", block->file, block->line, block->size);
total_cache += block->size;
break;
case PU_LEVEL:
fprintf(fp, "level %s:%d:%d\n", block->file, block->line, block->size);
total_malloc += block->size;
break;
default:
fprintf(fp, "malloc %s:%d:%d", block->file, block->line, block->size);
total_malloc += block->size;
if (block->file)
if (strstr(block->file,"w_memcache.c"))
W_PrintLump(fp, (char*)block + HEADER_SIZE);
fputc('\n', fp);
break;
}
if (block == end_block)
break;
block=block->next;
}
}
fprintf(fp, "malloc %d, cache %d, free %d, total %d\n",
total_malloc, total_cache, total_free,
total_malloc + total_cache + total_free);
fclose(fp);
free(buf);
dump++;
}
/*
* runs on each tic when recording checksums
*/
void checksum_gamestate(int tic) {
int i;
struct MD5Context md5ctx;
unsigned char digest[16];
char buffer[2048];
fprintf(outfile,"%6d, ", tic);
/* based on "ArchivePlayers" */
MD5Init(&md5ctx);
for (i=0 ; i<MAXPLAYERS ; i++) {
if (!playeringame[i]) continue;
doom_snprintf (buffer, sizeof(buffer), "%d", players[i].health);
buffer[sizeof(buffer)-1] = 0;
MD5Update(&md5ctx, (md5byte const *)&buffer, strlen(buffer));
}
MD5Final(digest, &md5ctx);
for (i=0; i<16; i++) {
MD5Update(&md5global, (md5byte const *)&digest[i], sizeof(digest[i]));
fprintf(outfile,"%x", digest[i]);
}
fprintf(outfile,"\n");
}
// %w video width (px)
// %h video height (px)
// %s sound rate (hz)
// %f filename passed to -viddump
// %% single percent sign
// TODO: add aspect ratio information
static int parsecommand (char *out, const char *in, int len)
{
int i;
while (*in && len > 1)
{
if (*in == '%')
{
switch (in[1])
{
case 'w':
i = doom_snprintf (out, len, "%u", REAL_SCREENWIDTH);
break;
case 'h':
i = doom_snprintf (out, len, "%u", REAL_SCREENHEIGHT);
break;
case 's':
i = doom_snprintf (out, len, "%u", snd_samplerate);
break;
case 'f':
i = doom_snprintf (out, len, "%s", vid_fname);
break;
case '%':
i = doom_snprintf (out, len, "%%");
break;
default:
return 0;
}
out += i;
len -= i;
in += 2;
}
else
{
*out++ = *in++;
len--;
}
}
if (*in || len < 1)
{ // out of space
return 0;
}
*out = 0;
return 1;
}
/* cphipps - I_SigString
* Returns a string describing a signal number
*/
const char* I_SigString(char* buf, size_t sz, int signum)
{
#if HAVE_DECL_SYS_SIGLIST // NSM: automake defines this symbol as 0 or 1
if (strlen(sys_siglist[signum]) < sz)
strcpy(buf,sys_siglist[signum]);
else
#endif
doom_snprintf(buf,sz,"signal %d",signum);
return buf;
}
/* cphipps - I_GetVersionString
* Returns a version string in the given buffer
*/
const char* I_GetVersionString(char* buf, size_t sz)
{
doom_snprintf(buf,sz,"%s v%s (http://prboom.sourceforge.net/)",PACKAGE,VERSION);
return buf;
}
void e6y_WriteStats(void)
{
FILE *f;
char str[200];
int i, level, playerscount;
timetable_t max;
tmpdata_t tmp;
tmpdata_t all[32];
size_t allkills_len=0, allitems_len=0, allsecrets_len=0;
f = fopen("levelstat.txt", "wb");
memset(&max, 0, sizeof(timetable_t));
playerscount = 0;
for (i=0; i<MAXPLAYERS; i++)
if (playeringame[i])
playerscount++;
for (level=0;level<numlevels;level++)
{
memset(&tmp, 0, sizeof(tmpdata_t));
for (i=0 ; i<MAXPLAYERS ; i++)
{
if (playeringame[i])
{
char strtmp[200];
strcpy(str, tmp.kill[0] == '\0' ? "%s%d" : "%s+%d");
doom_snprintf(strtmp, sizeof(strtmp), str, tmp.kill, stats[level].kill[i]);
strcpy(tmp.kill, strtmp);
doom_snprintf(strtmp, sizeof(strtmp), str, tmp.item, stats[level].item[i]);
strcpy(tmp.item, strtmp);
doom_snprintf(strtmp, sizeof(strtmp), str, tmp.secret, stats[level].secret[i]);
strcpy(tmp.secret, strtmp);
}
}
if (playerscount<2)
memset(&all[level], 0, sizeof(tmpdata_t));
else
{
sprintf(all[level].kill, " (%s)", tmp.kill );
sprintf(all[level].item, " (%s)", tmp.item );
sprintf(all[level].secret, " (%s)", tmp.secret);
}
if (strlen(all[level].kill) > allkills_len)
allkills_len = strlen(all[level].kill);
if (strlen(all[level].item) > allitems_len)
allitems_len = strlen(all[level].item);
if (strlen(all[level].secret) > allsecrets_len)
allsecrets_len = strlen(all[level].secret);
for(i=0; i<TT_MAX; i++)
if (stats[level].stat[i] > max.stat[i])
max.stat[i] = stats[level].stat[i];
}
max.stat[TT_TIME] = max.stat[TT_TIME]/TICRATE/60;
max.stat[TT_TOTALTIME] = max.stat[TT_TOTALTIME]/TICRATE/60;
for(i=0; i<TT_MAX; i++) {
doom_snprintf(str, 200, "%d", max.stat[i]);
max.stat[i] = strlen(str);
}
for (level=0;level<numlevels;level++)
{
sprintf(str,
"%%s - %%%dd:%%05.2f (%%%dd:%%02d) K: %%%dd/%%-%dd%%%ds I: %%%dd/%%-%dd%%%ds S: %%%dd/%%-%dd %%%ds\r\n",
max.stat[TT_TIME], max.stat[TT_TOTALTIME],
max.stat[TT_ALLKILL], max.stat[TT_TOTALKILL], allkills_len,
max.stat[TT_ALLITEM], max.stat[TT_TOTALITEM], allitems_len,
max.stat[TT_ALLSECRET], max.stat[TT_TOTALSECRET], allsecrets_len);
fprintf(f, str, stats[level].map,
stats[level].stat[TT_TIME]/TICRATE/60,
(float)(stats[level].stat[TT_TIME]%(60*TICRATE))/TICRATE,
(stats[level].stat[TT_TOTALTIME])/TICRATE/60,
(stats[level].stat[TT_TOTALTIME]%(60*TICRATE))/TICRATE,
stats[level].stat[TT_ALLKILL], stats[level].stat[TT_TOTALKILL], all[level].kill,
stats[level].stat[TT_ALLITEM], stats[level].stat[TT_TOTALITEM], all[level].item,
stats[level].stat[TT_ALLSECRET],stats[level].stat[TT_TOTALSECRET], all[level].secret
);
}
fclose(f);
}
//
// I_FillScreenResolutionsList
// Get all the supported screen resolutions
// and fill the list with them
//
static void I_FillScreenResolutionsList(void)
{
SDL_Rect **modes;
int i, j, list_size, current_resolution_index, count;
char mode[256];
Uint32 flags;
// do it only once
if (screen_resolutions_list[0])
{
return;
}
if (desired_screenwidth == 0 || desired_screenheight == 0)
{
I_GetScreenResolution();
}
flags = SDL_FULLSCREEN;
#ifdef GL_DOOM
flags |= SDL_OPENGL;
#endif
// Don't call SDL_ListModes if SDL has not been initialized
if (!nodrawers)
modes = SDL_ListModes(NULL, flags);
else
modes = NULL;
list_size = 0;
current_resolution_index = -1;
if (modes)
{
count = 0;
for(i = 0; modes[i]; i++)
{
count++;
}
// (-2) is for NULL at the end of list and for custom resolution
count = MIN(count, MAX_RESOLUTIONS_COUNT - 2);
for(i = count - 1; i >= 0; i--)
{
int in_list = false;
doom_snprintf(mode, sizeof(mode), "%dx%d", modes[i]->w, modes[i]->h);
if (i == count - 1)
{
screen_resolution_lowest = strdup(mode);
}
for(j = 0; j < list_size; j++)
{
if (!strcmp(mode, screen_resolutions_list[j]))
{
in_list = true;
break;
}
}
if (!in_list)
{
screen_resolutions_list[list_size] = strdup(mode);
if (modes[i]->w == desired_screenwidth && modes[i]->h == desired_screenheight)
{
current_resolution_index = list_size;
}
list_size++;
}
}
screen_resolutions_list[list_size] = NULL;
}
if (list_size == 0)
{
doom_snprintf(mode, sizeof(mode), "%dx%d", desired_screenwidth, desired_screenheight);
screen_resolutions_list[0] = strdup(mode);
current_resolution_index = 0;
list_size = 1;
}
if (current_resolution_index == -1)
{
doom_snprintf(mode, sizeof(mode), "%dx%d", desired_screenwidth, desired_screenheight);
// make it first
list_size++;
for(i = list_size - 1; i > 0; i--)
{
screen_resolutions_list[i] = screen_resolutions_list[i - 1];
}
screen_resolutions_list[0] = strdup(mode);
current_resolution_index = 0;
}
screen_resolutions_list[list_size] = NULL;
screen_resolution = screen_resolutions_list[current_resolution_index];
}
void R_InitTranMap(int progress)
{
int lump = W_CheckNumForName("TRANMAP");
// If a tranlucency filter map lump is present, use it
if (lump != -1) // Set a pointer to the translucency filter maps.
main_tranmap = W_CacheLumpNum(lump); // killough 4/11/98
else if (W_CheckNumForName("PLAYPAL")!=-1) // can be called before WAD loaded
{ // Compose a default transparent filter map based on PLAYPAL.
const byte *playpal = W_CacheLumpName("PLAYPAL");
byte *my_tranmap;
char *fname;
int fnlen;
struct {
unsigned char pct;
unsigned char playpal[256];
} cache;
FILE *cachefp;
fnlen = doom_snprintf(NULL, 0, "%s/tranmap.dat", I_DoomExeDir());
fname = malloc(fnlen+1);
doom_snprintf(fname, fnlen+1, "%s/tranmap.dat", I_DoomExeDir());
cachefp = fopen(fname, "rb");
main_tranmap = my_tranmap = Z_Malloc(256*256, PU_STATIC, 0); // killough 4/11/98
// Use cached translucency filter if it's available
if (!cachefp ||
fread(&cache, 1, sizeof cache, cachefp) != sizeof cache ||
cache.pct != tran_filter_pct ||
memcmp(cache.playpal, playpal, sizeof cache.playpal) ||
fread(my_tranmap, 256, 256, cachefp) != 256 ) // killough 4/11/98
{
long pal[3][256], tot[256], pal_w1[3][256];
long w1 = ((unsigned long) tran_filter_pct<<TSC)/100;
long w2 = (1l<<TSC)-w1;
if (progress)
lprintf(LO_INFO, "Tranmap build [ ]\x08\x08\x08\x08\x08\x08\x08\x08\x08");
// First, convert playpal into long int type, and transpose array,
// for fast inner-loop calculations. Precompute tot array.
{
register int i = 255;
register const unsigned char *p = playpal+255*3;
do
{
register long t,d;
pal_w1[0][i] = (pal[0][i] = t = p[0]) * w1;
d = t*t;
pal_w1[1][i] = (pal[1][i] = t = p[1]) * w1;
d += t*t;
pal_w1[2][i] = (pal[2][i] = t = p[2]) * w1;
d += t*t;
p -= 3;
tot[i] = d << (TSC-1);
}
while (--i>=0);
}
// Next, compute all entries using minimum arithmetic.
{
int i,j;
byte *tp = my_tranmap;
for (i=0;i<256;i++)
{
long r1 = pal[0][i] * w2;
long g1 = pal[1][i] * w2;
long b1 = pal[2][i] * w2;
if (!(i & 31) && progress)
//jff 8/3/98 use logical output routine
lprintf(LO_INFO,".");
for (j=0;j<256;j++,tp++)
{
register int color = 255;
register long err;
long r = pal_w1[0][j] + r1;
long g = pal_w1[1][j] + g1;
long b = pal_w1[2][j] + b1;
long best = LONG_MAX;
do
if ((err = tot[color] - pal[0][color]*r
- pal[1][color]*g - pal[2][color]*b) < best)
best = err, *tp = color;
while (--color >= 0);
}
}
}
if ((cachefp = fopen(fname,"wb")) != NULL) // write out the cached translucency map
{
cache.pct = tran_filter_pct;
memcpy(cache.playpal, playpal, 256);
fseek(cachefp, 0, SEEK_SET);
fwrite(&cache, 1, sizeof cache, cachefp);
fwrite(main_tranmap, 256, 256, cachefp);
// CPhipps - leave close for a few lines...
}
}
if (cachefp) // killough 11/98: fix filehandle leak
fclose(cachefp);
free(fname);
W_UnlockLumpName("PLAYPAL");
}
}
static GLShader* gld_LoadShader(const char *vpname, const char *fpname)
{
#define buffer_size 2048
int idx;
int linked;
char buffer[buffer_size];
char *vp_data = NULL;
char *fp_data = NULL;
int vp_size, fp_size;
size_t vp_fnlen, fp_fnlen;
char *filename = NULL;
GLShader* shader = NULL;
vp_fnlen = doom_snprintf(NULL, 0, "%s/shaders/%s.txt", I_DoomExeDir(), vpname);
fp_fnlen = doom_snprintf(NULL, 0, "%s/shaders/%s.txt", I_DoomExeDir(), fpname);
filename = malloc(MAX(vp_fnlen, fp_fnlen) + 1);
sprintf(filename, "%s/shaders/%s.txt", I_DoomExeDir(), vpname);
vp_size = ReadLump(filename, vpname, &vp_data);
sprintf(filename, "%s/shaders/%s.txt", I_DoomExeDir(), fpname);
fp_size = ReadLump(filename, fpname, &fp_data);
if (vp_data && fp_data)
{
shader = calloc(1, sizeof(GLShader));
shader->hVertProg = GLEXT_glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);
shader->hFragProg = GLEXT_glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);
GLEXT_glShaderSourceARB(shader->hVertProg, 1, &vp_data, &vp_size);
GLEXT_glShaderSourceARB(shader->hFragProg, 1, &fp_data, &fp_size);
GLEXT_glCompileShaderARB(shader->hVertProg);
GLEXT_glCompileShaderARB(shader->hFragProg);
shader->hShader = GLEXT_glCreateProgramObjectARB();
GLEXT_glAttachObjectARB(shader->hShader, shader->hVertProg);
GLEXT_glAttachObjectARB(shader->hShader, shader->hFragProg);
GLEXT_glLinkProgramARB(shader->hShader);
GLEXT_glGetInfoLogARB(shader->hShader, buffer_size, NULL, buffer);
GLEXT_glGetObjectParameterivARB(shader->hShader, GL_OBJECT_LINK_STATUS_ARB, &linked);
if (linked)
{
lprintf(LO_INFO, "gld_LoadShader: Shader \"%s+%s\" compiled OK: %s\n", vpname, fpname, buffer);
shader->lightlevel_index = GLEXT_glGetUniformLocationARB(shader->hShader, "lightlevel");
GLEXT_glUseProgramObjectARB(shader->hShader);
idx = GLEXT_glGetUniformLocationARB(shader->hShader, "tex");
GLEXT_glUniform1iARB(idx, 0);
GLEXT_glUseProgramObjectARB(0);
}
else
{
lprintf(LO_ERROR, "gld_LoadShader: Error compiling shader \"%s+%s\": %s\n", vpname, fpname, buffer);
free(shader);
shader = NULL;
}
}
free(filename);
free(vp_data);
free(fp_data);
return shader;
}
void M_LoadDefaults (void)
{
int i;
int len;
FILE* f;
char def[80];
char strparm[100];
char* newstring = NULL; // killough
int parm;
boolean isstring;
// set everything to base values
numdefaults = sizeof(defaults) / sizeof(defaults[0]);
for (i = 0 ; i < numdefaults ; i++) {
if (defaults[i].location.ppsz)
*defaults[i].location.ppsz = strdup(defaults[i].defaultvalue.psz);
if (defaults[i].location.pi)
*defaults[i].location.pi = defaults[i].defaultvalue.i;
}
// check for a custom default file
#if ((defined GL_DOOM) && (defined _MSC_VER))
#define BOOM_CFG "glboom.cfg"
#else
#define BOOM_CFG "prboom.cfg"
#endif
i = M_CheckParm ("-config");
if (i && i < myargc-1)
defaultfile = strdup(myargv[i+1]);
else {
const char* exedir = I_DoomExeDir();
/* get config file from same directory as executable */
#if 1
int len = doom_snprintf(NULL, 0, BOOM_CFG);
defaultfile = malloc(len+1);
doom_snprintf(defaultfile, len+1, BOOM_CFG);
#else
int len = doom_snprintf(NULL, 0, "%s/" BOOM_CFG, exedir);
defaultfile = malloc(len+1);
doom_snprintf(defaultfile, len+1, "%s/" BOOM_CFG, exedir);
#endif
}
lprintf (LO_CONFIRM, " default file: %s\n",defaultfile);
// read the file in, overriding any set defaults
f = fopen (defaultfile, "r");
if (f)
{
while (!feof(f))
{
isstring = false;
if (fscanf (f, "%79s %[^\n]\n", def, strparm) == 2)
{
//jff 3/3/98 skip lines not starting with an alphanum
if (!isalnum(def[0]))
continue;
if (strparm[0] == '"') {
// get a string default
isstring = true;
len = strlen(strparm);
newstring = (char *) malloc(len);
strparm[len-1] = 0; // clears trailing double-quote mark
strcpy(newstring, strparm+1); // clears leading double-quote mark
} else if ((strparm[0] == '0') && (strparm[1] == 'x')) {
// CPhipps - allow ints to be specified in hex
sscanf(strparm+2, "%x", &parm);
} else {
sscanf(strparm, "%i", &parm);
// Keycode hack removed
}
for (i = 0 ; i < numdefaults ; i++)
if ((defaults[i].type != def_none) && !strcmp(def, defaults[i].name))
{
// CPhipps - safety check
if (isstring != IS_STRING(defaults[i])) {
lprintf(LO_WARN, "M_LoadDefaults: Type mismatch reading %s\n", defaults[i].name);
continue;
}
if (!isstring)
{
//jff 3/4/98 range check numeric parameters
if ((defaults[i].minvalue==UL || defaults[i].minvalue<=parm) &&
(defaults[i].maxvalue==UL || defaults[i].maxvalue>=parm))
*(defaults[i].location.pi) = parm;
}
else
{
union { const char **c; char **s; } u; // type punning via unions
u.c = defaults[i].location.ppsz;
free(*(u.s));
*(u.s) = newstring;
}
break;
}
}
}
fclose (f);
}
//jff 3/4/98 redundant range checks for hud deleted here
}
