Files
SRB2Kart-Saturn/src/m_perfstats.c
T
alufolie91 b85a4b3034 WIP: OpenGL water refraction
tries to replicate the effect from software renderer
this is quite a mess, but finally feel like pushing this since i finally figured out the depth testing stuff
this still has some issues:
-map geometry in front of skybox water will just draw over it completely (not super sure how to fix this other than deferring water rendering after rendering both skybox and normal scene)
-translucent geometry is not included in refraction (and may draw in front of it?), software also suffers from this in certain cases, i just hope its not that visible

this really needs a cleanup at some point
and due to how this is setup for floor and ceiling planes this also costs quite a lot of gpu time (atleast on the cpu side this costs barely anything)
2026-07-14 09:46:19 +02:00

1096 lines
30 KiB
C

// SONIC ROBO BLAST 2
//-----------------------------------------------------------------------------
// Copyright (C) 2020-2023 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
// See the 'LICENSE' file for more details.
//-----------------------------------------------------------------------------
/// \file m_perfstats.c
/// \brief Performance measurement tools.
#include "m_perfstats.h"
#include "p_mobj.h"
#include "v_video.h"
#include "i_video.h"
#include "d_netcmd.h"
#include "r_main.h"
#include "i_system.h"
#include "z_zone.h"
#include "p_local.h"
#include "r_fps.h"
#ifdef HWRENDER
#include "hardware/hw_main.h"
#endif
struct perfstatrow;
typedef struct perfstatrow perfstatrow_t;
struct perfstatrow {
const char * lores_label;
const char * hires_label;
ps_metric_t * metric;
UINT8 flags;
};
// perfstatrow_t flags
#define PS_TIME 1 // metric measures time (uses precise_t instead of INT32)
#define PS_LEVEL 2 // metric is valid only when a level is active
#define PS_SW 4 // metric is valid only in software mode
#define PS_HW 8 // metric is valid only in opengl mode
#define PS_BATCHING 16 // metric is valid only when opengl batching is active
#define PS_HIDE_ZERO 32 // hide metric if its value is zero
static ps_metric_t ps_frametime = {0};
ps_metric_t ps_tictime = {0};
ps_metric_t ps_prevtictime = {0};
ps_metric_t ps_playerthink_time = {0};
ps_metric_t ps_thinkertime = {0};
//ps_metric_t ps_thlist_times[NUM_THINKERLISTS];
static ps_metric_t ps_thinkercount = {0};
static ps_metric_t ps_mobjcount = {0};
static ps_metric_t ps_regularcount = {0};
static ps_metric_t ps_scenerycount = {0};
static ps_metric_t ps_nothinkcount = {0};
static ps_metric_t ps_otherthcount = {0};
static ps_metric_t ps_precipcount = {0};
static ps_metric_t ps_removecount = {0};
ps_metric_t ps_checkposition_calls = {0};
ps_metric_t ps_lua_prethinkframe_time = {0};
ps_metric_t ps_lua_thinkframe_time = {0};
ps_metric_t ps_lua_postthinkframe_time = {0};
ps_metric_t ps_lua_mobjhooks = {0};
ps_metric_t ps_otherlogictime = {0};
// Columns for perfstats pages.
// Position on screen is determined separately in the drawing functions.
// New columns must also be added to the drawing and update functions.
// Drawing functions: PS_DrawRenderStats, PS_DrawGameLogicStats, etc.
// Update functions:
// - PS_UpdateFrameStats for frame-dependent values
// - PS_UpdateTickStats for tick-dependent values
// Rendering stats columns
perfstatrow_t rendertime_rows[] = {
{"frmtime", "Frame time: ", &ps_frametime, PS_TIME},
{"drwtime", "3d rendering: ", &ps_rendercalltime, PS_TIME|PS_LEVEL},
#ifdef HWRENDER
{" skybox ", " Skybox render: ", &ps_skyboxtime, PS_TIME|PS_LEVEL|PS_HW},
{" bsptime", " RenderBSPNode: ", &ps_bsptime, PS_TIME|PS_LEVEL|PS_HW},
{" batsort", " Batch sort: ", &ps_hw_batchsorttime, PS_TIME|PS_LEVEL|PS_HW|PS_BATCHING},
{" batdraw", " Batch render: ", &ps_hw_batchdrawtime, PS_TIME|PS_LEVEL|PS_HW|PS_BATCHING},
{" sprsort", " Sprite sort: ", &ps_hw_spritesorttime, PS_TIME|PS_LEVEL|PS_HW},
{" sprdraw", " Sprite render: ", &ps_hw_spritedrawtime, PS_TIME|PS_LEVEL|PS_HW},
{" nodesrt", " Drwnode sort: ", &ps_hw_nodesorttime, PS_TIME|PS_LEVEL|PS_HW},
{" nodedrw", " Drwnode render:", &ps_hw_nodedrawtime, PS_TIME|PS_LEVEL|PS_HW},
{" wtrdrw", " Water render: ", &ps_hw_waterdrawtime, PS_TIME|PS_LEVEL|PS_HW},
{" other ", " Other: ", &ps_otherrendertime, PS_TIME|PS_LEVEL|PS_HW},
#endif
{" skybox ", " Skybox render: ", &ps_skyboxtime, PS_TIME|PS_LEVEL|PS_SW},
{" bsptime", " RenderBSPNode: ", &ps_bsptime, PS_TIME|PS_LEVEL|PS_SW},
{" sprclip", " R_ClipSprites: ", &ps_sw_spritecliptime, PS_TIME|PS_LEVEL|PS_SW},
{" portals", " Portals: ", &ps_sw_portaltime, PS_TIME|PS_LEVEL|PS_SW},
{" planes ", " R_DrawPlanes: ", &ps_sw_planetime, PS_TIME|PS_LEVEL|PS_SW},
{" masked ", " R_DrawMasked: ", &ps_sw_maskedtime, PS_TIME|PS_LEVEL|PS_SW},
{" other ", " Other: ", &ps_otherrendertime, PS_TIME|PS_LEVEL|PS_SW},
{"ui ", "UI render: ", &ps_uitime, PS_TIME},
{"finupdt", "I_FinishUpdate:", &ps_swaptime, PS_TIME},
{}
};
perfstatrow_t gamelogicbrief_row[] = {
{"logic ", "Game logic: ", &ps_tictime, PS_TIME},
{}
};
perfstatrow_t commoncounter_rows[] = {
{"bspcall", "BSP calls: ", &ps_numbspcalls, 0},
{"sprites", "Sprites: ", &ps_numsprites, 0},
{"drwnode", "Drawnodes: ", &ps_numdrawnodes, 0},
{"plyobjs", "Polyobjects: ", &ps_numpolyobjects, 0},
{}
};
perfstatrow_t interpolation_rows[] = {
{"intpfrc", "Interp frac: ", &ps_interp_frac, 0},
{"intplag", "Interp lag: ", &ps_interp_lag, 0},
{}
};
#ifdef HWRENDER
perfstatrow_t batchcount_rows[] = {
{"polygon", "Polygons: ", &ps_hw_numpolys, 0},
{"vertex ", "Vertices: ", &ps_hw_numverts, 0},
{}
};
perfstatrow_t batchcalls_rows[] = {
{"drwcall", "Draw calls:", &ps_hw_numcalls, 0},
{"shaders", "Shaders: ", &ps_hw_numshaders, 0},
{"texture", "Textures: ", &ps_hw_numtextures, 0},
{"polyflg", "Polyflags: ", &ps_hw_numpolyflags, 0},
{"colors ", "Colors: ", &ps_hw_numcolors, 0},
{}
};
#endif
// Game logic stats columns
perfstatrow_t gamelogic_rows[] = {
{"logic ", "Game logic: ", &ps_tictime, PS_TIME},
{" plrthnk", " P_PlayerThink: ", &ps_playerthink_time, PS_TIME|PS_LEVEL},
{" thnkers", " P_RunThinkers: ", &ps_thinkertime, PS_TIME|PS_LEVEL},
/* {" plyobjs", " Polyobjects: ", &ps_thlist_times[THINK_POLYOBJ], PS_TIME|PS_LEVEL},
{" main ", " Main: ", &ps_thlist_times[THINK_MAIN], PS_TIME|PS_LEVEL},
{" mobjs ", " Mobjs: ", &ps_thlist_times[THINK_MOBJ], PS_TIME|PS_LEVEL},
{" dynslop", " Dynamic slopes: ", &ps_thlist_times[THINK_DYNSLOPE], PS_TIME|PS_LEVEL},
{" precip ", " Precipitation: ", &ps_thlist_times[THINK_PRECIP], PS_TIME|PS_LEVEL},*/
{" lprethinkf", " LUAh_PreThinkFrame:", &ps_lua_prethinkframe_time, PS_TIME|PS_LEVEL},
{" lthinkf", " LUAh_ThinkFrame:", &ps_lua_thinkframe_time, PS_TIME|PS_LEVEL},
{" lpostthinkf", " LUAh_PostThinkFrame:", &ps_lua_postthinkframe_time, PS_TIME|PS_LEVEL},
{" other ", " Other: ", &ps_otherlogictime, PS_TIME|PS_LEVEL},
{}
};
perfstatrow_t thinkercount_rows[] = {
{"thnkers", "Thinkers: ", &ps_thinkercount, PS_LEVEL},
{" mobjs ", " Mobjs: ", &ps_mobjcount, PS_LEVEL},
{" regular", " Regular: ", &ps_regularcount, PS_LEVEL},
{" scenery", " Scenery: ", &ps_scenerycount, PS_LEVEL},
{" nothink", " Nothink: ", &ps_nothinkcount, PS_HIDE_ZERO|PS_LEVEL},
{" precip ", " Precipitation: ", &ps_precipcount, PS_LEVEL},
{" other ", " Other: ", &ps_otherthcount, PS_LEVEL},
{" remove ", " Pending removal:", &ps_removecount, PS_LEVEL},
{}
};
perfstatrow_t misc_calls_rows[] = {
{"lmhook", "Lua mobj hooks: ", &ps_lua_mobjhooks, PS_LEVEL},
{"chkpos", "P_CheckPosition:", &ps_checkposition_calls, PS_LEVEL},
{}
};
// Sample collection status for averaging.
// Maximum of these two is shown to user if nonzero to tell that
// the reported averages are not correct yet.
int ps_frame_samples_left = 0;
int ps_tick_samples_left = 0;
// History writing positions for frame and tick based metrics
int ps_frame_index = 0;
int ps_tick_index = 0;
// dynamically allocated resizeable array for thinkframe hook stats
ps_hookinfo_t *prethinkframe_hooks = NULL;
int prethinkframe_hooks_length = 0;
int prethinkframe_hooks_capacity = 16;
ps_hookinfo_t *thinkframe_hooks = NULL;
int thinkframe_hooks_length = 0;
int thinkframe_hooks_capacity = 16;
ps_hookinfo_t *postthinkframe_hooks = NULL;
int postthinkframe_hooks_length = 0;
int postthinkframe_hooks_capacity = 16;
void PS_SetPreThinkFrameHookInfo(int index, precise_t time_taken, char* short_src)
{
if (!prethinkframe_hooks)
{
// array needs to be initialized
prethinkframe_hooks = Z_Calloc(sizeof(ps_hookinfo_t) * prethinkframe_hooks_capacity, PU_STATIC, NULL);
}
if (index >= prethinkframe_hooks_capacity)
{
// array needs more space, realloc with double size
int new_capacity = prethinkframe_hooks_capacity * 2;
prethinkframe_hooks = Z_Realloc(prethinkframe_hooks,
sizeof(ps_hookinfo_t) * new_capacity, PU_STATIC, NULL);
// initialize new memory with zeros so the pointers in the structs are null
memset(&prethinkframe_hooks[prethinkframe_hooks_capacity], 0,
sizeof(ps_hookinfo_t) * prethinkframe_hooks_capacity);
prethinkframe_hooks_capacity = new_capacity;
}
prethinkframe_hooks[index].time_taken.value.p = time_taken;
memcpy(prethinkframe_hooks[index].short_src, short_src, LUA_IDSIZE * sizeof(char));
// since the values are set sequentially from begin to end, the last call should leave
// the correct value to this variable
prethinkframe_hooks_length = index + 1;
}
void PS_SetThinkFrameHookInfo(int index, precise_t time_taken, char* short_src)
{
if (!thinkframe_hooks)
{
// array needs to be initialized
thinkframe_hooks = Z_Calloc(sizeof(ps_hookinfo_t) * thinkframe_hooks_capacity, PU_STATIC, NULL);
}
if (index >= thinkframe_hooks_capacity)
{
// array needs more space, realloc with double size
int new_capacity = thinkframe_hooks_capacity * 2;
thinkframe_hooks = Z_Realloc(thinkframe_hooks,
sizeof(ps_hookinfo_t) * new_capacity, PU_STATIC, NULL);
// initialize new memory with zeros so the pointers in the structs are null
memset(&thinkframe_hooks[thinkframe_hooks_capacity], 0,
sizeof(ps_hookinfo_t) * thinkframe_hooks_capacity);
thinkframe_hooks_capacity = new_capacity;
}
thinkframe_hooks[index].time_taken.value.p = time_taken;
memcpy(thinkframe_hooks[index].short_src, short_src, LUA_IDSIZE * sizeof(char));
// since the values are set sequentially from begin to end, the last call should leave
// the correct value to this variable
thinkframe_hooks_length = index + 1;
}
void PS_SetPostThinkFrameHookInfo(int index, precise_t time_taken, char* short_src)
{
if (!postthinkframe_hooks)
{
// array needs to be initialized
postthinkframe_hooks = Z_Calloc(sizeof(ps_hookinfo_t) * postthinkframe_hooks_capacity, PU_STATIC, NULL);
}
if (index >= postthinkframe_hooks_capacity)
{
// array needs more space, realloc with double size
int new_capacity = postthinkframe_hooks_capacity * 2;
postthinkframe_hooks = Z_Realloc(postthinkframe_hooks,
sizeof(ps_hookinfo_t) * new_capacity, PU_STATIC, NULL);
// initialize new memory with zeros so the pointers in the structs are null
memset(&postthinkframe_hooks[postthinkframe_hooks_capacity], 0,
sizeof(ps_hookinfo_t) * postthinkframe_hooks_capacity);
postthinkframe_hooks_capacity = new_capacity;
}
postthinkframe_hooks[index].time_taken.value.p = time_taken;
memcpy(postthinkframe_hooks[index].short_src, short_src, LUA_IDSIZE * sizeof(char));
// since the values are set sequentially from begin to end, the last call should leave
// the correct value to this variable
postthinkframe_hooks_length = index + 1;
}
static boolean PS_HighResolution(void)
{
return (vid.width >= 640 && vid.height >= 400);
}
static boolean PS_IsLevelActive(void)
{
return gamestate == GS_LEVEL;
}
// Is the row valid in the current context?
static boolean PS_IsRowValid(perfstatrow_t *row)
{
return !((row->flags & PS_LEVEL && !PS_IsLevelActive())
|| (row->flags & PS_SW && rendermode != render_soft)
|| (row->flags & PS_HW && rendermode != render_opengl)
#ifdef HWRENDER
|| (row->flags & PS_BATCHING && !cv_glbatching.value)
#endif
);
}
// Should the row be visible on the screen?
static boolean PS_IsRowVisible(perfstatrow_t *row)
{
boolean value_is_zero;
if (row->flags & PS_TIME)
value_is_zero = row->metric->value.p == 0;
else
value_is_zero = row->metric->value.i == 0;
return !(!PS_IsRowValid(row) ||
(row->flags & PS_HIDE_ZERO && value_is_zero));
}
typedef union
{
char *c;
UINT32 *i;
precise_t *p;
} history_read_pos_t;
static INT32 PS_GetMetricAverage(ps_metric_t *metric, boolean time_metric)
{
history_read_pos_t history_read_pos;
history_read_pos.c = metric->history; // char* used for pointer arithmetic
INT64 sum = 0;
int i;
int value_size = time_metric ? sizeof(precise_t) : sizeof(INT32);
for (i = 0; i < cv_ps_samplesize.value; i++)
{
if (time_metric)
sum += *history_read_pos.p / (I_GetPrecisePrecision() / 1000000);
else
sum += *history_read_pos.i;
history_read_pos.c += value_size;
}
return sum / cv_ps_samplesize.value;
}
static INT32 PS_GetMetricMinOrMax(ps_metric_t *metric, boolean time_metric, boolean get_max)
{
history_read_pos_t history_read_pos;
history_read_pos.c = metric->history; // char* used for pointer arithmetic
INT32 found_value = get_max ? INT32_MIN : INT32_MAX;
int i;
int value_size = time_metric ? sizeof(precise_t) : sizeof(INT32);
for (i = 0; i < cv_ps_samplesize.value; i++)
{
INT32 value;
if (time_metric)
value = *history_read_pos.p / (I_GetPrecisePrecision() / 1000000);
else
value = *history_read_pos.i;
if ((get_max && value > found_value) ||
(!get_max && value < found_value))
{
found_value = value;
}
history_read_pos.c += value_size;
}
return found_value;
}
// Calculates the standard deviation for metric.
static INT32 PS_GetMetricSD(ps_metric_t *metric, boolean time_metric)
{
history_read_pos_t history_read_pos;
history_read_pos.c = metric->history; // char* used for pointer arithmetic
INT64 sum = 0;
int i;
int value_size = time_metric ? sizeof(precise_t) : sizeof(INT32);
INT32 avg = PS_GetMetricAverage(metric, time_metric);
for (i = 0; i < cv_ps_samplesize.value; i++)
{
INT64 value;
if (time_metric)
value = *history_read_pos.p / (I_GetPrecisePrecision() / 1000000);
else
value = *history_read_pos.i;
value -= avg;
sum += value * value;
history_read_pos.c += value_size;
}
return round(sqrt((double)sum / (double)cv_ps_samplesize.value));
}
// Returns the value to show on screen for metric.
static INT32 PS_GetMetricScreenValue(ps_metric_t *metric, boolean time_metric)
{
if (cv_ps_samplesize.value > 1 && metric->history)
{
switch (cv_ps_descriptor.value)
{
case 1:
return PS_GetMetricAverage(metric, time_metric);
case 2:
return PS_GetMetricSD(metric, time_metric);
case 3:
return PS_GetMetricMinOrMax(metric, time_metric, false);
default:
return PS_GetMetricMinOrMax(metric, time_metric, true);
}
}
else
{
if (time_metric)
return (metric->value.p) / (I_GetPrecisePrecision() / 1000000);
else
return metric->value.i;
}
}
static int PS_DrawPerfRows(int x, int y, int color, perfstatrow_t *rows)
{
const boolean hires = PS_HighResolution();
INT32 draw_flags = V_MONOSPACE | color;
perfstatrow_t * row;
int draw_y = y;
if (hires)
draw_flags |= V_ALLOWLOWERCASE;
for (row = rows; row->lores_label; ++row)
{
const char *label;
INT32 value;
char *final_str;
if (!PS_IsRowVisible(row))
continue;
label = hires ? row->hires_label : row->lores_label;
value = PS_GetMetricScreenValue(row->metric, !!(row->flags & PS_TIME));
final_str = va("%s %d", label, value);
if (hires)
{
V_DrawSmallString(x, draw_y, draw_flags, final_str);
draw_y += 5;
}
else
{
V_DrawThinString(x, draw_y, draw_flags, final_str);
draw_y += 8;
}
}
return draw_y;
}
static void PS_UpdateMetricHistory(ps_metric_t *metric, boolean time_metric, boolean frame_metric)
{
int index = frame_metric ? ps_frame_index : ps_tick_index;
if (!metric->history)
{
// allocate history table
int value_size = time_metric ? sizeof(precise_t) : sizeof(INT32);
void** memory_user = &metric->history;
metric->history = Z_Calloc(value_size * cv_ps_samplesize.value, PU_PERFSTATS,
memory_user);
// reset "samples left" counter since this history table needs to be filled
if (frame_metric)
ps_frame_samples_left = cv_ps_samplesize.value;
else
ps_tick_samples_left = cv_ps_samplesize.value;
}
if (time_metric)
{
precise_t *history = (precise_t*)metric->history;
history[index] = metric->value.p;
}
else
{
INT32 *history = (INT32*)metric->history;
history[index] = metric->value.i;
}
}
static void PS_UpdateRowHistories(perfstatrow_t *rows, boolean frame_metric)
{
perfstatrow_t *row;
for (row = rows; row->lores_label; row++)
{
if (PS_IsRowValid(row))
PS_UpdateMetricHistory(row->metric, !!(row->flags & PS_TIME), frame_metric);
}
}
// Update all metrics that are calculated on every frame.
static void PS_UpdateFrameStats(void)
{
// update frame time
precise_t currenttime = I_GetPreciseTime();
ps_frametime.value.p = currenttime - ps_prevframetime;
ps_prevframetime = currenttime;
// update 3d rendering stats
if (PS_IsLevelActive())
{
// Remember to update this calculation when adding more 3d rendering stats!
ps_otherrendertime.value.p = ps_rendercalltime.value.p - ps_bsptime.value.p;
#ifdef HWRENDER
if (rendermode == render_opengl)
{
ps_otherrendertime.value.p -=
ps_skyboxtime.value.p +
ps_hw_nodesorttime.value.p +
ps_hw_nodedrawtime.value.p +
ps_hw_waterdrawtime.value.p +
ps_hw_spritesorttime.value.p +
ps_hw_spritedrawtime.value.p;
if (cv_glbatching.value)
{
ps_otherrendertime.value.p -=
ps_hw_batchsorttime.value.p +
ps_hw_batchdrawtime.value.p;
}
}
else
#endif
{
ps_otherrendertime.value.p -=
ps_skyboxtime.value.p +
ps_sw_spritecliptime.value.p +
ps_sw_portaltime.value.p +
ps_sw_planetime.value.p +
ps_sw_maskedtime.value.p;
}
}
if (cv_ps_samplesize.value > 1)
{
PS_UpdateRowHistories(rendertime_rows, true);
if (PS_IsLevelActive())
PS_UpdateRowHistories(commoncounter_rows, true);
if (R_UsingFrameInterpolation())
PS_UpdateRowHistories(interpolation_rows, true);
#ifdef HWRENDER
if (rendermode == render_opengl && cv_glbatching.value)
{
PS_UpdateRowHistories(batchcount_rows, true);
PS_UpdateRowHistories(batchcalls_rows, true);
}
#endif
ps_frame_index++;
if (ps_frame_index >= cv_ps_samplesize.value)
ps_frame_index = 0;
if (ps_frame_samples_left)
ps_frame_samples_left--;
}
}
// Update thinker counters by iterating the thinker lists.
static void PS_CountThinkers(void)
{
thinker_t *thinker;
ps_thinkercount.value.i = 0;
ps_mobjcount.value.i = 0;
ps_regularcount.value.i = 0;
ps_scenerycount.value.i = 0;
ps_nothinkcount.value.i = 0;
ps_precipcount.value.i = 0;
ps_otherthcount.value.i = 0;
ps_removecount.value.i = 0;
for (thinker = thinkercap.next; thinker != &thinkercap; thinker = thinker->next)
{
ps_thinkercount.value.i++;
if (thinker->function == (actionf_p1)P_RemoveThinkerDelayed)
ps_removecount.value.i++;
else if (thinker->function == (actionf_p1)P_MobjThinker)
{
mobj_t *mobj = (mobj_t*)thinker;
ps_mobjcount.value.i++;
if (mobj->flags & MF_NOTHINK)
ps_nothinkcount.value.i++;
else if (mobj->flags & MF_SCENERY)
ps_scenerycount.value.i++;
else
ps_regularcount.value.i++;
}
else
ps_otherthcount.value.i++;
}
for (thinker = precipcap.next; thinker != &precipcap; thinker = thinker->next)
{
if (thinker->function != (actionf_p1)P_NullPrecipThinker)
continue; // not a precipmobj thinker
ps_precipcount.value.i++;
}
/*for (i = 0; i < NUM_THINKERLISTS; i++)
{
for (thinker = thlist[i].next; thinker != &thlist[i]; thinker = thinker->next)
{
ps_thinkercount.value.i++;
if (thinker->function == (actionf_p1)P_RemoveThinkerDelayed)
ps_removecount.value.i++;
else if (i == THINK_POLYOBJ)
ps_polythcount.value.i++;
else if (i == THINK_MAIN)
ps_mainthcount.value.i++;
else if (i == THINK_MOBJ)
{
if (thinker->function == (actionf_p1)P_MobjThinker)
{
mobj_t *mobj = (mobj_t*)thinker;
ps_mobjcount.value.i++;
if (mobj->flags & MF_NOTHINK)
ps_nothinkcount.value.i++;
else if (mobj->flags & MF_SCENERY)
ps_scenerycount.value.i++;
else
ps_regularcount.value.i++;
}
}
else if (i == THINK_DYNSLOPE)
ps_dynslopethcount.value.i++;
else if (i == THINK_PRECIP)
ps_precipcount.value.i++;
}
}*/
}
// Update all metrics that are calculated on every tick.
void PS_UpdateTickStats(void)
{
if (cv_perfstats.value == 1 && cv_ps_samplesize.value > 1)
{
PS_UpdateRowHistories(gamelogicbrief_row, false);
}
if (cv_perfstats.value == 2)
{
if (PS_IsLevelActive())
{
ps_otherlogictime.value.p =
ps_tictime.value.p -
ps_playerthink_time.value.p -
ps_thinkertime.value.p -
ps_lua_prethinkframe_time.value.p -
ps_lua_thinkframe_time.value.p -
ps_lua_postthinkframe_time.value.p;
PS_CountThinkers();
}
if (cv_ps_samplesize.value > 1)
{
PS_UpdateRowHistories(gamelogic_rows, false);
PS_UpdateRowHistories(thinkercount_rows, false);
PS_UpdateRowHistories(misc_calls_rows, false);
}
}
if (cv_ps_samplesize.value > 1)
{
if (cv_perfstats.value >= 3 && PS_IsLevelActive())
{
int i;
switch (cv_perfstats.value)
{
case 3:
for (i = 0; i < thinkframe_hooks_length; i++)
{
PS_UpdateMetricHistory(&thinkframe_hooks[i].time_taken, true, false);
}
break;
case 4:
for (i = 0; i < prethinkframe_hooks_length; i++)
{
PS_UpdateMetricHistory(&prethinkframe_hooks[i].time_taken, true, false);
}
break;
case 5:
for (i = 0; i < postthinkframe_hooks_length; i++)
{
PS_UpdateMetricHistory(&postthinkframe_hooks[i].time_taken, true, false);
}
break;
default:
break;
}
}
if (cv_perfstats.value)
{
ps_tick_index++;
if (ps_tick_index >= cv_ps_samplesize.value)
ps_tick_index = 0;
if (ps_tick_samples_left)
ps_tick_samples_left--;
}
}
}
static void PS_DrawDescriptorHeader(void)
{
if (cv_ps_samplesize.value > 1)
{
const char* descriptor_names[] = {
"average",
"standard deviation",
"minimum",
"maximum"
};
const boolean hires = PS_HighResolution();
char* str;
INT32 flags = V_MONOSPACE | V_ALLOWLOWERCASE;
int samples_left = max(ps_frame_samples_left, ps_tick_samples_left);
int x, y;
if (cv_perfstats.value >= 3)
{
x = 2;
y = 0;
}
else
{
x = 20;
y = hires ? 5 : 2;
}
if (samples_left)
{
str = va("Samples needed for correct results: %d", samples_left);
flags |= V_REDMAP;
}
else
{
str = va("Showing the %s of %d samples.",
descriptor_names[cv_ps_descriptor.value - 1], cv_ps_samplesize.value);
flags |= V_GREENMAP;
}
if (hires)
V_DrawSmallString(x, y, flags, str);
else
V_DrawThinString(x, y, flags, str);
}
}
static void PS_DrawRenderStats(void)
{
const boolean hires = PS_HighResolution();
const int half_row = hires ? 5 : 4;
int x, y, cy = 10;
PS_DrawDescriptorHeader();
y = PS_DrawPerfRows(20, 10, V_YELLOWMAP, rendertime_rows);
PS_DrawPerfRows(20, y + half_row, V_GRAYMAP, gamelogicbrief_row);
if (PS_IsLevelActive())
{
x = hires ? 115 : 90;
cy = PS_DrawPerfRows(x, 10, V_BLUEMAP, commoncounter_rows) + half_row;
#ifdef HWRENDER
if (rendermode == render_opengl && cv_glbatching.value)
{
x = hires ? 200 : 155;
y = PS_DrawPerfRows(x, 10, V_PURPLEMAP, batchcount_rows);
x = hires ? 200 : 220;
y = hires ? y + half_row : 10;
PS_DrawPerfRows(x, y, V_PURPLEMAP, batchcalls_rows);
}
#endif
}
if (R_UsingFrameInterpolation())
{
x = hires ? 115 : 90;
PS_DrawPerfRows(x, cy, V_PEACHMAP, interpolation_rows);
}
}
static void PS_DrawGameLogicStats(void)
{
const boolean hires = PS_HighResolution();
int x, y;
PS_DrawDescriptorHeader();
PS_DrawPerfRows(20, 10, V_YELLOWMAP, gamelogic_rows);
x = hires ? 115 : 90;
PS_DrawPerfRows(x, 10, V_BLUEMAP, thinkercount_rows);
if (hires)
V_DrawSmallString(212, 10, V_MONOSPACE | V_ALLOWLOWERCASE | V_PURPLEMAP, "Calls:");
x = hires ? 216 : 170;
y = hires ? 15 : 10;
PS_DrawPerfRows(x, y, V_PURPLEMAP, misc_calls_rows);
}
// Maybe needs to be defined in header, with some prefix like PS_, but eh,
// works like that too. Just need to (un)define it outside so
// PS_ThinkFrame_Page_OnChange can see this too
#define WIDTH 106
#define HEIGHT 4
#define MAX_X 214
#define MAX_Y 182
#define START_X 2
#define START_Y 4
#define PAGE_ENTRIES ((MAX_Y - START_Y) / HEIGHT)
static void draw_think_frame_stats(int hook_length, ps_hookinfo_t *hook)
{
char s[100];
int i;
int maxpage = 0;
int page = 0;
int pagestart = 0;
int pageend = 0;
// text writing position
int x = START_X;
int y = START_Y;
UINT32 text_color;
char tempbuffer[LUA_IDSIZE];
char last_mod_name[LUA_IDSIZE];
last_mod_name[0] = '\0';
INT32 total = 0;
//Decide page length based and drawn text on choosen thinker type
switch (cv_perfstats.value)
{
case 3:
{
maxpage = thinkframe_hooks_length/PAGE_ENTRIES + 1;
page = max(1, min(cv_ps_thinkframe_page.value, maxpage));
pagestart = min((page - 1)*PAGE_ENTRIES, thinkframe_hooks_length);
pageend = min(pagestart + PAGE_ENTRIES, thinkframe_hooks_length);
V_DrawSmallString(MAX_X-50, MAX_Y+2*HEIGHT, V_MONOSPACE | V_GREENMAP, "ThinkFrame");
}
break;
case 4:
{
maxpage = prethinkframe_hooks_length/PAGE_ENTRIES + 1;
page = max(1, min(cv_ps_thinkframe_page.value, maxpage));
pagestart = min((page - 1)*PAGE_ENTRIES, prethinkframe_hooks_length);
pageend = min(pagestart + PAGE_ENTRIES, prethinkframe_hooks_length);
V_DrawSmallString(MAX_X-60, MAX_Y+2*HEIGHT, V_MONOSPACE | V_GREENMAP, "PreThinkFrame");
}
break;
case 5:
{
maxpage = postthinkframe_hooks_length/PAGE_ENTRIES + 1;
page = max(1, min(cv_ps_thinkframe_page.value, maxpage));
pagestart = min((page - 1)*PAGE_ENTRIES, postthinkframe_hooks_length);
pageend = min(pagestart + PAGE_ENTRIES, postthinkframe_hooks_length);
V_DrawSmallString(MAX_X-65, MAX_Y+2*HEIGHT, V_MONOSPACE | V_GREENMAP, "PostThinkFrame");
}
break;
default:
break;
}
PS_DrawDescriptorHeader();
for (i = 0; i < hook_length; i++)
{
#define NEXT_ROW() y += HEIGHT;
INT32 value = PS_GetMetricScreenValue(&hook[i].time_taken, true);
total += value;
if (i < pagestart || i >= pageend) continue;
char* str = hook[i].short_src;
char* tempstr = tempbuffer;
int len = (int)strlen(str);
char* str_ptr;
if (fastcmp(".lua", str + len - 4))
{
str[len-4] = '\0'; // remove .lua at end
}
// Print wad name first.
strcpy(tempstr, str);
str_ptr = strrchr(tempstr, '|');
if (str_ptr)
{
*str_ptr = '\0';
str = str_ptr + 1; // this is the name of the hook without the mod file name
str_ptr = strrchr(tempstr, PATHSEP[0]);
if (str_ptr)
tempstr = str_ptr + 1;
// tempstr should now point to the mod name, (wad/pk3) possibly truncated
strcpy(last_mod_name, tempstr);
len = (int)strlen(tempstr);
if (len > 30)
tempstr += len - 30;
snprintf(s, sizeof s - 1, "%s", tempstr);
V_DrawSmallString(x, y, V_MONOSPACE | V_ALLOWLOWERCASE | V_GRAYMAP, s);
text_color = V_YELLOWMAP;
}
else
{
// probably a standalone lua file
// cut off the folder if it's there
str_ptr = strrchr(tempstr, PATHSEP[0]);
if (str_ptr)
str = str_ptr + 1;
text_color = 0; // white
}
len = (int)strlen(str);
if (len > 40)
str += len - 40;
snprintf(s, sizeof s - 1, "%40s: %d", str, value);
V_DrawSmallString(x + WIDTH, y, V_MONOSPACE | V_ALLOWLOWERCASE | text_color, s);
NEXT_ROW()
#undef NEXT_ROW
}
snprintf(s, sizeof s - 1, "TOTAL %d", total);
V_DrawSmallString(MAX_X, MAX_Y+2*HEIGHT, V_MONOSPACE | V_GREENMAP, s);
if (maxpage > 1)
{
snprintf(s, sizeof s - 1, "PAGE %d", page);
V_DrawSmallString(START_X, MAX_Y+2*HEIGHT, V_MONOSPACE | V_GREENMAP, s);
}
}
void PS_ThinkFrame_Page_OnChange(void)
{
int maxpage = thinkframe_hooks_length/PAGE_ENTRIES + 1;
if (cv_ps_thinkframe_page.value > maxpage)
CV_StealthSetValue(&cv_ps_thinkframe_page, maxpage);
}
#undef WIDTH
#undef HEIGHT
#undef MAX_X
#undef MAX_Y
#undef START_X
#undef START_Y
#undef PAGE_ENTRIES
static void PS_DrawPreThinkFrameStats(void)
{
draw_think_frame_stats(prethinkframe_hooks_length, prethinkframe_hooks);
}
static void PS_DrawThinkFrameStats(void)
{
draw_think_frame_stats(thinkframe_hooks_length, thinkframe_hooks);
}
static void PS_DrawPostThinkFrameStats(void)
{
draw_think_frame_stats(postthinkframe_hooks_length, postthinkframe_hooks);
}
void M_DrawPerfStats(void)
{
if (cv_perfstats.value == 1) // rendering
{
PS_UpdateFrameStats();
PS_DrawRenderStats();
}
else if (cv_perfstats.value == 2) // logic
{
// PS_UpdateTickStats is called in TryRunTics, since otherwise it would miss
// tics when frame skips happen
PS_DrawGameLogicStats();
}
else if (cv_perfstats.value >= 3) // lua thinkframe
{
if (!PS_IsLevelActive())
return;
if (!PS_HighResolution())
{
// Low resolutions can't really use V_DrawSmallString that is used by thinkframe stats.
// A low-res version using V_DrawThinString could be implemented,
// but it would have much less space for information.
V_DrawThinString(80, 92, V_MONOSPACE | V_ALLOWLOWERCASE | V_YELLOWMAP, "Lua Perfstats is not available");
V_DrawThinString(80, 100, V_MONOSPACE | V_ALLOWLOWERCASE | V_YELLOWMAP, "for resolutions below 640x400.");
return;
}
switch (cv_perfstats.value)
{
case 3:
PS_DrawThinkFrameStats();
break;
case 4:
PS_DrawPreThinkFrameStats();
break;
case 5:
PS_DrawPostThinkFrameStats();
break;
default:
break;
}
}
}
// remove and unallocate history from all metrics
static void PS_ClearHistory(void)
{
int i;
Z_FreeTags(PU_PERFSTATS, PU_PERFSTATS);
// thinkframe hook metric history pointers need to be cleared manually
for (i = 0; i < prethinkframe_hooks_length; i++)
{
prethinkframe_hooks[i].time_taken.history = NULL;
}
for (i = 0; i < thinkframe_hooks_length; i++)
{
thinkframe_hooks[i].time_taken.history = NULL;
}
for (i = 0; i < postthinkframe_hooks_length; i++)
{
postthinkframe_hooks[i].time_taken.history = NULL;
}
ps_frame_index = ps_tick_index = 0;
// PS_UpdateMetricHistory will set these correctly when it runs
ps_frame_samples_left = ps_tick_samples_left = 0;
}
void PS_PerfStats_OnChange(void)
{
if (cv_perfstats.value && cv_ps_samplesize.value > 1)
PS_ClearHistory();
}
void PS_SampleSize_OnChange(void)
{
if (cv_ps_samplesize.value > 1)
PS_ClearHistory();
}