2006-04-23 06:44:19 +00:00
|
|
|
#include "compat.h"
|
|
|
|
#include "osd.h"
|
|
|
|
#include "build.h"
|
|
|
|
#include "baselayer.h"
|
|
|
|
|
2012-11-25 04:26:37 +00:00
|
|
|
#include "renderlayer.h"
|
2006-04-23 06:44:19 +00:00
|
|
|
|
2012-12-14 19:28:17 +00:00
|
|
|
#include "a.h"
|
2009-08-09 05:32:17 +00:00
|
|
|
#include "polymost.h"
|
2018-04-05 04:39:30 +00:00
|
|
|
#include "cache1d.h"
|
2009-08-09 05:32:17 +00:00
|
|
|
|
2018-04-12 21:02:31 +00:00
|
|
|
// video
|
2018-04-12 21:02:18 +00:00
|
|
|
#ifdef _WIN32
|
|
|
|
extern "C"
|
|
|
|
{
|
|
|
|
__declspec(dllexport) int AmdPowerXpressRequestHighPerformance = 0x00000001;
|
|
|
|
__declspec(dllexport) DWORD NvOptimusEnablement = 0x00000001;
|
|
|
|
}
|
|
|
|
#endif // _WIN32
|
|
|
|
|
2018-04-12 21:02:31 +00:00
|
|
|
vec2_t const g_defaultVideoModes[]
|
|
|
|
= { { 2560, 1440 }, { 2560, 1200 }, { 2560, 1080 }, { 1920, 1440 }, { 1920, 1200 }, { 1920, 1080 }, { 1680, 1050 },
|
|
|
|
{ 1600, 1200 }, { 1600, 900 }, { 1366, 768 }, { 1280, 1024 }, { 1280, 960 }, { 1280, 720 }, { 1152, 864 },
|
|
|
|
{ 1024, 768 }, { 1024, 600 }, { 800, 600 }, { 640, 480 }, { 640, 400 }, { 512, 384 }, { 480, 360 },
|
|
|
|
{ 400, 300 }, { 320, 240 }, { 320, 200 }, { 0, 0 } };
|
2014-12-27 18:36:43 +00:00
|
|
|
|
2018-04-12 21:02:31 +00:00
|
|
|
// input
|
|
|
|
char inputdevices = 0;
|
2010-05-25 10:56:00 +00:00
|
|
|
|
2018-04-12 21:02:31 +00:00
|
|
|
char keystatus[NUMKEYS];
|
|
|
|
char g_keyFIFO[KEYFIFOSIZ];
|
|
|
|
char g_keyAsciiFIFO[KEYFIFOSIZ];
|
|
|
|
uint8_t g_keyFIFOend;
|
|
|
|
uint8_t g_keyAsciiPos;
|
|
|
|
uint8_t g_keyAsciiEnd;
|
|
|
|
char g_keyRemapTable[NUMKEYS];
|
|
|
|
char g_keyNameTable[NUMKEYS][24];
|
2010-05-25 10:56:00 +00:00
|
|
|
|
2018-04-12 21:02:31 +00:00
|
|
|
void (*keypresscallback)(int32_t, int32_t);
|
2010-07-03 08:53:57 +00:00
|
|
|
|
2018-04-12 21:02:31 +00:00
|
|
|
void keySetCallback(void (*callback)(int32_t, int32_t)) { keypresscallback = callback; }
|
2010-05-25 10:56:00 +00:00
|
|
|
|
2018-04-12 21:02:31 +00:00
|
|
|
char const g_keyAsciiTable[128] = {
|
|
|
|
0 , 0, '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '-', '=', 0, 0, 'q', 'w', 'e', 'r', 't', 'y', 'u', 'i', 'o', 'p',
|
2017-08-27 10:20:53 +00:00
|
|
|
'[', ']', 0, 0, 'a', 's', 'd', 'f', 'g', 'h', 'j', 'k', 'l', ';', 39, '`', 0, 92, 'z', 'x', 'c', 'v', 'b', 'n', 'm', ',',
|
|
|
|
'.', '/', 0, '*', 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, '7', '8', '9', '-', '4', '5', '6',
|
|
|
|
'+', '1', '2', '3', '0', '.', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
2018-04-12 21:02:31 +00:00
|
|
|
0 , 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
2008-07-02 01:32:53 +00:00
|
|
|
};
|
|
|
|
|
2018-04-12 21:02:31 +00:00
|
|
|
int32_t keyGetState(int32_t key) { return keystatus[g_keyRemapTable[key]]; }
|
2011-03-04 07:04:42 +00:00
|
|
|
|
2018-04-12 21:02:31 +00:00
|
|
|
void keySetState(int32_t key, int32_t state)
|
2010-05-25 10:56:00 +00:00
|
|
|
{
|
2018-04-12 21:02:31 +00:00
|
|
|
keystatus[g_keyRemapTable[key]] = state;
|
2010-05-25 10:56:00 +00:00
|
|
|
|
2011-01-16 02:50:27 +00:00
|
|
|
if (state)
|
2010-05-25 10:56:00 +00:00
|
|
|
{
|
2018-04-12 21:02:31 +00:00
|
|
|
g_keyFIFO[g_keyFIFOend] = g_keyRemapTable[key];
|
|
|
|
g_keyFIFO[(g_keyFIFOend+1)&(KEYFIFOSIZ-1)] = state;
|
|
|
|
g_keyFIFOend = ((g_keyFIFOend+2)&(KEYFIFOSIZ-1));
|
2010-05-25 10:56:00 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
2018-04-12 21:02:31 +00:00
|
|
|
// character-based input functions
|
2010-05-25 10:56:00 +00:00
|
|
|
//
|
2018-04-12 21:02:31 +00:00
|
|
|
char keyGetChar(void)
|
2010-05-25 10:56:00 +00:00
|
|
|
{
|
2018-04-12 21:02:31 +00:00
|
|
|
if (g_keyAsciiPos == g_keyAsciiEnd)
|
2010-05-25 10:56:00 +00:00
|
|
|
return 0;
|
|
|
|
|
2018-04-12 21:02:31 +00:00
|
|
|
char const c = g_keyAsciiFIFO[g_keyAsciiPos];
|
|
|
|
g_keyAsciiPos = ((g_keyAsciiPos + 1) & (KEYFIFOSIZ - 1));
|
|
|
|
|
|
|
|
return c;
|
2010-05-25 10:56:00 +00:00
|
|
|
}
|
|
|
|
|
2018-04-12 21:02:31 +00:00
|
|
|
void keyFlushChars(void)
|
2010-05-25 10:56:00 +00:00
|
|
|
{
|
2018-04-12 21:02:31 +00:00
|
|
|
Bmemset(&g_keyAsciiFIFO,0,sizeof(g_keyAsciiFIFO));
|
|
|
|
g_keyAsciiPos = g_keyAsciiEnd = 0;
|
2010-05-25 10:56:00 +00:00
|
|
|
}
|
|
|
|
|
2018-04-12 21:02:31 +00:00
|
|
|
const char *keyGetName(int32_t num) { return ((unsigned)num >= NUMKEYS) ? NULL : g_keyNameTable[num]; }
|
|
|
|
|
|
|
|
vec2_t g_mousePos;
|
|
|
|
vec2_t g_mouseAbs;
|
|
|
|
int32_t g_mouseBits;
|
|
|
|
uint8_t g_mouseClickState;
|
|
|
|
|
|
|
|
bool g_mouseEnabled;
|
|
|
|
bool g_mouseGrabbed;
|
|
|
|
bool g_mouseInsideWindow = 1;
|
|
|
|
bool g_mouseLockedToWindow = 1;
|
|
|
|
|
|
|
|
void (*g_mouseCallback)(int32_t, int32_t);
|
|
|
|
void mouseSetCallback(void(*callback)(int32_t, int32_t)) { g_mouseCallback = callback; }
|
|
|
|
|
|
|
|
int32_t mouseAdvanceClickState(void)
|
2010-05-25 10:56:00 +00:00
|
|
|
{
|
2018-04-12 21:02:31 +00:00
|
|
|
switch (g_mouseClickState)
|
|
|
|
{
|
|
|
|
case MOUSE_PRESSED: g_mouseClickState = MOUSE_HELD; return 1;
|
|
|
|
case MOUSE_RELEASED: g_mouseClickState = MOUSE_IDLE; return 1;
|
|
|
|
case MOUSE_HELD: return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
2010-05-25 10:56:00 +00:00
|
|
|
}
|
|
|
|
|
2018-04-12 21:02:31 +00:00
|
|
|
void mouseReadPos(int32_t *x, int32_t *y)
|
2011-04-07 01:16:29 +00:00
|
|
|
{
|
2018-04-12 21:02:31 +00:00
|
|
|
if (!g_mouseEnabled || !g_mouseGrabbed || !appactive)
|
|
|
|
{
|
|
|
|
*x = *y = 0;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
*x = g_mousePos.x;
|
|
|
|
*y = g_mousePos.y;
|
|
|
|
g_mousePos.x = g_mousePos.y = 0;
|
2011-04-07 01:16:29 +00:00
|
|
|
}
|
|
|
|
|
2018-04-12 21:02:31 +00:00
|
|
|
int32_t mouseReadAbs(vec2_t * const pResult, vec2_t const * const pInput)
|
2012-05-01 12:38:14 +00:00
|
|
|
{
|
2018-04-12 21:02:31 +00:00
|
|
|
if (!g_mouseEnabled || !appactive || !g_mouseInsideWindow || (osd && osd->flags & OSD_CAPTURE))
|
2014-11-17 07:39:12 +00:00
|
|
|
return 0;
|
|
|
|
|
2018-04-12 21:02:31 +00:00
|
|
|
int32_t const xwidth = max(scale(240<<16, xdim, ydim), 320<<16);
|
2014-11-17 07:39:12 +00:00
|
|
|
|
2018-07-14 21:36:44 +00:00
|
|
|
pResult->x = scale(pInput->x, xwidth, xres) - ((xwidth>>1) - (320<<15));
|
|
|
|
pResult->y = scale(pInput->y, 200<<16, yres);
|
2014-11-17 07:39:12 +00:00
|
|
|
|
|
|
|
return 1;
|
2012-05-01 12:38:14 +00:00
|
|
|
}
|
|
|
|
|
2018-04-12 21:02:31 +00:00
|
|
|
void mouseReadButtons(int32_t *pResult)
|
2011-04-07 01:16:29 +00:00
|
|
|
{
|
2018-04-12 21:02:31 +00:00
|
|
|
*pResult = (!g_mouseEnabled || !appactive || !g_mouseInsideWindow || (osd && osd->flags & OSD_CAPTURE)) ? 0 : g_mouseBits;
|
2011-04-07 01:16:29 +00:00
|
|
|
}
|
|
|
|
|
2018-04-12 21:02:31 +00:00
|
|
|
controllerinput_t joystick;
|
|
|
|
|
|
|
|
void joySetCallback(void (*callback)(int32_t, int32_t)) { joystick.pCallback = callback; }
|
|
|
|
void joyReadButtons(int32_t *pResult) { *pResult = appactive ? joystick.bits : 0; }
|
2012-06-03 16:11:22 +00:00
|
|
|
|
2017-02-19 22:15:44 +00:00
|
|
|
#if defined __linux || defined EDUKE32_BSD || defined __APPLE__
|
2014-11-02 05:36:28 +00:00
|
|
|
# include <sys/mman.h>
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if !defined(NOASM) && !defined(GEKKO) && !defined(__ANDROID__)
|
|
|
|
#ifdef __cplusplus
|
|
|
|
extern "C" {
|
|
|
|
#endif
|
|
|
|
extern intptr_t dep_begin, dep_end;
|
|
|
|
#ifdef __cplusplus
|
2014-11-26 04:39:23 +00:00
|
|
|
}
|
2014-11-02 05:36:28 +00:00
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
|
2014-11-02 05:44:27 +00:00
|
|
|
#if !defined(NOASM) && !defined(GEKKO) && !defined(__ANDROID__)
|
2016-05-29 21:11:24 +00:00
|
|
|
static int32_t nx_unprotect(intptr_t beg, intptr_t end, int prot)
|
2014-11-02 05:36:28 +00:00
|
|
|
{
|
|
|
|
# if defined _WIN32
|
2016-05-29 21:11:24 +00:00
|
|
|
# define B_PROT_RW PAGE_READWRITE
|
|
|
|
# define B_PROT_RX PAGE_EXECUTE_READ
|
|
|
|
# define B_PROT_RWX PAGE_EXECUTE_READWRITE
|
|
|
|
|
2014-11-02 05:36:28 +00:00
|
|
|
DWORD oldprot;
|
|
|
|
|
2016-05-29 21:11:24 +00:00
|
|
|
if (!VirtualProtect((LPVOID) beg, (SIZE_T)end - (SIZE_T)beg, prot, &oldprot))
|
2014-11-02 05:36:28 +00:00
|
|
|
{
|
|
|
|
initprintf("VirtualProtect() error! Crashing in 3... 2... 1...\n");
|
|
|
|
return 1;
|
|
|
|
}
|
2015-03-02 07:54:24 +00:00
|
|
|
# elif defined __linux || defined EDUKE32_BSD || defined __APPLE__
|
2016-05-29 21:11:24 +00:00
|
|
|
# define B_PROT_RW (PROT_READ|PROT_WRITE)
|
|
|
|
# define B_PROT_RX (PROT_READ|PROT_EXEC)
|
|
|
|
# define B_PROT_RWX (PROT_READ|PROT_WRITE|PROT_EXEC)
|
|
|
|
|
2014-11-02 05:36:28 +00:00
|
|
|
int32_t pagesize;
|
|
|
|
size_t dep_begin_page;
|
|
|
|
pagesize = sysconf(_SC_PAGE_SIZE);
|
|
|
|
if (pagesize == -1)
|
|
|
|
{
|
|
|
|
initprintf("Error getting system page size\n");
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
dep_begin_page = ((size_t)beg) & ~(pagesize-1);
|
2016-05-29 21:11:24 +00:00
|
|
|
if (mprotect((void *) dep_begin_page, (size_t)end - dep_begin_page, prot) < 0)
|
2014-11-02 05:36:28 +00:00
|
|
|
{
|
|
|
|
initprintf("Error making code writeable (errno=%d)\n", errno);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
# else
|
|
|
|
# error "Don't know how to unprotect the self-modifying assembly on this platform!"
|
|
|
|
# endif
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2014-11-02 05:44:27 +00:00
|
|
|
#endif
|
2014-11-02 05:36:28 +00:00
|
|
|
|
|
|
|
|
2012-12-14 19:28:17 +00:00
|
|
|
// Calculate ylookup[] and call setvlinebpl()
|
|
|
|
void calc_ylookup(int32_t bpl, int32_t lastyidx)
|
|
|
|
{
|
|
|
|
int32_t i, j=0;
|
2014-11-06 23:43:47 +00:00
|
|
|
static int32_t ylookupsiz;
|
2014-11-02 05:36:28 +00:00
|
|
|
|
2012-12-14 19:28:17 +00:00
|
|
|
Bassert(lastyidx <= MAXYDIM);
|
|
|
|
|
2014-11-06 23:43:47 +00:00
|
|
|
lastyidx++;
|
|
|
|
|
2014-10-29 17:04:28 +00:00
|
|
|
if (lastyidx > ylookupsiz)
|
|
|
|
{
|
2014-11-06 23:43:47 +00:00
|
|
|
Baligned_free(ylookup);
|
2014-10-29 17:04:28 +00:00
|
|
|
|
|
|
|
ylookup = (intptr_t *)Xaligned_alloc(16, lastyidx * sizeof(intptr_t));
|
|
|
|
ylookupsiz = lastyidx;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i=0; i<=lastyidx-4; i+=4)
|
|
|
|
{
|
|
|
|
ylookup[i] = j;
|
|
|
|
ylookup[i + 1] = j + bpl;
|
|
|
|
ylookup[i + 2] = j + (bpl << 1);
|
|
|
|
ylookup[i + 3] = j + (bpl * 3);
|
|
|
|
j += (bpl << 2);
|
|
|
|
}
|
|
|
|
|
2014-11-06 23:43:47 +00:00
|
|
|
for (; i<lastyidx; i++)
|
2012-12-14 19:28:17 +00:00
|
|
|
{
|
|
|
|
ylookup[i] = j;
|
|
|
|
j += bpl;
|
|
|
|
}
|
|
|
|
|
|
|
|
setvlinebpl(bpl);
|
|
|
|
}
|
|
|
|
|
2014-11-02 05:36:28 +00:00
|
|
|
|
|
|
|
void makeasmwriteable(void)
|
|
|
|
{
|
|
|
|
#if !defined(NOASM) && !defined(GEKKO) && !defined(__ANDROID__)
|
2016-05-29 21:11:24 +00:00
|
|
|
nx_unprotect((intptr_t)&dep_begin, (intptr_t)&dep_end, B_PROT_RWX);
|
2014-11-02 05:36:28 +00:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2016-11-15 21:55:30 +00:00
|
|
|
int32_t vsync=0;
|
2018-04-12 21:02:31 +00:00
|
|
|
int32_t g_logFlushWindow = 1;
|
2016-11-15 21:55:30 +00:00
|
|
|
|
2006-04-23 06:44:19 +00:00
|
|
|
#ifdef USE_OPENGL
|
2010-05-02 23:27:30 +00:00
|
|
|
struct glinfo_t glinfo =
|
2007-12-12 17:42:14 +00:00
|
|
|
{
|
2009-09-30 01:26:13 +00:00
|
|
|
"Unknown", // vendor
|
|
|
|
"Unknown", // renderer
|
|
|
|
"0.0.0", // version
|
|
|
|
"", // extensions
|
|
|
|
|
|
|
|
1.0, // max anisotropy
|
|
|
|
0, // brga texture format
|
|
|
|
0, // clamp-to-edge support
|
|
|
|
0, // texture compression
|
|
|
|
0, // non-power-of-two textures
|
|
|
|
0, // multisampling
|
|
|
|
0, // nvidia multisampling hint
|
|
|
|
0, // ARBfp
|
|
|
|
0, // depth textures
|
|
|
|
0, // shadow comparison
|
|
|
|
0, // Frame Buffer Objects
|
|
|
|
0, // rectangle textures
|
|
|
|
0, // multitexturing
|
|
|
|
0, // env_combine
|
|
|
|
0, // Vertex Buffer Objects
|
|
|
|
0, // VSync support
|
|
|
|
0, // Shader Model 4 support
|
|
|
|
0, // Occlusion Queries
|
|
|
|
0, // GLSL
|
2011-10-02 05:56:35 +00:00
|
|
|
0, // Debug Output
|
2015-07-25 17:23:17 +00:00
|
|
|
0, // Buffer storage
|
2018-02-16 06:38:48 +00:00
|
|
|
0, // Sync
|
2009-09-30 01:26:13 +00:00
|
|
|
0, // GL info dumped
|
2007-12-12 17:42:14 +00:00
|
|
|
};
|
2009-01-06 06:59:18 +00:00
|
|
|
|
2013-08-12 15:18:19 +00:00
|
|
|
// Used to register the game's / editor's osdcmd_vidmode() functions here.
|
2017-06-27 02:24:14 +00:00
|
|
|
int32_t (*baselayer_osdcmd_vidmode_func)(osdfuncparm_t const * const parm);
|
2013-08-12 15:18:19 +00:00
|
|
|
|
2017-06-27 02:24:14 +00:00
|
|
|
static int32_t osdfunc_setrendermode(osdfuncparm_t const * const parm)
|
2006-04-23 06:44:19 +00:00
|
|
|
{
|
2013-08-12 15:18:19 +00:00
|
|
|
if (parm->numparms != 1)
|
|
|
|
return OSDCMD_SHOWHELP;
|
|
|
|
|
2016-01-11 05:06:10 +00:00
|
|
|
char *p;
|
|
|
|
int32_t m = Bstrtol(parm->parms[0], &p, 10);
|
2006-04-23 06:44:19 +00:00
|
|
|
|
2013-08-12 15:18:19 +00:00
|
|
|
if (m != REND_CLASSIC && m != REND_POLYMOST && m != REND_POLYMER)
|
|
|
|
return OSDCMD_SHOWHELP;
|
|
|
|
|
|
|
|
if ((m==REND_CLASSIC) != (bpp==8) && baselayer_osdcmd_vidmode_func)
|
|
|
|
{
|
|
|
|
// Mismatch between video mode and requested renderer, do auto switch.
|
|
|
|
osdfuncparm_t parm;
|
|
|
|
char arg[4];
|
|
|
|
|
|
|
|
const char *ptrptr[1];
|
|
|
|
ptrptr[0] = arg;
|
|
|
|
|
|
|
|
Bmemset(&parm, 0, sizeof(parm));
|
|
|
|
|
|
|
|
if (m==REND_CLASSIC)
|
|
|
|
Bmemcpy(&arg, "8", 2);
|
|
|
|
else
|
|
|
|
Bmemcpy(&arg, "32", 3);
|
|
|
|
|
|
|
|
// CAUTION: we assume that the osdcmd_vidmode function doesn't use any
|
|
|
|
// other member!
|
|
|
|
parm.numparms = 1;
|
|
|
|
parm.parms = ptrptr;
|
|
|
|
|
|
|
|
baselayer_osdcmd_vidmode_func(&parm);
|
|
|
|
}
|
2006-04-23 06:44:19 +00:00
|
|
|
|
2018-04-12 21:03:47 +00:00
|
|
|
videoSetRenderMode(m);
|
2012-12-30 20:34:55 +00:00
|
|
|
|
2016-01-11 05:06:10 +00:00
|
|
|
char const *renderer;
|
|
|
|
|
2018-04-12 21:03:12 +00:00
|
|
|
switch (videoGetRenderMode())
|
2012-12-30 20:34:55 +00:00
|
|
|
{
|
|
|
|
case REND_CLASSIC:
|
2016-01-11 05:06:10 +00:00
|
|
|
renderer = "classic software";
|
2012-12-30 20:34:55 +00:00
|
|
|
break;
|
|
|
|
case REND_POLYMOST:
|
2016-01-11 05:06:10 +00:00
|
|
|
renderer = "polygonal OpenGL";
|
2012-12-30 20:34:55 +00:00
|
|
|
break;
|
2016-03-14 00:07:40 +00:00
|
|
|
#ifdef POLYMER
|
2012-12-30 20:34:55 +00:00
|
|
|
case REND_POLYMER:
|
2016-01-11 05:06:10 +00:00
|
|
|
renderer = "great justice (Polymer)";
|
2012-12-30 20:34:55 +00:00
|
|
|
break;
|
2016-03-14 00:07:40 +00:00
|
|
|
#endif
|
2016-01-12 10:31:19 +00:00
|
|
|
default:
|
|
|
|
EDUKE32_UNREACHABLE_SECTION(break);
|
2012-12-30 20:34:55 +00:00
|
|
|
}
|
|
|
|
|
2016-01-11 05:06:10 +00:00
|
|
|
OSD_Printf("Rendering method changed to %s\n", renderer);
|
2006-04-23 06:44:19 +00:00
|
|
|
|
2006-04-24 19:04:22 +00:00
|
|
|
return OSDCMD_OK;
|
2006-04-23 06:44:19 +00:00
|
|
|
}
|
2018-04-12 21:02:31 +00:00
|
|
|
|
2006-04-23 06:44:19 +00:00
|
|
|
#ifdef DEBUGGINGAIDS
|
2017-06-27 02:24:14 +00:00
|
|
|
static int32_t osdcmd_hicsetpalettetint(osdfuncparm_t const * const parm)
|
2006-04-23 06:44:19 +00:00
|
|
|
{
|
2017-12-12 05:13:58 +00:00
|
|
|
int32_t parms[8];
|
2006-04-24 19:04:22 +00:00
|
|
|
|
2017-12-12 05:13:58 +00:00
|
|
|
if (parm->numparms < 1 || (int32_t)ARRAY_SIZE(parms) < parm->numparms) return OSDCMD_SHOWHELP;
|
2006-04-24 19:04:22 +00:00
|
|
|
|
2017-12-12 05:13:58 +00:00
|
|
|
size_t i;
|
|
|
|
for (i = 0; (int32_t)i < parm->numparms; ++i)
|
|
|
|
parms[i] = Batol(parm->parms[i]);
|
|
|
|
for (; i < ARRAY_SIZE(parms); ++i)
|
|
|
|
parms[i] = 0;
|
2006-04-24 19:04:22 +00:00
|
|
|
|
2017-12-12 05:13:58 +00:00
|
|
|
// order is intentional
|
|
|
|
hicsetpalettetint(parms[0],parms[1],parms[2],parms[3],parms[5],parms[6],parms[7],parms[4]);
|
2006-04-24 19:04:22 +00:00
|
|
|
|
|
|
|
return OSDCMD_OK;
|
2006-04-23 06:44:19 +00:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2017-06-27 02:24:14 +00:00
|
|
|
int32_t osdcmd_glinfo(osdfuncparm_t const * const UNUSED(parm))
|
2006-04-23 06:44:19 +00:00
|
|
|
{
|
2017-06-27 02:24:14 +00:00
|
|
|
UNREFERENCED_CONST_PARAMETER(parm);
|
2008-03-22 10:23:57 +00:00
|
|
|
|
2007-12-12 17:42:14 +00:00
|
|
|
if (bpp == 8)
|
|
|
|
{
|
2015-02-11 05:23:04 +00:00
|
|
|
initprintf("glinfo: not in OpenGL mode!\n");
|
2006-04-24 19:04:22 +00:00
|
|
|
return OSDCMD_OK;
|
|
|
|
}
|
|
|
|
|
2015-02-11 05:23:04 +00:00
|
|
|
initprintf("OpenGL information\n %s %s %s\n",
|
|
|
|
glinfo.vendor, glinfo.renderer, glinfo.version);
|
2008-07-09 23:25:38 +00:00
|
|
|
|
|
|
|
if (!glinfo.dumped)
|
|
|
|
return OSDCMD_OK;
|
|
|
|
|
2018-04-12 21:02:31 +00:00
|
|
|
char const *s[] = { "supported", "not supported" };
|
|
|
|
|
|
|
|
#define SUPPORTED(x) (x ? s[0] : s[1])
|
|
|
|
|
|
|
|
initprintf(" BGRA textures: %s\n", SUPPORTED(glinfo.bgra));
|
|
|
|
initprintf(" Non-power-of-2 textures: %s\n", SUPPORTED(glinfo.texnpot));
|
|
|
|
initprintf(" Clamp-to-edge: %s\n", SUPPORTED(glinfo.clamptoedge));
|
|
|
|
initprintf(" Multi-texturing: %s\n", SUPPORTED(glinfo.multitex));
|
|
|
|
initprintf(" Framebuffer objects: %s\n", SUPPORTED(glinfo.fbos));
|
2015-02-11 05:23:04 +00:00
|
|
|
#ifndef EDUKE32_GLES
|
2018-04-12 21:02:31 +00:00
|
|
|
initprintf(" Texture compression: %s\n", SUPPORTED(glinfo.texcompr));
|
|
|
|
initprintf(" Multi-sampling: %s\n", SUPPORTED(glinfo.multisample));
|
|
|
|
initprintf(" NVIDIA multisample hint: %s\n", SUPPORTED(glinfo.nvmultisamplehint));
|
|
|
|
initprintf(" ARBfp fragment programs: %s\n", SUPPORTED(glinfo.arbfp));
|
|
|
|
initprintf(" Depth textures: %s\n", SUPPORTED(glinfo.depthtex));
|
|
|
|
initprintf(" Shadow textures: %s\n", SUPPORTED(glinfo.shadow));
|
|
|
|
initprintf(" Rectangle textures: %s\n", SUPPORTED(glinfo.rect));
|
|
|
|
initprintf(" env_combine: %s\n", SUPPORTED(glinfo.envcombine));
|
|
|
|
initprintf(" Vertex buffer objects: %s\n", SUPPORTED(glinfo.vbos));
|
|
|
|
initprintf(" Shader model 4: %s\n", SUPPORTED(glinfo.sm4));
|
|
|
|
initprintf(" Occlusion queries: %s\n", SUPPORTED(glinfo.occlusionqueries));
|
|
|
|
initprintf(" GLSL: %s\n", SUPPORTED(glinfo.glsl));
|
|
|
|
initprintf(" Debug output: %s\n", SUPPORTED(glinfo.debugoutput));
|
|
|
|
initprintf(" Buffer storage: %s\n", SUPPORTED(glinfo.bufferstorage));
|
|
|
|
initprintf(" Sync: %s\n", SUPPORTED(glinfo.sync));
|
2015-02-11 05:23:04 +00:00
|
|
|
#endif
|
2018-04-12 21:02:31 +00:00
|
|
|
initprintf(" Maximum anisotropy: %.1f%s\n", glinfo.maxanisotropy, glinfo.maxanisotropy > 1.0 ? "" : " (no anisotropic filtering)");
|
2006-04-24 19:04:22 +00:00
|
|
|
|
2018-04-12 21:02:31 +00:00
|
|
|
#undef SUPPORTED
|
|
|
|
|
|
|
|
initprintf(" Extensions:\n%s", glinfo.extensions);
|
2006-04-24 19:04:22 +00:00
|
|
|
|
|
|
|
return OSDCMD_OK;
|
2006-04-23 06:44:19 +00:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2017-06-27 02:24:14 +00:00
|
|
|
static int32_t osdcmd_cvar_set_baselayer(osdfuncparm_t const * const parm)
|
2006-04-23 06:44:19 +00:00
|
|
|
{
|
2010-07-03 08:53:57 +00:00
|
|
|
int32_t r = osdcmd_cvar_set(parm);
|
2006-04-24 19:04:22 +00:00
|
|
|
|
2010-07-03 08:53:57 +00:00
|
|
|
if (r != OSDCMD_OK) return r;
|
|
|
|
|
|
|
|
if (!Bstrcasecmp(parm->name, "vid_gamma") || !Bstrcasecmp(parm->name, "vid_brightness") || !Bstrcasecmp(parm->name, "vid_contrast"))
|
|
|
|
{
|
2018-04-12 21:03:12 +00:00
|
|
|
videoSetPalette(GAMMA_CALC,0,0);
|
2010-07-03 08:53:57 +00:00
|
|
|
|
|
|
|
return r;
|
2006-04-24 19:04:22 +00:00
|
|
|
}
|
2010-07-03 08:53:57 +00:00
|
|
|
|
|
|
|
return r;
|
2006-04-23 06:44:19 +00:00
|
|
|
}
|
|
|
|
|
2009-01-09 09:29:17 +00:00
|
|
|
int32_t baselayer_init(void)
|
2006-04-23 06:44:19 +00:00
|
|
|
{
|
2012-04-09 19:22:00 +00:00
|
|
|
#ifdef _WIN32
|
|
|
|
// on Windows, don't save the "r_screenaspect" cvar because the physical screen size is
|
|
|
|
// determined at startup
|
|
|
|
# define SCREENASPECT_CVAR_TYPE (CVAR_UINT|CVAR_NOSAVE)
|
|
|
|
#else
|
|
|
|
# define SCREENASPECT_CVAR_TYPE (CVAR_UINT)
|
|
|
|
#endif
|
2017-06-27 02:24:14 +00:00
|
|
|
static osdcvardata_t cvars_engine[] =
|
2009-04-29 06:20:07 +00:00
|
|
|
{
|
2018-04-05 04:39:30 +00:00
|
|
|
{ "lz4compressionlevel","adjust LZ4 compression level used for savegames",(void *) &lz4CompressionLevel, CVAR_INT, 1, 32 },
|
2013-05-17 03:43:20 +00:00
|
|
|
{ "r_usenewaspect","enable/disable new screen aspect ratio determination code",(void *) &r_usenewaspect, CVAR_BOOL, 0, 1 },
|
|
|
|
{ "r_screenaspect","if using r_usenewaspect and in fullscreen, screen aspect ratio in the form XXYY, e.g. 1609 for 16:9",
|
2012-08-24 18:51:49 +00:00
|
|
|
(void *) &r_screenxy, SCREENASPECT_CVAR_TYPE, 0, 9999 },
|
2013-05-17 03:43:20 +00:00
|
|
|
{ "r_novoxmips","turn off/on the use of mipmaps when rendering 8-bit voxels",(void *) &novoxmips, CVAR_BOOL, 0, 1 },
|
|
|
|
{ "r_voxels","enable/disable automatic sprite->voxel rendering",(void *) &usevoxels, CVAR_BOOL, 0, 1 },
|
Support for drawing 'island sectors' for TROR/classic (and with limited
functionality, Polymost).
The new feature can be enabled/disabled with the 'r_tror_nomaskpass' cvar.
The basic idea is that when drawing lower or upper levels, a first pass
is performed that ignores all red walls for which the TROR nextwall link
'towards' the viewer arrives at a red wall. Thus, in the worst case, there
can be up to twice as many rendering passes now (when it is discovered that
the no-mask-pass isn't different that what would be drawn with the ordinary
one, the latter is skipped, since we've already drawn all needed geometry).
Hovever, this kind of multi-pass splitting is only suitable for simple scenes,
like the upper subway in the TROR test map. In particular, multiple islands
shouldn't 'see' each other.
Two issues are worth mentioning: first, care needs to be taken for translucent
ceilings or floors, since drawing them twice isn't the same as drawing them
once. This is done for classic, but not for Polymost. Second, sprites (which
are always drawn _after_ the geometry for a given pass) are still clipped to
the geometry of the ordinary pass, resulting in their disappearance from
certain angles.
--
Additionaly, a change made it into this commit that fixes redundant collection
of sprites in TROR:classic/Polymost.
git-svn-id: https://svn.eduke32.com/eduke32@2024 1a8010ca-5511-0410-912e-c29ae57300e0
2011-09-15 17:04:14 +00:00
|
|
|
#ifdef YAX_ENABLE
|
2013-05-17 03:43:20 +00:00
|
|
|
{ "r_tror_nomaskpass", "enable/disable additional pass in TROR software rendering", (void *)&r_tror_nomaskpass, CVAR_BOOL, 0, 1 },
|
Support for drawing 'island sectors' for TROR/classic (and with limited
functionality, Polymost).
The new feature can be enabled/disabled with the 'r_tror_nomaskpass' cvar.
The basic idea is that when drawing lower or upper levels, a first pass
is performed that ignores all red walls for which the TROR nextwall link
'towards' the viewer arrives at a red wall. Thus, in the worst case, there
can be up to twice as many rendering passes now (when it is discovered that
the no-mask-pass isn't different that what would be drawn with the ordinary
one, the latter is skipped, since we've already drawn all needed geometry).
Hovever, this kind of multi-pass splitting is only suitable for simple scenes,
like the upper subway in the TROR test map. In particular, multiple islands
shouldn't 'see' each other.
Two issues are worth mentioning: first, care needs to be taken for translucent
ceilings or floors, since drawing them twice isn't the same as drawing them
once. This is done for classic, but not for Polymost. Second, sprites (which
are always drawn _after_ the geometry for a given pass) are still clipped to
the geometry of the ordinary pass, resulting in their disappearance from
certain angles.
--
Additionaly, a change made it into this commit that fixes redundant collection
of sprites in TROR:classic/Polymost.
git-svn-id: https://svn.eduke32.com/eduke32@2024 1a8010ca-5511-0410-912e-c29ae57300e0
2011-09-15 17:04:14 +00:00
|
|
|
#endif
|
2014-02-11 17:55:45 +00:00
|
|
|
{ "r_windowpositioning", "enable/disable window position memory", (void *) &windowpos, CVAR_BOOL, 0, 1 },
|
2018-04-12 21:02:51 +00:00
|
|
|
{ "vid_gamma","adjusts gamma component of gamma ramp",(void *) &g_videoGamma, CVAR_FLOAT|CVAR_FUNCPTR, 0, 10 },
|
|
|
|
{ "vid_contrast","adjusts contrast component of gamma ramp",(void *) &g_videoContrast, CVAR_FLOAT|CVAR_FUNCPTR, 0, 10 },
|
|
|
|
{ "vid_brightness","adjusts brightness component of gamma ramp",(void *) &g_videoBrightness, CVAR_FLOAT|CVAR_FUNCPTR, 0, 10 },
|
2012-12-31 01:50:45 +00:00
|
|
|
#ifdef DEBUGGINGAIDS
|
2011-01-16 02:50:27 +00:00
|
|
|
{ "debug1","debug counter",(void *) &debug1, CVAR_FLOAT, -100000, 100000 },
|
|
|
|
{ "debug2","debug counter",(void *) &debug2, CVAR_FLOAT, -100000, 100000 },
|
2014-01-19 20:17:14 +00:00
|
|
|
#endif
|
|
|
|
#ifdef DEBUG_MASK_DRAWING
|
2014-01-24 21:39:02 +00:00
|
|
|
{ "debug_maskdrawmode", "Show mask draw orders", (void *)&g_maskDrawMode, CVAR_BOOL, 0, 1 },
|
2012-12-31 01:50:45 +00:00
|
|
|
#endif
|
2009-04-29 06:20:07 +00:00
|
|
|
};
|
|
|
|
|
2018-04-12 21:03:30 +00:00
|
|
|
for (native_t i=0; i<ARRAY_SSIZE(cvars_engine); i++)
|
2017-06-27 02:24:14 +00:00
|
|
|
OSD_RegisterCvar(&cvars_engine[i], (cvars_engine[i].flags & CVAR_FUNCPTR) ? osdcmd_cvar_set_baselayer : osdcmd_cvar_set);
|
2009-04-29 06:20:07 +00:00
|
|
|
|
2011-03-04 08:50:58 +00:00
|
|
|
#ifdef USE_OPENGL
|
2006-04-24 19:04:22 +00:00
|
|
|
OSD_RegisterFunction("setrendermode","setrendermode <number>: sets the engine's rendering mode.\n"
|
|
|
|
"Mode numbers are:\n"
|
|
|
|
" 0 - Classic Build software\n"
|
|
|
|
" 3 - Polygonal OpenGL\n"
|
2016-03-14 00:07:40 +00:00
|
|
|
#ifdef POLYMER
|
2010-05-25 10:56:00 +00:00
|
|
|
" 4 - Great justice renderer (Polymer)\n"
|
2016-03-14 00:07:40 +00:00
|
|
|
#endif
|
2006-04-24 19:04:22 +00:00
|
|
|
,
|
|
|
|
osdfunc_setrendermode);
|
2015-11-02 17:07:54 +00:00
|
|
|
|
2009-12-13 01:23:44 +00:00
|
|
|
# ifdef DEBUGGINGAIDS
|
|
|
|
OSD_RegisterFunction("hicsetpalettetint","hicsetpalettetint: sets palette tinting values",osdcmd_hicsetpalettetint);
|
|
|
|
# endif
|
2015-11-02 17:07:54 +00:00
|
|
|
|
2006-04-24 19:04:22 +00:00
|
|
|
OSD_RegisterFunction("glinfo","glinfo: shows OpenGL information about the current OpenGL mode",osdcmd_glinfo);
|
2015-11-02 17:07:54 +00:00
|
|
|
|
2009-04-29 06:20:07 +00:00
|
|
|
polymost_initosdfuncs();
|
2006-04-23 06:44:19 +00:00
|
|
|
#endif
|
2009-04-29 06:20:07 +00:00
|
|
|
|
2018-04-12 21:02:31 +00:00
|
|
|
for (native_t i = 0; i < NUMKEYS; i++) g_keyRemapTable[i] = i;
|
|
|
|
|
2006-04-24 19:04:22 +00:00
|
|
|
return 0;
|
2006-04-23 06:44:19 +00:00
|
|
|
}
|
|
|
|
|
2013-01-06 18:56:29 +00:00
|
|
|
void maybe_redirect_outputs(void)
|
|
|
|
{
|
|
|
|
#if !(defined __APPLE__ && defined __BIG_ENDIAN__)
|
|
|
|
char *argp;
|
|
|
|
|
|
|
|
// pipe standard outputs to files
|
2018-04-12 21:02:31 +00:00
|
|
|
if ((argp = Bgetenv("BUILD_LOGSTDOUT")) == NULL || Bstrcasecmp(argp, "TRUE"))
|
|
|
|
return;
|
|
|
|
|
|
|
|
FILE *fp = freopen("stdout.txt", "w", stdout);
|
|
|
|
|
|
|
|
if (!fp)
|
|
|
|
fp = fopen("stdout.txt", "w");
|
|
|
|
|
|
|
|
if (fp)
|
|
|
|
{
|
|
|
|
setvbuf(fp, 0, _IONBF, 0);
|
|
|
|
*stdout = *fp;
|
|
|
|
*stderr = *fp;
|
|
|
|
}
|
2013-01-06 18:56:29 +00:00
|
|
|
#endif
|
|
|
|
}
|