Merge branch 'Saturn-Next' into updatesdl2again

This commit is contained in:
Alug committed 2025-10-16 15:07:54 +01:00
commit 6f17ed0883
46 files changed
+845 -1758

No files matched your search

+1 -1
View File
@@ -10,7 +10,7 @@
makedir:=$(makedir)/SDL
opts+=-DDIRECTFULLSCREEN -DHAVE_SDL
opts+=-DHAVE_SDL
sources+=$(call List,sdl/Sourcefile)
NOUPNP=1
+3 -1
View File
@@ -2,6 +2,8 @@
# Mingw, if you don't know, that's Win32/Win64
#
sources+=$(call List,win32/Sourcefile)
ifndef MINGW64
EXENAME?=srb2kart-saturn_32bit.exe
else
@@ -95,7 +97,7 @@ LIBBACKTRACE_libs:=-L$(lib)/lib/x86_64 -lbacktrace
$(eval $(call _set,LIBBACKTRACE))
else
lib:=../libs/drmingw
opts+=-I$(lib)/include
opts+=-I$(lib)/include -DHAVE_DRMINGW
libs+=-L$(lib)/lib/win32 -lmgwhelp -lexchndl
endif
+1 -1
View File
@@ -53,7 +53,7 @@ r_data.c
r_draw.c
r_fps.cpp
r_main.cpp
r_patch.c
r_patch.cpp
r_patchrotation.c
r_plane.cpp
r_segs.cpp
+7 -6
View File
@@ -1913,13 +1913,14 @@ void CV_AddValue(consvar_t *var, INT32 increment)
max = (M_SecretUnlocked(SECRET_HARDSPEED) ? 3 : 2);
}
#ifdef PARANOIA
if (currentindice == -1)
I_Error("CV_AddValue: current value %d not found in possible value\n",
var->value);
if (currentindice == -1 || max == 0)
I_Error("CV_AddValue: current value %d not found in possible value\n", var->value);
#endif
newindice = (currentindice + increment + max) % max;
CV_Set(var, var->PossibleValue[newindice].strvalue);
if (max > 0)
{
newindice = (currentindice + increment + max) % max;
CV_Set(var, var->PossibleValue[newindice].strvalue);
}
}
}
else
-31
View File
@@ -69,14 +69,9 @@ static boolean consoleready; // console prompt is ready
INT32 con_destlines; // vid lines used by console at final position
static INT32 con_curlines; // vid lines currently used by console
INT32 con_clipviewtop; // (useless)
static UINT8 con_hudlines; // number of console heads up message lines
static UINT32 con_hudtime[MAXHUDLINES]; // remaining time of display for hud msg lines
INT32 con_clearlines; // top screen lines to refresh when view reduced
boolean con_hudupdate; // when messages scroll, we need a backgrnd refresh
// console text output
static char *con_line; // console text output current line
static size_t con_cx; // cursor position in current line
@@ -393,9 +388,6 @@ void CON_Init(void)
Lock_state();
//note: CON_Ticker should always execute at least once before D_Display()
con_clipviewtop = -1; // -1 does not clip
con_hudlines = atoi(cons_hudlines.defaultvalue);
Unlock_state();
@@ -727,7 +719,6 @@ void CON_ToggleOff(void)
con_curlines = 0;
CON_ClearHUD();
con_forcepic = 0;
con_clipviewtop = -1; // remove console clipping of view
I_SetTextInput(false);
@@ -779,18 +770,6 @@ void CON_Ticker(void)
}
}
// clip the view, so that the part under the console is not drawn
con_clipviewtop = -1;
if (cons_backpic.value) // clip only when using an opaque background
{
if (con_curlines > 0)
con_clipviewtop = con_curlines - viewwindowy - 1 - 10;
// NOTE: BIG HACK::SUBTRACT 10, SO THAT WATER DON'T COPY LINES OF THE CONSOLE
// WINDOW!!! (draw some more lines behind the bottom of the console)
if (con_clipviewtop < 0)
con_clipviewtop = -1; // maybe not necessary, provided it's < 0
}
// check if console ready for prompt
if (con_destlines >= minheight)
{
@@ -1100,9 +1079,6 @@ static void CON_Linefeed(void)
con_line = &con_buffer[(con_cy%con_totallines)*con_width];
memset(con_line, ' ', con_width);
// make sure the view borders are refreshed if hud messages scroll
con_hudupdate = true; // see HU_Erase()
}
// Outputs text into the console text buffer
@@ -1489,9 +1465,6 @@ static void CON_DrawHudlines(void)
//V_DrawCharacter(x, y, (p[c]&0xff) | cv_constextsize.value | V_NOSCALESTART, !cv_allcaps.value);
y += charheight;
}
// top screen lines that might need clearing when view is reduced
con_clearlines = y; // this is handled by HU_Erase();
}
// draw the console background, text, and prompt if enough place
@@ -1509,10 +1482,6 @@ static void CON_DrawConsole(void)
if (con_curlines <= 0)
return;
//FIXME: refresh borders only when console bg is translucent
con_clearlines = con_curlines; // clear console draw from view borders
con_hudupdate = true; // always refresh while console is on
// draw console background
if (cons_backpic.value || con_forcepic)
{
-5
View File
@@ -30,14 +30,9 @@ extern boolean con_recalc;
extern boolean con_startup;
// top clip value for view render: do not draw part of view hidden by console
extern INT32 con_clipviewtop;
// 0 means console if off, or moving out
extern INT32 con_destlines;
extern INT32 con_clearlines; // lines of top of screen to refresh
extern boolean con_hudupdate; // hud messages have changed, need refresh
extern UINT32 con_scalefactor; // console text scale factor
extern consvar_t cons_backcolor, cons_menuhighlight;
-9
View File
@@ -522,19 +522,16 @@ static boolean D_Display(void)
case GS_LEVEL:
if (!gametic)
break;
HU_Erase();
AM_Drawer();
break;
case GS_INTERMISSION:
Y_IntermissionDrawer();
HU_Erase();
HU_Drawer();
break;
case GS_VOTING:
Y_VoteDrawer();
HU_Erase();
HU_Drawer();
break;
@@ -549,7 +546,6 @@ static boolean D_Display(void)
case GS_CUTSCENE:
F_CutsceneDrawer();
HU_Erase();
HU_Drawer();
break;
@@ -559,7 +555,6 @@ static boolean D_Display(void)
case GS_EVALUATION:
F_GameEvaluationDrawer();
HU_Erase();
HU_Drawer();
break;
@@ -569,7 +564,6 @@ static boolean D_Display(void)
case GS_CREDITS:
F_CreditDrawer();
HU_Erase();
HU_Drawer();
break;
@@ -586,7 +580,6 @@ static boolean D_Display(void)
{
// I don't think HOM from nothing drawing is independent...
F_WaitingPlayersDrawer();
HU_Erase();
HU_Drawer();
}
case GS_TIMEATTACK:
@@ -1925,9 +1918,7 @@ void D_SRB2Main(void)
G_LoadGameData();
#if defined (__unix__) || defined (UNIXCOMMON) || defined (HAVE_SDL)
VID_PrepareModeList(); // Regenerate Modelist according to cv_fullscreen
#endif
// set user default mode or mode set at cmdline
SCR_CheckDefaultMode();
-6
View File
@@ -90,12 +90,6 @@ extern FILE *logstream;
extern char logfilename[1024];
#endif
// not sure if this belongs here lul
// TODO: figure out whats preventing 32bit windows from working with libbacktrace
#if defined(_WIN32) && !defined(__MINGW64__)
#define HAVE_DRMINGW
#endif
#if defined (HAVE_LIBBACKTRACE)
#define CRASH_LOGFILE_NAME "srb2kart-crash-log.txt"
#elif defined (HAVE_DRMINGW)
-1
View File
@@ -43,7 +43,6 @@ extern "C" {
#define UINT64 uint64_t
#ifdef __APPLE_CC__
#define DIRECTFULLSCREEN 1
#define DEBUG_LOG
#define NOIPX
#endif
+24 -7
View File
@@ -3569,7 +3569,8 @@ void G_SaveDemo(void)
size_t i, strindex = 0;
boolean dash = true;
for (i = 0; demo.titlename[i] && i < 127; i++)
//for (i = 0; demo.titlename[i] && i < 127; i++) ?????
for (i = 0; i < 64 && demo.titlename[i]; i++)
{
if ((demo.titlename[i] >= 'a' && demo.titlename[i] <= 'z') ||
(demo.titlename[i] >= '0' && demo.titlename[i] <= '9'))
@@ -3584,7 +3585,7 @@ void G_SaveDemo(void)
strindex++;
dash = false;
}
else if (!dash)
else if (strindex && !dash)
{
demo_slug[strindex] = '-';
strindex++;
@@ -3592,12 +3593,28 @@ void G_SaveDemo(void)
}
}
demo_slug[strindex] = 0;
if (dash) demo_slug[strindex-1] = 0;
if (dash && strindex)
{
strindex--;
}
demo_slug[strindex] = '\0';
writepoint = strstr(demoname, "-") + 1;
demo_slug[128 - (writepoint - demoname) - 4] = 0;
sprintf(writepoint, "%s.lmp", demo_slug);
if (demo_slug[0] != '\0')
{
// Slug is valid, write the chosen filename.
writepoint = strstr(demoname, "-");
if (!writepoint)
return;
writepoint++;
size_t flen = 128 - (writepoint - demoname) - 4;
if (flen > 0 && flen < 128)
{
demo_slug[flen] = '\0';
sprintf(writepoint, "%s.lmp", demo_slug);
}
}
}
length = *(UINT32 *)demoinfo_p;
+1 -195
View File
@@ -31,11 +31,6 @@
#include "../st_stuff.h"
#include <fcntl.h>
#include "../i_video.h" // for rendermode != render_glide
#ifndef O_BINARY
#define O_BINARY 0
#endif
typedef struct
{
@@ -58,68 +53,6 @@ static UINT8 softwaretranstogl_lo[11] = { 0, 12, 24, 36, 48, 60, 71, 83, 95,111
static const float FLOATBASEVIDWIDTH = (float)BASEVIDWIDTH;
static const float FLOATBASEVIDHEIGHT = (float)BASEVIDHEIGHT;
//
// -----------------+
// HWR_DrawPatch : Draw a 'tile' graphic
// Notes : x,y : positions relative to the original Doom resolution
// : textes(console+score) + menus + status bar
// -----------------+
void HWR_DrawPatch(patch_t *gpatch, INT32 x, INT32 y, INT32 option)
{
FOutVector v[4];
FBITFIELD flags;
GLPatch_t *hwrPatch;
// 3--2
// | /|
// |/ |
// 0--1
float sdup = FIXED_TO_FLOAT(vid.fdup)*2.0f;
float pdup = FIXED_TO_FLOAT(vid.fdup)*2.0f;
// make patch ready in hardware cache
HWR_GetPatch(gpatch);
hwrPatch = ((GLPatch_t *)gpatch->hardware);
switch (option & V_SCALEPATCHMASK)
{
case V_NOSCALEPATCH:
pdup = 2.0f;
break;
case V_SMALLSCALEPATCH:
pdup = 2.0f * FIXED_TO_FLOAT(vid.smalldup*FRACUNIT);
break;
case V_MEDSCALEPATCH:
pdup = 2.0f * FIXED_TO_FLOAT(vid.meddup*FRACUNIT);
break;
}
if (option & V_NOSCALESTART)
sdup = 2.0f;
v[0].x = v[3].x = (x*sdup-gpatch->leftoffset*pdup)/vid.width - 1;
v[2].x = v[1].x = (x*sdup+(gpatch->width - gpatch->leftoffset)*pdup)/vid.width - 1;
v[0].y = v[1].y = 1-(y*sdup-gpatch->topoffset*pdup)/vid.height;
v[2].y = v[3].y = 1-(y*sdup+(gpatch->height - gpatch->topoffset)*pdup)/vid.height;
v[0].z = v[1].z = v[2].z = v[3].z = 1.0f;
v[0].s = v[3].s = 0.0f;
v[2].s = v[1].s = hwrPatch->max_s;
v[0].t = v[1].t = 0.0f;
v[2].t = v[3].t = hwrPatch->max_t;
flags = PF_Translucent|PF_NoDepthTest;
if (option & V_WRAPX)
flags |= PF_ForceWrapX;
if (option & V_WRAPY)
flags |= PF_ForceWrapY;
// clip it since it is used for bunny scroll in doom I
GL_DrawPolygon(NULL, v, 4, flags);
}
void HWR_DrawStretchyFixedPatch(patch_t *gpatch, fixed_t x, fixed_t y, fixed_t pscale, fixed_t vscale, INT32 option, const UINT8 *colormap, INT32 bflags)
{
FOutVector v[4];
@@ -636,133 +569,6 @@ void HWR_DrawConsoleBack(UINT32 color, INT32 height)
}
// ==========================================================================
// R_DRAW.C STUFF
// ==========================================================================
// ------------------
// HWR_DrawViewBorder
// Fill the space around the view window with a Doom flat texture, draw the
// beveled edges.
// 'clearlines' is useful to clear the heads up messages, when the view
// window is reduced, it doesn't refresh all the view borders.
// ------------------
void HWR_DrawViewBorder(INT32 clearlines)
{
INT32 x, y;
INT32 top, side;
INT32 baseviewwidth, baseviewheight;
INT32 basewindowx, basewindowy;
patch_t *patch;
if (!clearlines)
clearlines = BASEVIDHEIGHT; // refresh all
// calc view size based on original game resolution
baseviewwidth = FixedInt(FixedDiv(FLOAT_TO_FIXED(gl_viewwidth), vid.fdup)); //(cv_viewsize.value * BASEVIDWIDTH/10)&~7;
baseviewheight = FixedInt(FixedDiv(FLOAT_TO_FIXED(gl_viewheight), vid.fdup));
top = FixedInt(FixedDiv(FLOAT_TO_FIXED(gl_baseviewwindowy), vid.fdup));
side = FixedInt(FixedDiv(FLOAT_TO_FIXED(gl_baseviewwindowx), vid.fdup));
// top
HWR_DrawFlatFill(0, 0,
BASEVIDWIDTH, (top < clearlines ? top : clearlines),
st_borderpatchnum);
// left
if (top < clearlines)
HWR_DrawFlatFill(0, top, side,
(clearlines-top < baseviewheight ? clearlines-top : baseviewheight),
st_borderpatchnum);
// right
if (top < clearlines)
HWR_DrawFlatFill(side + baseviewwidth, top, side,
(clearlines-top < baseviewheight ? clearlines-top : baseviewheight),
st_borderpatchnum);
// bottom
if (top + baseviewheight < clearlines)
HWR_DrawFlatFill(0, top + baseviewheight,
BASEVIDWIDTH, BASEVIDHEIGHT, st_borderpatchnum);
//
// draw the view borders
//
basewindowx = (BASEVIDWIDTH - baseviewwidth)>>1;
if (baseviewwidth == BASEVIDWIDTH)
basewindowy = 0;
else
basewindowy = top;
// top edge
if (clearlines > basewindowy - 8)
{
patch = W_CachePatchNum(viewborderlump[BRDR_T], PU_PATCH);
for (x = 0; x < baseviewwidth; x += 8)
HWR_DrawPatch(patch, basewindowx + x, basewindowy - 8,
0);
}
// bottom edge
if (clearlines > basewindowy + baseviewheight)
{
patch = W_CachePatchNum(viewborderlump[BRDR_B], PU_PATCH);
for (x = 0; x < baseviewwidth; x += 8)
HWR_DrawPatch(patch, basewindowx + x,
basewindowy + baseviewheight, 0);
}
// left edge
if (clearlines > basewindowy)
{
patch = W_CachePatchNum(viewborderlump[BRDR_L], PU_PATCH);
for (y = 0; y < baseviewheight && basewindowy + y < clearlines;
y += 8)
{
HWR_DrawPatch(patch, basewindowx - 8, basewindowy + y,
0);
}
}
// right edge
if (clearlines > basewindowy)
{
patch = W_CachePatchNum(viewborderlump[BRDR_R], PU_PATCH);
for (y = 0; y < baseviewheight && basewindowy+y < clearlines;
y += 8)
{
HWR_DrawPatch(patch, basewindowx + baseviewwidth,
basewindowy + y, 0);
}
}
// Draw beveled corners.
if (clearlines > basewindowy - 8)
HWR_DrawPatch(W_CachePatchNum(viewborderlump[BRDR_TL],
PU_PATCH),
basewindowx - 8, basewindowy - 8, 0);
if (clearlines > basewindowy - 8)
HWR_DrawPatch(W_CachePatchNum(viewborderlump[BRDR_TR],
PU_PATCH),
basewindowx + baseviewwidth, basewindowy - 8, 0);
if (clearlines > basewindowy+baseviewheight)
HWR_DrawPatch(W_CachePatchNum(viewborderlump[BRDR_BL],
PU_PATCH),
basewindowx - 8, basewindowy + baseviewheight, 0);
if (clearlines > basewindowy + baseviewheight)
HWR_DrawPatch(W_CachePatchNum(viewborderlump[BRDR_BR],
PU_PATCH),
basewindowx + baseviewwidth,
basewindowy + baseviewheight, 0);
}
// ==========================================================================
// AM_MAP.C DRAWING STUFF
// ==========================================================================
@@ -1168,7 +974,7 @@ static inline boolean saveTGA(const char *file_name, void *buffer,
INT32 i;
UINT8 *buf8 = buffer;
fd = open(file_name, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, 0666);
fd = open(file_name, O_WRONLY | O_CREAT | O_TRUNC, 0666);
if (fd < 0)
return false;
+12 -44
View File
@@ -65,8 +65,6 @@
// Globals
// ==========================================================================
#define ABS(x) ((x) < 0 ? -(x) : (x))
// false if shaders have not been initialized yet, or if shaders are not available
boolean gl_shadersavailable = false;
@@ -77,11 +75,6 @@ boolean gl_drawing_stencil = false;
static INT32 current_bsp_culling_distance = 0;
// base values set at SetViewSize
float gl_baseviewwindowy, gl_baseviewwindowx;
static float gl_viewwindowy, gl_viewwindowx; // top left corner of view window
float gl_viewwidth, gl_viewheight; // viewport clipping boundaries (screen coords)
FTransform atransform;
// Float variants of viewx, viewy, viewz, etc.
@@ -4335,7 +4328,7 @@ static int CompareDrawNodePlanes(const void *p1, const void *p2)
const INT32 n1 = *(const INT32*)p1;
const INT32 n2 = *(const INT32*)p2;
return ABS(drawnodes[n2].u.plane.fixedheight - viewz) - ABS(drawnodes[n1].u.plane.fixedheight - viewz);
return abs(drawnodes[n2].u.plane.fixedheight - viewz) - abs(drawnodes[n1].u.plane.fixedheight - viewz);
}
//
@@ -5316,10 +5309,10 @@ static void HWR_DrawSkyBackground(void)
// -----------------+
static inline void HWR_ClearView(void)
{
GL_GClipRect((INT32)gl_viewwindowx,
(INT32)gl_viewwindowy,
(INT32)(gl_viewwindowx + gl_viewwidth),
(INT32)(gl_viewwindowy + gl_viewheight),
GL_GClipRect(viewwindowx,
viewwindowy,
(viewwindowx + viewwidth),
(viewwindowy + viewheight),
ZCLIP_PLANE, FAR_ZCLIP_DEFAULT);
GL_ClearBuffer(false, true, true, NULL);
}
@@ -5329,19 +5322,6 @@ static inline void HWR_ClearView(void)
// -----------------+
void HWR_SetViewSize(void)
{
// setup view size
gl_viewwidth = (float)vid.width;
gl_viewheight = (float)vid.height;
if (splitscreen)
gl_viewheight /= 2;
if (splitscreen > 1)
gl_viewwidth /= 2;
gl_baseviewwindowy = 0;
gl_baseviewwindowx = 0;
GL_FlushScreenTextures();
}
@@ -5352,7 +5332,9 @@ static void HWR_SetTransformAiming(FTransform *trans)
if (cv_glshearing.value)
{
fixed_t fixedaiming = AIMINGTODY(aimingangle);
trans->viewaiming = FixedToFloat(fixedaiming);
trans->viewaiming = FixedToFloat(fixedaiming) * ((float)vid.width / vid.height) / ((float)BASEVIDWIDTH / BASEVIDHEIGHT);
if (splitscreen == 1) // only for 2 player splitscreen
trans->viewaiming *= 2.125; // splitscreen adjusts fov with 0.8, so compensate (but only halfway, since splitscreen means only half the screen is used)
trans->shearing = true;
gl_aimingangle = 0;
}
@@ -5594,20 +5576,6 @@ extern "C" {
// ==========================================================================
static void HWR_RenderFrame(player_t *player, boolean skybox)
{
// set window position
gl_viewwindowx = gl_baseviewwindowx;
gl_viewwindowy = gl_baseviewwindowy;
if ((splitscreen == 1 && viewssnum == 1) || (splitscreen > 1 && viewssnum > 1))
{
gl_viewwindowy += gl_viewheight;
}
if (splitscreen > 1 && viewssnum & 1)
{
gl_viewwindowx += gl_viewwidth;
}
// check for new console commands.
NetUpdate();
@@ -5623,10 +5591,10 @@ static void HWR_RenderFrame(player_t *player, boolean skybox)
if (!skybox && cv_glrenderdistance.value)
{
GL_GClipRect((INT32)gl_viewwindowx,
(INT32)gl_viewwindowy,
(INT32)(gl_viewwindowx + gl_viewwidth),
(INT32)(gl_viewwindowy + gl_viewheight),
GL_GClipRect(viewwindowx,
viewwindowy,
(viewwindowx + viewwidth),
(viewwindowy + viewheight),
ZCLIP_PLANE, clipping_distances[cv_glrenderdistance.value - 1]);
current_bsp_culling_distance = bsp_culling_distances[cv_glrenderdistance.value - 1];
}
-6
View File
@@ -42,10 +42,6 @@ extern "C" {
void HWR_Startup(void);
void HWR_Shutdown(void);
extern float gl_viewwidth, gl_viewheight, gl_baseviewwindowx, gl_baseviewwindowy;
extern float gl_basewindowcenterx, gl_basewindowcentery;
extern unsigned msaa;
extern boolean a2c;
@@ -89,7 +85,6 @@ extern ps_metric_t ps_hw_batchdrawtime;
extern boolean gl_shadersavailable;
// hw_draw.c
void HWR_DrawPatch(patch_t *gpatch, INT32 x, INT32 y, INT32 option);
void HWR_DrawStretchyFixedPatch(patch_t *gpatch, fixed_t x, fixed_t y, fixed_t pscale, fixed_t vscale, INT32 option, const UINT8 *colormap, INT32 bflags);
void HWR_DrawCroppedPatch(patch_t *gpatch, fixed_t x, fixed_t y, fixed_t pscale, INT32 option, fixed_t sx, fixed_t sy, fixed_t w, fixed_t h);
void HWR_DrawFill(INT32 x, INT32 y, INT32 w, INT32 h, INT32 color);
@@ -98,7 +93,6 @@ void HWR_DrawDiag(INT32 x, INT32 y, INT32 wh, INT32 color);
void HWR_drawAMline(const fline_t *fl, INT32 color);
void HWR_FadeScreenMenuBack(UINT16 color, UINT8 strength);
void HWR_DrawConsoleBack(UINT32 color, INT32 height);
void HWR_DrawViewBorder(INT32 clearlines);
void HWR_DrawFlatFill(INT32 x, INT32 y, INT32 w, INT32 h, lumpnum_t flatlumpnum);
UINT8 *HWR_GetScreenshot(INT32 scale);
-145
View File
@@ -114,7 +114,6 @@ void UnloadModel(model_t *model)
if (model->materials)
Z_Free(model->materials);
DeleteVBOs(model);
Z_Free(model);
}
@@ -194,7 +193,6 @@ model_t *LoadModel(const char *filename, int ztag)
strcpy(model->mdlFilename, filename);
Optimize(model);
GeneratePolygonNormals(model, ztag);
// Default material properties
for (i = 0 ; i < model->numMaterials; i++)
@@ -246,13 +244,6 @@ void GenerateVertexNormals(model_t *model)
M_Memcpy(newNormals, frame->normals, sizeof(float)*3*mesh->numTriangles*3);
/* if (!systemSucks)
{
memTag = Z_GetTag(frame->tangents);
float *newTangents = (float*)Z_Malloc(sizeof(float)*3*mesh->numTriangles*3, memTag);
M_Memcpy(newTangents, frame->tangents, sizeof(float)*3*mesh->numTriangles*3);
}*/
for (k = 0; k < mesh->numVertices; k++)
{
float x, y, z;
@@ -288,32 +279,15 @@ void GenerateVertexNormals(model_t *model)
if (vCount > 1)
{
// Vector::Normalize(&normal);
newNormals[3 * k + 0] = (float)normal.x;
newNormals[3 * k + 1] = (float)normal.y;
newNormals[3 * k + 2] = (float)normal.z;
/* if (!systemSucks)
{
Vector::vector_t tangent;
Vector::Tangent(&normal, &tangent);
newTangents[3 * k + 0] = tangent.x;
newTangents[3 * k + 1] = tangent.y;
newTangents[3 * k + 2] = tangent.z;
}*/
}
}
oldNormals = frame->normals;
frame->normals = newNormals;
Z_Free(oldNormals);
/* if (!systemSucks)
{
float *oldTangents = frame->tangents;
frame->tangents = newTangents;
Z_Free(oldTangents);
}*/
}
}
}
@@ -404,15 +378,11 @@ void Optimize(model_t *model)
newMesh->numTriangles = numTriangles;
newMesh->numVertices = numTriangles * 3;
newMesh->uvs = (float*)Z_Malloc(sizeof(float)*2*numTriangles*3, memTag, 0);
// if (node->material->lightmap)
// newMesh->lightuvs = (float*)Z_Malloc(sizeof(float)*2*numTriangles*3, memTag, 0);
newMesh->frames = (mdlframe_t*)Z_Calloc(sizeof(mdlframe_t), memTag, 0);
curFrame = &newMesh->frames[0];
curFrame->material = curMat;
curFrame->normals = (float*)Z_Malloc(sizeof(float)*3*numTriangles*3, memTag, 0);
// if (!systemSucks)
// curFrame->tangents = (float*)Z_Malloc(sizeof(float)*3*numTriangles*3, memTag, 0);
curFrame->vertices = (float*)Z_Malloc(sizeof(float)*3*numTriangles*3, memTag, 0);
curFrame->colors = (char*)Z_Malloc(sizeof(char)*4*numTriangles*3, memTag, 0);
@@ -436,12 +406,6 @@ void Optimize(model_t *model)
curMesh->uvs,
sizeof(float)*2*curMesh->numTriangles*3);
/* if (node->material->lightmap)
{
M_Memcpy(&newMesh->lightuvs[uvCount],
curMesh->lightuvs,
sizeof(float)*2*curMesh->numTriangles*3);
}*/
uvCount += 2*curMesh->numTriangles*3;
dest = (float*)newMesh->frames[0].vertices;
@@ -456,15 +420,6 @@ void Optimize(model_t *model)
src,
sizeof(float)*3*curMesh->numTriangles*3);
/* if (!systemSucks)
{
dest = (float*)newMesh->frames[0].tangents;
src = (float*)curMesh->frames[0].tangents;
M_Memcpy(&dest[vertCount],
src,
sizeof(float)*3*curMesh->numTriangles*3);
}*/
vertCount += 3 * curMesh->numTriangles * 3;
destByte = (char*)newMesh->frames[0].colors;
@@ -494,103 +449,3 @@ void Optimize(model_t *model)
model->meshes = newMeshes;
model->numMeshes = numMeshes;
}
void GeneratePolygonNormals(model_t *model, int ztag)
{
int i;
for (i = 0; i < model->numMeshes; i++)
{
int j;
mesh_t *mesh = &model->meshes[i];
if (!mesh->frames)
continue;
for (j = 0; j < mesh->numFrames; j++)
{
int k;
mdlframe_t *frame = &mesh->frames[j];
const float *vertices = frame->vertices;
vector_t *polyNormals;
frame->polyNormals = (vector_t*)Z_Malloc(sizeof(vector_t) * mesh->numTriangles, ztag, 0);
polyNormals = frame->polyNormals;
for (k = 0; k < mesh->numTriangles; k++)
{
/// TODO: normalize vectors
(void)vertices;
(void)polyNormals;
// Vector::Normal(vertices, polyNormals);
vertices += 3 * 3;
polyNormals++;
}
}
}
}
//
// Reload
//
// Reload VBOs
//
#if 0
static void Reload(void)
{
/* model_t *node;
for (node = modelHead; node; node = node->next)
{
int i;
for (i = 0; i < node->numMeshes; i++)
{
mesh_t *mesh = &node->meshes[i];
if (mesh->frames)
{
int j;
for (j = 0; j < mesh->numFrames; j++)
CreateVBO(mesh, &mesh->frames[j]);
}
else if (mesh->tinyframes)
{
int j;
for (j = 0; j < mesh->numFrames; j++)
CreateVBO(mesh, &mesh->tinyframes[j]);
}
}
}*/
}
#endif
void DeleteVBOs(model_t *model)
{
(void)model;
/* for (int i = 0; i < model->numMeshes; i++)
{
mesh_t *mesh = &model->meshes[i];
if (mesh->frames)
{
for (int j = 0; j < mesh->numFrames; j++)
{
mdlframe_t *frame = &mesh->frames[j];
if (!frame->vboID)
continue;
bglDeleteBuffers(1, &frame->vboID);
frame->vboID = 0;
}
}
else if (mesh->tinyframes)
{
for (int j = 0; j < mesh->numFrames; j++)
{
tinyframe_t *frame = &mesh->tinyframes[j];
if (!frame->vboID)
continue;
bglDeleteBuffers(1, &frame->vboID);
frame->vboID = 0;
}
}
}*/
}
-6
View File
@@ -28,8 +28,6 @@ typedef struct
float ambient[4], diffuse[4], specular[4], emissive[4];
float shininess;
boolean spheremap;
// Texture::texture_t *texture;
// Texture::texture_t *lightmap;
} material_t;
typedef struct
@@ -40,7 +38,6 @@ typedef struct
float *tangents;
char *colors;
unsigned int vboID;
vector_t *polyNormals;
} mdlframe_t;
typedef struct
@@ -70,7 +67,6 @@ typedef struct mesh_s
typedef struct tag_s
{
char name[64];
// matrix_t transform;
} tag_t;
typedef struct model_s
@@ -96,9 +92,7 @@ model_t *LoadModel(const char *filename, int ztag);
void UnloadModel(model_t *model);
void Optimize(model_t *model);
void GenerateVertexNormals(model_t *model);
void GeneratePolygonNormals(model_t *model, int ztag);
void CreateVBOTiny(mesh_t *mesh, tinyframe_t *frame);
void CreateVBO(mesh_t *mesh, mdlframe_t *frame);
void DeleteVBOs(model_t *model);
#endif
+3
View File
@@ -253,6 +253,9 @@ HMS_connect (const char *format, ...)
cc = curl_easy_setopt(curl, CURLOPT_TIMEOUT, (long)cv_masterserver_timeout.value);
if (cc != CURLE_OK) I_OutputMsg("libcurl: %s\n", buffer->errbuf);
cc = curl_easy_setopt(curl, CURLOPT_MAXREDIRS, 30L);
if (cc != CURLE_OK) I_OutputMsg("libcurl: %s\n", buffer->errbuf);
cc = curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, HMS_on_read);
if (cc != CURLE_OK) I_OutputMsg("libcurl: %s\n", buffer->errbuf);
-70
View File
@@ -2391,76 +2391,6 @@ void HU_Drawer(void)
}
}
//======================================================================
// HUD MESSAGES CLEARING FROM SCREEN
//======================================================================
// Clear old messages from the borders around the view window
// (only for reduced view, refresh the borders when needed)
//
// startline: y coord to start clear,
// clearlines: how many lines to clear.
//
static INT32 oldclearlines;
void HU_Erase(void)
{
INT32 topline, bottomline;
INT32 y, yoffset;
#ifdef HWRENDER
// clear hud msgs on double buffer (OpenGL mode)
boolean secondframe;
static INT32 secondframelines;
#endif
if (con_clearlines == oldclearlines && !con_hudupdate && !chat_on)
return;
#ifdef HWRENDER
// clear the other frame in double-buffer modes
secondframe = (con_clearlines != oldclearlines);
if (secondframe)
secondframelines = oldclearlines;
#endif
// clear the message lines that go away, so use _oldclearlines_
bottomline = oldclearlines;
oldclearlines = con_clearlines;
if (chat_on && OLDCHAT)
if (bottomline < 8)
bottomline = 8; // only do it for consolechat. consolechat is gay.
if (automapactive || viewwindowx == 0) // hud msgs don't need to be cleared
return;
// software mode copies view border pattern & beveled edges from the backbuffer
if (rendermode == render_soft)
{
topline = 0;
for (y = topline, yoffset = y*vid.width; y < bottomline; y++, yoffset += vid.width)
{
if (y < viewwindowy || y >= viewwindowy + viewheight)
R_VideoErase(yoffset, vid.width); // erase entire line
else
{
R_VideoErase(yoffset, viewwindowx); // erase left border
// erase right border
R_VideoErase(yoffset + viewwindowx + viewwidth, viewwindowx);
}
}
con_hudupdate = false; // if it was set..
}
#ifdef HWRENDER
else if (rendermode != render_none)
{
// refresh just what is needed from the view borders
HWR_DrawViewBorder(secondframelines);
con_hudupdate = secondframe;
}
#endif
}
//======================================================================
// IN-LEVEL MULTIPLAYER RANKINGS
//======================================================================
-1
View File
@@ -117,7 +117,6 @@ void HU_TickSongCredits(void);
void HU_DrawSongCredits(void);
void HU_Drawer(void);
char HU_dequeueChatChar(void);
void HU_Erase(void);
void HU_clearChatChars(void);
void HU_drawPlayerPing(INT32 x, INT32 y, INT32 pnum, INT32 flags); // Lat': Ping drawer for scoreboard.
//void HU_DrawTeamTabRankings(playersort_t *tab, INT32 whiteplayer);
-680
View File
@@ -1,680 +0,0 @@
// SONIC ROBO BLAST 2
//-----------------------------------------------------------------------------
// Copyright (C) 2011-2018 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 i_addrinfo.c
/// \brief getaddr stubs, for lesser OSes
///
/// Some systems/SDKs, like PSL1GHT v2 does not have addrinfo functions
/// So a stub is needed
#include <string.h>
#include <stdlib.h>
#include <sys/types.h>
#ifdef _WIN32
#ifdef USE_WINSOCK2
#include <ws2tcpip.h>
#else
#include <winsock.h>
#endif
#else
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netdb.h>
#endif
#include "i_addrinfo.h"
/*
* This addrinfo stub have a testcases:
* To test the stub, use this command to compile the stub testcase:
* gcc -g -DTESTCASE -Dtest_stub -Wall -W i_addrinfo.c -o stub
* To test the real getaddrinfo API, use this command to get real one:
* gcc -g -DTESTCASE -Utest_stub -Wall -W i_addrinfo.c -o real
* For Win32,you need the WinSock library, version 1.1 or 2.2
* for 1.1, add -lwsock32
* i686-w64-mingw32-gcc -g -DTESTCASE -Dtest_stub -UUSE_WINSOCK2 -Wall -W i_addrinfo.c -o stub.exe -lwsock32
* for 2.2, add -DUSE_WINSOCK2 -lws2_32
* i686-w64-mingw32-gcc -g -DTESTCASE -Utest_stub -DUSE_WINSOCK2 -Wall -W i_addrinfo.c -o real.exe -lws2_32
*/
#ifndef I_getaddrinfo
#include <stdbool.h>
#ifdef _WIN32
// it seems windows doesn't define that... maybe some other OS? OS/2
static int inet_aton(const char *cp, struct in_addr *addr)
{
if( cp == NULL || addr == NULL )
{
return(0);
}
if (strcmp(cp, "255.255.255.225") == 0)
{
addr->s_addr = htonl(INADDR_BROADCAST);
return 0;
}
return (addr->s_addr = inet_addr(cp)) != htonl(INADDR_NONE);
}
#endif
#ifdef USE_WINSOCK2
static HMODULE ipv6dll = NULL;
typedef int (WSAAPI *p_getaddrinfo) (const char *, const char *,
const struct my_addrinfo *,
struct my_addrinfo **);
typedef void (WSAAPI *p_freeaddrinfo) (struct my_addrinfo *);
static p_getaddrinfo WS_getaddrinfo = NULL;
static p_freeaddrinfo WS_freeaddrinfo = NULL;
static HMODULE WS_getfunctions(HMODULE tmp)
{
if (tmp != NULL)
{
WS_getaddrinfo = (p_getaddrinfo)(LPVOID)GetProcAddress(tmp, "getaddrinfo");
if (WS_getaddrinfo == NULL)
return NULL;
WS_freeaddrinfo = (p_freeaddrinfo)(LPVOID)GetProcAddress(tmp, "freeaddrinfo");
if (WS_freeaddrinfo == NULL)
{
WS_getaddrinfo = NULL;
return NULL;
}
}
return tmp;
}
static void WS_addrinfosetup(void)
{
if (WS_getaddrinfo && WS_freeaddrinfo)
return; // already have the functions
// why not hold it into ipv6dll? becase we already link with ws2_32, silly!
if (WS_getfunctions(GetModuleHandleA("ws2_32.dll")) == NULL)
ipv6dll = WS_getfunctions(LoadLibraryA("wship6.dll"));
}
void WS_addrinfocleanup(void)
{
if (ipv6dll)
FreeLibrary(ipv6dll);
ipv6dll = NULL;
WS_getaddrinfo = NULL;
WS_freeaddrinfo = NULL;
}
#else
void WS_addrinfocleanup(void) {}
#endif
int I_getaddrinfo(const char *node, const char *service,
const struct my_addrinfo *hints,
struct my_addrinfo **res)
{
struct hostent *nodename = NULL;
bool hostlookup = true, passivemode = false;
int flags = 0;
int socktype = 0;
int sockport = 0;
struct my_addrinfo *ai;
struct sockaddr_in *addr;
struct in_addr ipv4;
size_t addrlen = 1;
size_t ailen = 1, i = 0, j;
size_t famsize = sizeof(struct sockaddr_in);
#ifdef USE_WINSOCK2
WS_addrinfosetup();
if (WS_getaddrinfo)
return WS_getaddrinfo(node, service, hints, res);
#endif
// param check
if (node == NULL && service == NULL)
return EAI_NONAME;
//note: testcase show NULL as res crashes libc
if (res == NULL)
return -1;
// check hints
if (hints)
{
// no support for IPv6
if (hints->ai_family != AF_INET && hints->ai_family != AF_UNSPEC)
return -1; //EAI_FAMILY
#ifdef AI_NUMERICHOST
// do not look up hostnames
if ((hints->ai_flags & AI_NUMERICHOST) == AI_NUMERICHOST)
{
hostlookup = false;
flags |= AI_NUMERICHOST;
}
#endif
#ifdef AI_PASSIVE
// return loopback or any address?
if ((hints->ai_flags & AI_PASSIVE) == AI_PASSIVE)
{
passivemode = true;
flags |= AI_PASSIVE;
}
#endif
// why no support for canon names? lazy
//AI_CANONNAME
// what kind of socket?
socktype = hints->ai_socktype;
}
else
{
#ifdef AI_V4MAPPED
flags |= AI_V4MAPPED;
#endif
#ifdef AI_ADDRCONFIG
flags |= AI_ADDRCONFIG;
#endif
}
// we need gethostbyname to convert numeric strings
if (node && hostlookup)
{
if (node == NULL)
return -1;
nodename = gethostbyname(node);
if (nodename == NULL)
{
if (inet_aton(node, &ipv4) != 0)
addrlen = 1;
else
return -1;
}
else while (nodename->h_addr_list[addrlen] != NULL)
addrlen++;
}
else if (node)
{
if (inet_aton(node, &ipv4) != 0)
addrlen = 1;
else if (!hostlookup)
return EAI_NONAME;
}
else
addrlen = 1;
if (service) //AI_NUMERICSERV
sockport = atoi(service);
if (socktype == 0)
ailen = addrlen*3;
else
ailen = addrlen;
ai = calloc(ailen, sizeof(struct my_addrinfo));
if (ai == NULL)
return -1;
else
*res = ai;
addr = calloc(ailen*2, famsize);
if (addr == NULL)
{
free(ai);
return -1;
}
else
ai->ai_addr = memset(addr, 0x00, ailen*ai->ai_addrlen);
for (i = 0; i < ailen; i++)
{
ai = *res+i;
ai->ai_flags = flags;
ai->ai_family = AF_INET;
ai->ai_socktype = socktype;
switch (ai->ai_socktype)
{
case SOCK_STREAM:
ai->ai_protocol = IPPROTO_TCP;
break;
case SOCK_DGRAM:
ai->ai_protocol = IPPROTO_UDP;
break;
default:
ai->ai_protocol = 0;
}
ai->ai_addrlen = famsize;
ai->ai_addr = (struct sockaddr *)&addr[i];
//ai_cannonname
ai->ai_next = ai+1;
}
ai->ai_next = NULL;
ai = *res;
for (i = 0, j = 0; i < ailen; i++, j++)
{
ai = *res+i;
addr[i].sin_port = htons((UINT16)sockport);
if (nodename)
{
memcpy(&addr[i].sin_addr, nodename->h_addr_list[j], ai->ai_addrlen);
addr[i].sin_family = nodename->h_addrtype;
}
else if (node)
{
memcpy(&addr[i].sin_addr, &ipv4, ai->ai_addrlen);
addr[i].sin_family = AF_INET;
}
else
{
if (passivemode)
addr[i].sin_addr.s_addr = htonl(INADDR_ANY);
else
addr[i].sin_addr.s_addr = htonl(INADDR_LOOPBACK);
addr[i].sin_family = AF_INET;
}
if (socktype == 0)
{
ai->ai_socktype = SOCK_STREAM;
ai->ai_protocol = IPPROTO_TCP;
memcpy(&addr[i+1], &addr[i], ai->ai_addrlen);
i++; ai++;
ai->ai_socktype = SOCK_DGRAM;
ai->ai_protocol = IPPROTO_UDP;
memcpy(&addr[i+1], &addr[i], ai->ai_addrlen);
i++; ai++;
ai->ai_socktype = SOCK_RAW;
ai->ai_protocol = IPPROTO_IP;
}
}
return 0;
}
#endif
#ifndef I_freeaddrinfo
void I_freeaddrinfo(struct my_addrinfo *res)
{
#ifdef USE_WINSOCK2
if (WS_freeaddrinfo)
{
WS_freeaddrinfo(res);
return;
}
#endif
if (!res)
return;
free(res->ai_addr);
free(res);
}
#endif
#ifdef TESTCASE
#include <stdio.h>
#ifdef USE_WINSOCK2
#define inet_ntop inet_ntopA
#define HAVE_NTOP
static const char* inet_ntopA(int af, const void *cp, char *buf, socklen_t len)
{
DWORD Dlen = len, AFlen = 0;
SOCKADDR_STORAGE any;
LPSOCKADDR anyp = (LPSOCKADDR)&any;
LPSOCKADDR_IN any4 = (LPSOCKADDR_IN)&any;
LPSOCKADDR_IN6 any6 = (LPSOCKADDR_IN6)&any;
if (!buf)
{
WSASetLastError(STATUS_INVALID_PARAMETER);
return NULL;
}
if (af != AF_INET && af != AF_INET6)
{
WSASetLastError(WSAEAFNOSUPPORT);
return NULL;
}
ZeroMemory(&any, sizeof(SOCKADDR_STORAGE));
any.ss_family = af;
switch (af)
{
case AF_INET:
{
CopyMemory(&any4->sin_addr, cp, sizeof(IN_ADDR));
AFlen = sizeof(SOCKADDR_IN);
break;
}
case AF_INET6:
{
CopyMemory(&any6->sin6_addr, cp, sizeof(IN6_ADDR));
AFlen = sizeof(SOCKADDR_IN6);
break;
}
}
if (WSAAddressToStringA(anyp, AFlen, NULL, buf, &Dlen) == SOCKET_ERROR)
return NULL;
return buf;
}
#elif defined (_WIN32)
// w32api, ws2tcpip.h, r1.12
static inline char* gai_strerror(int ecode)
{
static char message[1024+1];
DWORD dwFlags = FORMAT_MESSAGE_FROM_SYSTEM
| FORMAT_MESSAGE_IGNORE_INSERTS
| FORMAT_MESSAGE_MAX_WIDTH_MASK;
DWORD dwLanguageId = MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT);
FormatMessageA(dwFlags, NULL, ecode, dwLanguageId, message, 1024, NULL);
return message;
}
#else
#define HAVE_NTOP
#endif
#ifndef INET_ADDRSTRLEN
#define INET_ADDRSTRLEN 16
#endif
static inline void printflags(int ai_flags)
{
printf("flags: %x(", ai_flags);
if (ai_flags == 0)
printf("NONE|");
#ifdef AI_PASSIVE
if ((ai_flags & AI_PASSIVE) == AI_PASSIVE)
printf("AI_PASSIVE|");
ai_flags &= ~AI_PASSIVE;
#endif
#ifdef AI_CANONNAME
if ((ai_flags & AI_CANONNAME) == AI_CANONNAME)
printf("AI_CANONNAME|");
ai_flags &= ~AI_CANONNAME;
#endif
#ifdef AI_NUMERICHOST
if ((ai_flags & AI_NUMERICHOST) == AI_NUMERICHOST)
printf("AI_NUMERICHOST|");
ai_flags &= ~AI_NUMERICHOST;
#endif
#ifdef AI_V4MAPPED
if ((ai_flags & AI_V4MAPPED) == AI_V4MAPPED)
printf("AI_V4MAPPED|");
ai_flags &= ~AI_V4MAPPED;
#endif
#ifdef AI_ALL
if ((ai_flags & AI_ALL) == AI_ALL)
printf("AI_ALL|");
ai_flags &= ~AI_ALL;
#endif
#ifdef AI_ADDRCONFIG
if ((ai_flags & AI_ADDRCONFIG) == AI_ADDRCONFIG)
printf("AI_ADDRCONFIG|");
ai_flags &= ~AI_ADDRCONFIG;
#endif
#ifdef AI_IDN
if ((ai_flags & AI_IDN) == AI_IDN)
printf("AI_IDN|");
ai_flags &= ~AI_IDN;
#endif
#ifdef AI_CANONIDN
if ((ai_flags & AI_CANONIDN) == AI_CANONIDN)
printf("AI_CANONIDN|");
ai_flags &= ~AI_CANONIDN;
#endif
#ifdef AI_IDN_ALLOW_UNASSIGNED
if ((ai_flags & AI_IDN_ALLOW_UNASSIGNED) == AI_IDN_ALLOW_UNASSIGNED)
printf("AI_IDN_ALLOW_UNASSIGNED|");
ai_flags &= ~AI_IDN_ALLOW_UNASSIGNED;
#endif
#ifdef AI_IDN_USE_STD3_ASCII_RULES
if ((ai_flags & AI_IDN_USE_STD3_ASCII_RULES) == AI_IDN_USE_STD3_ASCII_RULES)
printf("AI_IDN_USE_STD3_ASCII_RULES|");
ai_flags &= ~AI_PASSIVE;
#endif
#ifdef AI_NUMERICSERV
if ((ai_flags & AI_NUMERICSERV) == AI_NUMERICSERV)
printf("AI_NUMERICSERV|");
ai_flags &= ~AI_NUMERICSERV;
#endif
printf("%x", ai_flags);
printf(")\n");
}
static inline void printsocktype(int ai_socktype)
{
printf("socktype: %d(", ai_socktype);
switch (ai_socktype)
{
case 0:
printf("SOCK_ Woe32");
break;
case SOCK_STREAM:
printf("SOCK_STREAM");
break;
case SOCK_DGRAM:
printf("SOCK_DGRAM");
break;
case SOCK_RAW:
printf("SOCK_RAW");
break;
default:
printf("SOCK_ERROR\n");
exit(-1);
}
printf(")\n");
}
static inline void printprotocol(int ai_protocol)
{
printf("protocol: %d(", ai_protocol);
switch (ai_protocol)
{
case IPPROTO_IP:
printf("IPPROTO_IP");
break;
case IPPROTO_TCP:
printf("IPPROTO_TCP");
break;
case IPPROTO_UDP:
printf("IPPROTO_UDP");
break;
default:
printf("IPPROTO_ERROR\n");
exit(-1);
}
printf(")\n");
}
static inline void printaddr(int ai_family, const struct sockaddr *ai_addr)
{
char str[INET_ADDRSTRLEN+1] = "FAKE";
printf("family: %d(", ai_family);
switch (ai_family)
{
case AF_UNSPEC:
printf("AF_UNSPEC");
break;
case AF_INET:
printf("AF_INET");
break;
#ifdef AF_INET6
case AF_INET6:
printf("AF_INET6");
break;
#endif
default:
printf("AF_ERROR\n");
exit(-1);
}
printf(")\n");
if (ai_family == AF_INET && ai_addr)
{
const struct sockaddr_in *ip4 = (void *)ai_addr;
#ifdef HAVE_NTOP
inet_ntop(ai_family, &ip4->sin_addr, str, INET_ADDRSTRLEN);
#else
strncpy(str, inet_ntoa(ip4->sin_addr), INET_ADDRSTRLEN);
#endif
printf("port: %d\n", ntohs(ip4->sin_port));
}
printf("addr: %s\n", str);
}
void printaddrinfo(const struct my_addrinfo *data)
{
if(data == NULL)
{
printf("no data\n");
return;
}
else
printf("starting addrinfo dump\n");
while (data != NULL)
{
printflags(data->ai_flags);
printsocktype(data->ai_socktype);
printaddr(data->ai_family, data->ai_addr);
printprotocol(data->ai_protocol);
//addrlen
data = data->ai_next;
}
}
int main(int argc, char **argv)
{
struct my_addrinfo *res = NULL, hints;
int gaie;
(void)argc;
(void)argv;
memset(&hints, 0x00, sizeof(struct my_addrinfo));
hints.ai_family = AF_INET;
#ifdef _WIN32
{
#ifdef USE_WINSOCK2
const WORD VerNeed = MAKEWORD(2,2);
#else
const WORD VerNeed = MAKEWORD(1,1);
#endif
WSADATA WSAData;
WSAStartup(VerNeed, &WSAData);
}
#endif
printf("-----------------------------------------------------------\n");
#ifndef _WIN32 //NULL as res crashes Win32
gaie = I_getaddrinfo(NULL, NULL, &hints, NULL);
if (gaie != EAI_NONAME)
printf("NULLs test returned: %s(%d)\n", gai_strerror(gaie), gaie);
I_freeaddrinfo(res);
#endif
#if 0 //NULL as res crashes
gaie = I_getaddrinfo("localhost", "5029", NULL, NULL);
if (gaie == 0)
printf("NULL crashes: %s(%d)\n", gai_strerror(gaie), gaie);
I_freeaddrinfo(res);
#endif
gaie = I_getaddrinfo("localhost", NULL, &hints, &res);
//if (gaie != 0)
printf("NULL service test returned: %s(%d)\n", gai_strerror(gaie), gaie);
printaddrinfo(res);
I_freeaddrinfo(res); res = NULL;
gaie = I_getaddrinfo(NULL, "5029", &hints, &res);
//if (gaie != 0)
printf("NULLs test returned: %s(%d)\n", gai_strerror(gaie), gaie);
printaddrinfo(res);
I_freeaddrinfo(res); res = NULL;
gaie = I_getaddrinfo("localhost", "5029", &hints, &res);
//if (gaie != 0)
printf("no hints test returned: %s(%d)\n", gai_strerror(gaie), gaie);
printaddrinfo(res);
I_freeaddrinfo(res); res = NULL;
printf("-----------------------------------------------------------\n");
hints.ai_socktype = SOCK_STREAM;
hints.ai_protocol = IPPROTO_TCP;
gaie = I_getaddrinfo("localhost", NULL, &hints, &res);
//if (gaie != 0)
printf("NULL service test returned: %s(%d)\n", gai_strerror(gaie), gaie);
printaddrinfo(res);
I_freeaddrinfo(res); res = NULL;
gaie = I_getaddrinfo(NULL, "5029", &hints, &res);
//if (gaie != 0)
printf("NULLs test returned: %s(%d)\n", gai_strerror(gaie), gaie);
printaddrinfo(res);
I_freeaddrinfo(res); res = NULL;
gaie = I_getaddrinfo("localhost", "5029", &hints, &res);
//if (gaie != 0)
printf("no hints test returned: %s(%d)\n", gai_strerror(gaie), gaie);
printaddrinfo(res);
I_freeaddrinfo(res); res = NULL;
printf("-----------------------------------------------------------\n");
hints.ai_socktype = SOCK_DGRAM;
hints.ai_protocol = IPPROTO_UDP;
gaie = I_getaddrinfo("localhost", NULL, &hints, &res);
//if (gaie != 0)
printf("NULL service test returned: %s(%d)\n", gai_strerror(gaie), gaie);
printaddrinfo(res);
I_freeaddrinfo(res); res = NULL;
gaie = I_getaddrinfo(NULL, "5029", &hints, &res);
//if (gaie != 0)
printf("NULLs test returned: %s(%d)\n", gai_strerror(gaie), gaie);
printaddrinfo(res);
I_freeaddrinfo(res); res = NULL;
gaie = I_getaddrinfo("localhost", "5029", &hints, &res);
//if (gaie != 0)
printf("no hints test returned: %s(%d)\n", gai_strerror(gaie), gaie);
printaddrinfo(res);
I_freeaddrinfo(res); res = NULL;
printf("-----------------------------------------------------------\n");
hints.ai_flags = AI_NUMERICHOST;
gaie = I_getaddrinfo("localhost", NULL, &hints, &res);
//if (gaie != 0)
printf("NULL service test returned: %s(%d)\n", gai_strerror(gaie), gaie);
printaddrinfo(res);
I_freeaddrinfo(res); res = NULL;
gaie = I_getaddrinfo(NULL, "5029", &hints, &res);
//if (gaie != 0)
printf("NULLs test returned: %s(%d)\n", gai_strerror(gaie), gaie);
printaddrinfo(res);
I_freeaddrinfo(res); res = NULL;
gaie = I_getaddrinfo("localhost", "5029", &hints, &res);
//if (gaie != 0)
printf("no hints test returned: %s(%d)\n", gai_strerror(gaie), gaie);
printaddrinfo(res);
I_freeaddrinfo(res); res = NULL;
printf("-----------------------------------------------------------\n");
gaie = I_getaddrinfo("127.0.0.1", NULL, &hints, &res);
//if (gaie != 0)
printf("NULL service test returned: %s(%d)\n", gai_strerror(gaie), gaie);
printaddrinfo(res);
I_freeaddrinfo(res); res = NULL;
gaie = I_getaddrinfo("127.0.0.1", "5029", &hints, &res);
//if (gaie != 0)
printf("no hints test returned: %s(%d)\n", gai_strerror(gaie), gaie);
printaddrinfo(res);
I_freeaddrinfo(res); res = NULL;
printf("-----------------------------------------------------------\n");
gaie = I_getaddrinfo("255.255.255.255", NULL, &hints, &res);
//if (gaie != 0)
printf("NULL service test returned: %s(%d)\n", gai_strerror(gaie), gaie);
printaddrinfo(res);
I_freeaddrinfo(res); res = NULL;
gaie = I_getaddrinfo("255.255.255.255", "5029", &hints, &res);
//if (gaie != 0)
printf("no hints test returned: %s(%d)\n", gai_strerror(gaie), gaie);
printaddrinfo(res);
I_freeaddrinfo(res); res = NULL;
printf("-----------------------------------------------------------\n");
hints.ai_flags = AI_PASSIVE;
gaie = I_getaddrinfo("0.0.0.0", NULL, &hints, &res);
//if (gaie != 0)
printf("NULL service test returned: %s(%d)\n", gai_strerror(gaie), gaie);
printaddrinfo(res);
I_freeaddrinfo(res); res = NULL;
gaie = I_getaddrinfo("0.0.0.0", "5029", &hints, &res);
//if (gaie != 0)
printf("no hints test returned: %s(%d)\n", gai_strerror(gaie), gaie);
printaddrinfo(res);
I_freeaddrinfo(res); res = NULL;
return 0;
}
#endif
-71
View File
@@ -1,71 +0,0 @@
// SONIC ROBO BLAST 2
//-----------------------------------------------------------------------------
// Copyright (C) 2011-2018 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 i_addrinfo.h
/// \brief getaddrinfo stub
#ifndef __I_ADDRINFO__
#define __I_ADDRINFO__
#ifdef __GNUG__
#pragma interface
#endif
#ifndef AI_PASSIVE
#define AI_PASSIVE 0x01
#endif
#ifndef AI_NUMERICHOST
#define AI_NUMERICHOST 0x04
#endif
#ifndef AI_V4MAPPED
#define AI_V4MAPPED 0x08
#endif
#ifndef AI_ADDRCONFIG
#define AI_ADDRCONFIG 0x20
#endif
#ifdef _WIN32
#ifndef EAI_NONAME
#define EAI_NONAME WSAHOST_NOT_FOUND
#endif
#endif
#ifndef EAI_NONAME
#define EAI_NONAME -2
#endif
#ifdef _WIN32 // already use the stub for Win32
// w32api, ws2tcpip.h, r1.12
struct my_addrinfo {
int ai_flags;
int ai_family;
int ai_socktype;
int ai_protocol;
size_t ai_addrlen;
char *ai_canonname;
struct sockaddr *ai_addr;
struct my_addrinfo *ai_next;
};
#else
#define my_addrinfo addrinfo
#endif
void WS_addrinfocleanup(void);
#ifndef my_addrinfo
void I_freeaddrinfo(struct my_addrinfo *res);
int I_getaddrinfo(const char *node, const char *service,
const struct my_addrinfo *hints,
struct my_addrinfo **res);
#elif !defined (test_stub)
#define I_getaddrinfo getaddrinfo
#define I_freeaddrinfo freeaddrinfo
#endif
#endif
+44 -87
View File
@@ -29,42 +29,36 @@
#ifdef _WIN32
#define USE_WINSOCK
#if defined (_WIN64) || defined (HAVE_IPV6)
#define USE_WINSOCK2
#else //_WIN64/HAVE_IPV6
#define USE_WINSOCK1
#endif
#endif //WIN32 OS
#ifdef USE_WINSOCK2
#ifdef USE_WINSOCK
#include <ws2tcpip.h>
#define addrinfo_t ADDRINFOA
#else
#define addrinfo_t struct addrinfo
#endif
#include "doomdef.h"
#ifndef USE_WINSOCK
#include <arpa/inet.h>
#ifdef __APPLE_CC__
#ifndef _BSD_SOCKLEN_T_
#define _BSD_SOCKLEN_T_
#endif //_BSD_SOCKLEN_T_
#endif //__APPLE_CC__
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <sys/ioctl.h>
#endif //normal BSD API
#include <errno.h>
#include <time.h>
#ifdef USE_WINSOCK1
#include <winsock.h>
#else
#ifndef USE_WINSOCK
#include <arpa/inet.h>
#ifdef __APPLE_CC__
#ifndef _BSD_SOCKLEN_T_
#define _BSD_SOCKLEN_T_
#endif //_BSD_SOCKLEN_T_
#endif //__APPLE_CC__
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <sys/ioctl.h>
#endif //normal BSD API
#include <errno.h>
#if defined (__unix__) || defined (__APPLE__) || defined (UNIXCOMMON)
#include <sys/time.h>
#endif // UNIXCOMMON
#endif
#if defined (__unix__) || defined (__APPLE__) || defined (UNIXCOMMON)
#include <sys/time.h>
#endif // UNIXCOMMON
#ifdef USE_WINSOCK
// some undefined under win32
@@ -152,7 +146,6 @@ static UINT8 UPNP_support = TRUE;
#define close closesocket
#endif
#include "i_addrinfo.h"
#define DEFAULTPORT "5029"
#if defined (USE_WINSOCK)
@@ -169,10 +162,6 @@ typedef unsigned long SOCKET_TYPE;
#define IPV6_MULTICAST_ADDRESS "ff15::57e1:1a12"
#ifdef USE_WINSOCK1
typedef int socklen_t;
#endif
typedef struct
{
mysockaddr_t address;
@@ -232,9 +221,8 @@ static char *get_WSAErrorStr(int e)
#define strerror get_WSAErrorStr
#endif
#ifdef USE_WINSOCK2
#ifdef USE_WINSOCK
#define inet_ntop inet_ntopA
#define HAVE_NTOP
static const char* inet_ntopA(short af, const void *cp, char *buf, socklen_t len)
{
DWORD Dlen = len, AFlen = 0;
@@ -278,8 +266,6 @@ static const char* inet_ntopA(short af, const void *cp, char *buf, socklen_t len
return NULL;
return buf;
}
#elif !defined (USE_WINSOCK1)
#define HAVE_NTOP
#endif
#ifdef HAVE_MINIUPNPC // based on old XChat patch
@@ -360,7 +346,6 @@ static const char *SOCK_AddrToStr(mysockaddr_t *sk)
static char s[64]; // 255.255.255.255:65535 or
// [ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff]:65535
#ifdef HAVE_NTOP
#ifdef HAVE_IPV6
int v6 = (sk->any.sa_family == AF_INET6);
#else
@@ -398,15 +383,7 @@ static const char *SOCK_AddrToStr(mysockaddr_t *sk)
#endif
else if(sk->any.sa_family == AF_INET && sk->ip4.sin_port != 0)
strcat(s, va(":%d", ntohs(sk->ip4.sin_port)));
#else
if (sk->any.sa_family == AF_INET)
{
strcpy(s, inet_ntoa(sk->ip4.sin_addr));
if (sk->ip4.sin_port != 0) strcat(s, va(":%d", ntohs(sk->ip4.sin_port)));
}
else
sprintf(s, "Unknown type");
#endif
return s;
}
@@ -868,15 +845,11 @@ static SOCKET_TYPE UDP_Bind(int family, struct sockaddr *addr, socklen_t addrlen
#ifdef USE_WINSOCK
{ // Alam_GBC: disable the new UDP connection reset behavior for Win2k and up
#ifdef USE_WINSOCK2
DWORD dwBytesReturned = 0;
BOOL bfalse = FALSE;
rc = WSAIoctl(s, SIO_UDP_CONNRESET, &bfalse, sizeof(bfalse),
NULL, 0, &dwBytesReturned, NULL, NULL);
#else
unsigned long falseval = false;
rc = ioctl(s, SIO_UDP_CONNRESET, &falseval);
#endif
if (rc == -1)
{
e = errno;
@@ -1046,7 +1019,7 @@ static SOCKET_TYPE UDP_Bind(int family, struct sockaddr *addr, socklen_t addrlen
static boolean UDP_Socket(void)
{
size_t s;
struct my_addrinfo *ai, *runp, hints;
addrinfo_t *ai, *runp, hints;
int gaie;
#ifdef HAVE_IPV6
const INT32 b_ipv6 = M_CheckParm("-ipv6");
@@ -1075,7 +1048,7 @@ static boolean UDP_Socket(void)
{
while (M_IsNextParm())
{
gaie = I_getaddrinfo(M_GetNextParm(), serv, &hints, &ai);
gaie = getaddrinfo(M_GetNextParm(), serv, &hints, &ai);
if (gaie == 0)
{
runp = ai;
@@ -1089,13 +1062,13 @@ static boolean UDP_Socket(void)
}
runp = runp->ai_next;
}
I_freeaddrinfo(ai);
freeaddrinfo(ai);
}
}
}
else
{
gaie = I_getaddrinfo("0.0.0.0", serv, &hints, &ai);
gaie = getaddrinfo("0.0.0.0", serv, &hints, &ai);
if (gaie == 0)
{
runp = ai;
@@ -1116,7 +1089,7 @@ static boolean UDP_Socket(void)
}
runp = runp->ai_next;
}
I_freeaddrinfo(ai);
freeaddrinfo(ai);
}
}
@@ -1128,7 +1101,7 @@ static boolean UDP_Socket(void)
{
while (M_IsNextParm())
{
gaie = I_getaddrinfo(M_GetNextParm(), serv, &hints, &ai);
gaie = getaddrinfo(M_GetNextParm(), serv, &hints, &ai);
if (gaie == 0)
{
runp = ai;
@@ -1142,13 +1115,13 @@ static boolean UDP_Socket(void)
}
runp = runp->ai_next;
}
I_freeaddrinfo(ai);
freeaddrinfo(ai);
}
}
}
else
{
gaie = I_getaddrinfo("::", serv, &hints, &ai);
gaie = getaddrinfo("::", serv, &hints, &ai);
if (gaie == 0)
{
runp = ai;
@@ -1162,7 +1135,7 @@ static boolean UDP_Socket(void)
}
runp = runp->ai_next;
}
I_freeaddrinfo(ai);
freeaddrinfo(ai);
}
}
}
@@ -1216,11 +1189,7 @@ boolean I_InitTcpDriver(void)
if (!init_tcp_driver)
{
#ifdef USE_WINSOCK
#ifdef USE_WINSOCK2
const WORD VerNeed = MAKEWORD(2,2);
#else
const WORD VerNeed = MAKEWORD(1,1);
#endif
WSADATA WSAData;
const int WSAresult = WSAStartup(VerNeed, &WSAData);
if (WSAresult != 0)
@@ -1247,21 +1216,14 @@ boolean I_InitTcpDriver(void)
if (WSAresult != WSAVERNOTSUPPORTED)
CONS_Debug(DBG_NETPLAY, "WinSock(TCP/IP) error: %s\n",WSError);
}
#ifdef USE_WINSOCK2
if(LOBYTE(WSAData.wVersion) != 2 ||
if (LOBYTE(WSAData.wVersion) != 2 ||
HIBYTE(WSAData.wVersion) != 2)
{
WSACleanup();
CONS_Debug(DBG_NETPLAY, "No WinSock(TCP/IP) 2.2 driver detected\n");
}
#else
if (LOBYTE(WSAData.wVersion) != 1 ||
HIBYTE(WSAData.wVersion) != 1)
{
WSACleanup();
CONS_Debug(DBG_NETPLAY, "No WinSock(TCP/IP) 1.1 driver detected\n");
}
#endif
CONS_Debug(DBG_NETPLAY, "WinSock description: %s\n",WSAData.szDescription);
CONS_Debug(DBG_NETPLAY, "WinSock System Status: %s\n",WSAData.szSystemStatus);
#endif
@@ -1301,7 +1263,6 @@ void I_ShutdownTcpDriver(void)
CONS_Printf("I_ShutdownTcpDriver: ");
#ifdef USE_WINSOCK
WS_addrinfocleanup();
WSACleanup();
#endif
CONS_Printf("shut down\n");
@@ -1310,24 +1271,24 @@ void I_ShutdownTcpDriver(void)
static boolean SOCK_GetAddr(struct sockaddr_in *sin, const char *address, const char *port, boolean test)
{
struct my_addrinfo *ai = NULL, *runp, hints;
addrinfo_t *ai = NULL, *runp, hints;
int gaie;
size_t i;
if (!port || !port[0])
port = DEFAULTPORT;
memset (&hints, 0x00, sizeof (hints));
memset(&hints, 0x00, sizeof (hints));
hints.ai_flags = AI_ADDRCONFIG;
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_DGRAM;
hints.ai_protocol = IPPROTO_UDP;
gaie = I_getaddrinfo(address, port, &hints, &ai);
gaie = getaddrinfo(address, port, &hints, &ai);
if (gaie != 0)
{
I_freeaddrinfo(ai);
freeaddrinfo(ai);
return false;
}
@@ -1356,7 +1317,7 @@ static boolean SOCK_GetAddr(struct sockaddr_in *sin, const char *address, const
if (runp != NULL)
memcpy(sin, runp->ai_addr, runp->ai_addrlen);
I_freeaddrinfo(ai);
freeaddrinfo(ai);
return (runp != NULL);
}
@@ -1554,7 +1515,7 @@ static boolean SOCK_SetUnbanTime(time_t timestamp)
static boolean SOCK_SetBanAddress(const char *address, const char *mask)
{
struct my_addrinfo *ai, *runp, hints;
addrinfo_t *ai, *runp, hints;
int gaie;
if (!address)
@@ -1566,7 +1527,7 @@ static boolean SOCK_SetBanAddress(const char *address, const char *mask)
hints.ai_socktype = SOCK_DGRAM;
hints.ai_protocol = IPPROTO_UDP;
gaie = I_getaddrinfo(address, "0", &hints, &ai);
gaie = getaddrinfo(address, "0", &hints, &ai);
if (gaie != 0)
return false;
@@ -1611,7 +1572,7 @@ static boolean SOCK_SetBanAddress(const char *address, const char *mask)
runp = runp->ai_next;
}
I_freeaddrinfo(ai);
freeaddrinfo(ai);
return true;
}
@@ -1660,8 +1621,6 @@ boolean I_InitTcpNetwork(void)
// FIXME: for dedicated server, numnodes needs to be set to 0 upon start
if (dedicated)
doomcom->numnodes = 0;
/* else if (M_IsNextParm())
doomcom->numnodes = (INT16)atoi(M_GetNextParm());*/
else
doomcom->numnodes = 1;
@@ -1746,5 +1705,3 @@ boolean I_InitTcpNetwork(void)
return ret;
}
#include "i_addrinfo.c"
+1 -1
View File
@@ -94,8 +94,8 @@ INT32 VID_SetMode(INT32 modenum);
\return name of video mode
*/
const char *VID_GetModeName(INT32 modenum);
void VID_PrepareModeList(void); /// note hack for SDL
void VID_PrepareModeList(void);
/** \brief can video system do fullscreen
*/
+60 -16
View File
@@ -797,8 +797,12 @@ static UINT8 ArchiveValue(UINT8 **p, int TABLESINDEX, int myindex)
{
mobj_t *mobj = *((mobj_t **)lua_touserdata(gL, myindex));
if (!mobj)
{
WRITEUINT8(*p, ARCH_NULL);
else {
return 3;
}
else
{
WRITEUINT8(*p, ARCH_MOBJ);
WRITEUINT32(*p, mobj->mobjnum);
}
@@ -808,8 +812,12 @@ static UINT8 ArchiveValue(UINT8 **p, int TABLESINDEX, int myindex)
{
player_t *player = *((player_t **)lua_touserdata(gL, myindex));
if (!player)
{
WRITEUINT8(*p, ARCH_NULL);
else {
return 3;
}
else
{
WRITEUINT8(*p, ARCH_PLAYER);
WRITEUINT8(*p, player - players);
}
@@ -819,8 +827,12 @@ static UINT8 ArchiveValue(UINT8 **p, int TABLESINDEX, int myindex)
{
mapthing_t *mapthing = *((mapthing_t **)lua_touserdata(gL, myindex));
if (!mapthing)
{
WRITEUINT8(*p, ARCH_NULL);
else {
return 3;
}
else
{
WRITEUINT8(*p, ARCH_MAPTHING);
WRITEUINT16(*p, mapthing - mapthings);
}
@@ -830,8 +842,12 @@ static UINT8 ArchiveValue(UINT8 **p, int TABLESINDEX, int myindex)
{
vertex_t *vertex = *((vertex_t **)lua_touserdata(gL, myindex));
if (!vertex)
{
WRITEUINT8(*p, ARCH_NULL);
else {
return 3;
}
else
{
WRITEUINT8(*p, ARCH_VERTEX);
WRITEUINT16(*p, vertex - vertexes);
}
@@ -841,8 +857,12 @@ static UINT8 ArchiveValue(UINT8 **p, int TABLESINDEX, int myindex)
{
line_t *line = *((line_t **)lua_touserdata(gL, myindex));
if (!line)
{
WRITEUINT8(*p, ARCH_NULL);
else {
return 3;
}
else
{
WRITEUINT8(*p, ARCH_LINE);
WRITEUINT16(*p, line - lines);
}
@@ -852,8 +872,12 @@ static UINT8 ArchiveValue(UINT8 **p, int TABLESINDEX, int myindex)
{
side_t *side = *((side_t **)lua_touserdata(gL, myindex));
if (!side)
{
WRITEUINT8(*p, ARCH_NULL);
else {
return 3;
}
else
{
WRITEUINT8(*p, ARCH_SIDE);
WRITEUINT16(*p, side - sides);
}
@@ -863,8 +887,12 @@ static UINT8 ArchiveValue(UINT8 **p, int TABLESINDEX, int myindex)
{
subsector_t *subsector = *((subsector_t **)lua_touserdata(gL, myindex));
if (!subsector)
{
WRITEUINT8(*p, ARCH_NULL);
else {
return 3;
}
else
{
WRITEUINT8(*p, ARCH_SUBSECTOR);
WRITEUINT16(*p, subsector - subsectors);
}
@@ -874,8 +902,12 @@ static UINT8 ArchiveValue(UINT8 **p, int TABLESINDEX, int myindex)
{
sector_t *sector = *((sector_t **)lua_touserdata(gL, myindex));
if (!sector)
{
WRITEUINT8(*p, ARCH_NULL);
else {
return 3;
}
else
{
WRITEUINT8(*p, ARCH_SECTOR);
WRITEUINT16(*p, sector - sectors);
}
@@ -885,8 +917,12 @@ static UINT8 ArchiveValue(UINT8 **p, int TABLESINDEX, int myindex)
{
pslope_t *slope = *((pslope_t **)lua_touserdata(gL, myindex));
if (!slope)
{
WRITEUINT8(*p, ARCH_NULL);
else {
return 3;
}
else
{
WRITEUINT8(*p, ARCH_SLOPE);
WRITEUINT16(*p, slope->id);
}
@@ -896,8 +932,12 @@ static UINT8 ArchiveValue(UINT8 **p, int TABLESINDEX, int myindex)
{
mapheader_t *header = *((mapheader_t **)lua_touserdata(gL, myindex));
if (!header)
{
WRITEUINT8(*p, ARCH_NULL);
else {
return 3;
}
else
{
WRITEUINT8(*p, ARCH_MAPHEADER);
WRITEUINT16(*p, header - *mapheaderinfo);
}
@@ -1003,19 +1043,23 @@ static void ArchiveTables(UINT8 **p)
e = ArchiveValue(p, TABLESINDEX, -2); // key should be either a number or a string, ArchiveValue can handle this.
if (e == 2) // invalid key type (function, thread, lightuserdata, or anything we don't recognise)
{
lua_pushvalue(gL, -2);
CONS_Alert(CONS_ERROR, "Index '%s' (%s) of table %d could not be archived!\n", lua_tostring(gL, -1), luaL_typename(gL, -1), i);
lua_pop(gL, 1);
CONS_Alert(CONS_ERROR, "Index '%s' (%s) of table %d could not be archived!\n", lua_tostring(gL, -2), luaL_typename(gL, -2), i);
}
else if (e == 3) // nil key due to invalid userdata. NOT an error.
{
lua_pop(gL, 1);
continue;
}
// Write value
e = ArchiveValue(p, TABLESINDEX, -1);
if (e == 1)
{
n++; // the table contained a new table we'll have to archive. :(
}
else if (e == 2) // invalid value type
{
lua_pushvalue(gL, -2);
CONS_Alert(CONS_ERROR, "Type of value for table %d entry '%s' (%s) could not be archived!\n", i, lua_tostring(gL, -1), luaL_typename(gL, -1));
lua_pop(gL, 1);
CONS_Alert(CONS_ERROR, "Type of value for table %d entry '%s' (%s) could not be archived!\n", i, lua_tostring(gL, -2), luaL_typename(gL, -1));
}
lua_pop(gL, 1);
+2 -2
View File
@@ -92,7 +92,7 @@ void M_LoadEmotes(UINT16 wadnum)
if (emote_name.size() > MAXEMOTENAME)
{
CONS_Alert(CONS_WARNING, "EMOTES: Emote name is too long, truncating. (file %s, line %d)\n", wadfiles[wadnum]->filename, linenum);
emote_name = emote_name.substr(0, MAXEMOTENAME);
emote_name.resize(MAXEMOTENAME);
}
emote = &emotes[emote_name];
@@ -139,7 +139,7 @@ void M_LoadEmotes(UINT16 wadnum)
if (framelumpname.size() > 8)
{
CONS_Alert(CONS_WARNING, "EMOTES: Frame %d name is too long. (file %s, line %d)", numframes, wadfiles[wadnum]->filename, linenum);
framelumpname = framelumpname.substr(0, 8);
framelumpname.resize(8);
}
std::strncpy(emote->frames[numframes], framelumpname.c_str(), framelumpname.size()+1);
+1 -2
View File
@@ -9442,9 +9442,8 @@ static void M_VideoModeMenu(INT32 choice)
memset(modedescs, 0, sizeof(modedescs));
#if defined (__unix__) || defined (UNIXCOMMON) || defined (HAVE_SDL)
VID_PrepareModeList(); // FIXME: hack
#endif
vidm_nummodes = 0;
vidm_selected = 0;
nummodes = VID_NumModes();
+32 -32
View File
@@ -61,7 +61,7 @@ typedef enum
//
// P_ArchivePlayer
//
static inline void P_ArchivePlayer(savebuffer_t *save)
FUNCINLINE static ATTRINLINE void P_ArchivePlayer(savebuffer_t *save)
{
const player_t *player = &players[consoleplayer];
INT32 pllives = player->lives;
@@ -85,7 +85,7 @@ static inline void P_ArchivePlayer(savebuffer_t *save)
//
// P_UnArchivePlayer
//
static inline void P_UnArchivePlayer(savebuffer_t *save)
FUNCINLINE static ATTRINLINE void P_UnArchivePlayer(savebuffer_t *save)
{
savedata.skincolor = READUINT8(save->p);
savedata.skin = READUINT8(save->p);
@@ -1043,25 +1043,25 @@ typedef enum
tc_end
} specials_e;
static inline UINT32 SaveMobjnum(const mobj_t *mobj)
FUNCINLINE static ATTRINLINE UINT32 SaveMobjnum(const mobj_t *mobj)
{
if (mobj) return mobj->mobjnum;
return 0;
}
static inline UINT32 SaveSector(const sector_t *sector)
FUNCINLINE static ATTRINLINE UINT32 SaveSector(const sector_t *sector)
{
if (sector) return (UINT32)(sector - sectors);
return 0xFFFFFFFF;
}
static inline UINT32 SaveLine(const line_t *line)
FUNCINLINE static ATTRINLINE UINT32 SaveLine(const line_t *line)
{
if (line) return (UINT32)(line - lines);
return 0xFFFFFFFF;
}
static inline UINT32 SavePlayer(const player_t *player)
FUNCINLINE static ATTRINLINE UINT32 SavePlayer(const player_t *player)
{
if (player) return (UINT32)(player - players);
return 0xFFFFFFFF;
@@ -1476,7 +1476,7 @@ static void SaveElevatorThinker(savebuffer_t *save, const thinker_t *th, const U
//
// Saves a scroll_t thinker
//
static inline void SaveScrollThinker(savebuffer_t *save, const thinker_t *th, const UINT8 type)
FUNCINLINE static ATTRINLINE void SaveScrollThinker(savebuffer_t *save, const thinker_t *th, const UINT8 type)
{
const scroll_t *ht = (const void *)th;
WRITEUINT8(save->p, type);
@@ -1497,7 +1497,7 @@ static inline void SaveScrollThinker(savebuffer_t *save, const thinker_t *th, co
//
// Saves a friction_t thinker
//
static inline void SaveFrictionThinker(savebuffer_t *save, const thinker_t *th, const UINT8 type)
FUNCINLINE static ATTRINLINE void SaveFrictionThinker(savebuffer_t *save, const thinker_t *th, const UINT8 type)
{
const friction_t *ht = (const void *)th;
WRITEUINT8(save->p, type);
@@ -1513,7 +1513,7 @@ static inline void SaveFrictionThinker(savebuffer_t *save, const thinker_t *th,
//
// Saves a pusher_t thinker
//
static inline void SavePusherThinker(savebuffer_t *save, const thinker_t *th, const UINT8 type)
FUNCINLINE static ATTRINLINE void SavePusherThinker(savebuffer_t *save, const thinker_t *th, const UINT8 type)
{
const pusher_t *ht = (const void *)th;
WRITEUINT8(save->p, type);
@@ -1598,7 +1598,7 @@ static void SaveDisappearThinker(savebuffer_t *save, const thinker_t *th, const
//
// Saves a polyrotate_t thinker
//
static inline void SavePolyrotatetThinker(savebuffer_t *save, const thinker_t *th, const UINT8 type)
FUNCINLINE static ATTRINLINE void SavePolyrotatetThinker(savebuffer_t *save, const thinker_t *th, const UINT8 type)
{
const polyrotate_t *ht = (const void *)th;
WRITEUINT8(save->p, type);
@@ -1935,25 +1935,25 @@ mobj_t *P_FindNewPosition(UINT32 oldposition)
return NULL;
}
static inline mobj_t *LoadMobj(UINT32 mobjnum)
FUNCINLINE static ATTRINLINE mobj_t *LoadMobj(UINT32 mobjnum)
{
if (mobjnum == 0) return NULL;
return (mobj_t *)(size_t)mobjnum;
}
static inline sector_t *LoadSector(UINT32 sector)
FUNCINLINE static ATTRINLINE sector_t *LoadSector(UINT32 sector)
{
if (sector >= numsectors) return NULL;
return &sectors[sector];
}
static inline line_t *LoadLine(UINT32 line)
FUNCINLINE static ATTRINLINE line_t *LoadLine(UINT32 line)
{
if (line >= numlines) return NULL;
return &lines[line];
}
static inline player_t *LoadPlayer(UINT32 player)
FUNCINLINE static ATTRINLINE player_t *LoadPlayer(UINT32 player)
{
if (player >= MAXPLAYERS) return NULL;
return &players[player];
@@ -2529,7 +2529,7 @@ static void LoadScrollThinker(savebuffer_t *save, actionf_p1 thinker)
//
// Loads a friction_t from a save game
//
static inline void LoadFrictionThinker(savebuffer_t *save, actionf_p1 thinker)
FUNCINLINE static ATTRINLINE void LoadFrictionThinker(savebuffer_t *save, actionf_p1 thinker)
{
friction_t *ht = (friction_t*)Z_LevelPoolMalloc(sizeof (*ht));
ht->thinker.alloctype = TAT_LEVELPOOL;
@@ -2576,7 +2576,7 @@ static void LoadPusherThinker(savebuffer_t *save, actionf_p1 thinker)
//
// Loads a laserthink_t from a save game
//
static inline void LoadLaserThinker(savebuffer_t *save, actionf_p1 thinker)
FUNCINLINE static ATTRINLINE void LoadLaserThinker(savebuffer_t *save, actionf_p1 thinker)
{
laserthink_t *ht = (laserthink_t*)Z_LevelPoolMalloc(sizeof (*ht));
ht->thinker.alloctype = TAT_LEVELPOOL;
@@ -2621,7 +2621,7 @@ FUNCINLINE static ATTRINLINE void LoadLightlevelThinker(savebuffer_t *save, acti
//
// Loads a executor_t from a save game
//
static inline void LoadExecutorThinker(savebuffer_t *save, actionf_p1 thinker)
FUNCINLINE static ATTRINLINE void LoadExecutorThinker(savebuffer_t *save, actionf_p1 thinker)
{
executor_t *ht = (executor_t*)Z_LevelPoolMalloc(sizeof (*ht));
ht->thinker.alloctype = TAT_LEVELPOOL;
@@ -2639,7 +2639,7 @@ static inline void LoadExecutorThinker(savebuffer_t *save, actionf_p1 thinker)
//
// Loads a disappear_t thinker
//
static inline void LoadDisappearThinker(savebuffer_t *save, actionf_p1 thinker)
FUNCINLINE static ATTRINLINE void LoadDisappearThinker(savebuffer_t *save, actionf_p1 thinker)
{
disappear_t *ht = (disappear_t*)Z_LevelPoolMalloc(sizeof (*ht));
ht->thinker.alloctype = TAT_LEVELPOOL;
@@ -2660,7 +2660,7 @@ static inline void LoadDisappearThinker(savebuffer_t *save, actionf_p1 thinker)
//
// Loads a polyrotate_t thinker
//
static inline void LoadPolyrotatetThinker(savebuffer_t *save, actionf_p1 thinker)
FUNCINLINE static ATTRINLINE void LoadPolyrotatetThinker(savebuffer_t *save, actionf_p1 thinker)
{
polyrotate_t *ht = (polyrotate_t*)Z_LevelPoolMalloc(sizeof (*ht));
ht->thinker.alloctype = TAT_LEVELPOOL;
@@ -2720,7 +2720,7 @@ static void LoadPolymoveThinker(savebuffer_t *save, actionf_p1 thinker)
//
// Loads a polywaypoint_t thinker
//
static inline void LoadPolywaypointThinker(savebuffer_t *save, actionf_p1 thinker)
FUNCINLINE static ATTRINLINE void LoadPolywaypointThinker(savebuffer_t *save, actionf_p1 thinker)
{
polywaypoint_t *ht = (polywaypoint_t*)Z_LevelPoolMalloc(sizeof (*ht));
ht->thinker.alloctype = TAT_LEVELPOOL;
@@ -2776,7 +2776,7 @@ static inline void LoadPolywaypointThinker(savebuffer_t *save, actionf_p1 thinke
//
// loads a polyslidedoor_t thinker
//
static inline void LoadPolyslidedoorThinker(savebuffer_t *save, actionf_p1 thinker)
FUNCINLINE static ATTRINLINE void LoadPolyslidedoorThinker(savebuffer_t *save, actionf_p1 thinker)
{
polyslidedoor_t *ht = (polyslidedoor_t*)Z_LevelPoolMalloc(sizeof (*ht));
ht->thinker.alloctype = TAT_LEVELPOOL;
@@ -2814,7 +2814,7 @@ static inline void LoadPolyslidedoorThinker(savebuffer_t *save, actionf_p1 think
//
// Loads a polyswingdoor_t thinker
//
static inline void LoadPolyswingdoorThinker(savebuffer_t *save, actionf_p1 thinker)
FUNCINLINE static ATTRINLINE void LoadPolyswingdoorThinker(savebuffer_t *save, actionf_p1 thinker)
{
polyswingdoor_t *ht = (polyswingdoor_t*)Z_LevelPoolMalloc(sizeof (*ht));
ht->thinker.alloctype = TAT_LEVELPOOL;
@@ -2847,7 +2847,7 @@ static inline void LoadPolyswingdoorThinker(savebuffer_t *save, actionf_p1 think
//
// Loads a polydisplace_t thinker
//
static inline void LoadPolydisplaceThinker(savebuffer_t *save, actionf_p1 thinker)
FUNCINLINE static ATTRINLINE void LoadPolydisplaceThinker(savebuffer_t *save, actionf_p1 thinker)
{
polydisplace_t *ht = (polydisplace_t*)Z_LevelPoolMalloc(sizeof (*ht));
ht->thinker.alloctype = TAT_LEVELPOOL;
@@ -3115,7 +3115,7 @@ static void P_NetUnArchiveThinkers(savebuffer_t *save)
#define PD_FLAGS 0x01
#define PD_TRANS 0x02
static inline void P_ArchivePolyObj(savebuffer_t *save, polyobj_t *po)
FUNCINLINE static ATTRINLINE void P_ArchivePolyObj(savebuffer_t *save, polyobj_t *po)
{
UINT8 diff = 0;
WRITEINT32(save->p, po->id);
@@ -3137,7 +3137,7 @@ static inline void P_ArchivePolyObj(savebuffer_t *save, polyobj_t *po)
WRITEINT32(save->p, po->translucency);
}
static inline void P_UnArchivePolyObj(savebuffer_t *save, polyobj_t *po)
FUNCINLINE static ATTRINLINE void P_UnArchivePolyObj(savebuffer_t *save, polyobj_t *po)
{
INT32 id;
UINT32 angle;
@@ -3172,7 +3172,7 @@ static inline void P_UnArchivePolyObj(savebuffer_t *save, polyobj_t *po)
Polyobj_MoveOnLoad(po, angle, x, y);
}
static inline void P_ArchivePolyObjects(savebuffer_t *save)
FUNCINLINE static ATTRINLINE void P_ArchivePolyObjects(savebuffer_t *save)
{
INT32 i;
@@ -3185,7 +3185,7 @@ static inline void P_ArchivePolyObjects(savebuffer_t *save)
P_ArchivePolyObj(save, &PolyObjects[i]);
}
static inline void P_UnArchivePolyObjects(savebuffer_t *save)
FUNCINLINE static ATTRINLINE void P_UnArchivePolyObjects(savebuffer_t *save)
{
INT32 i, numSavedPolys;
@@ -3203,7 +3203,7 @@ static inline void P_UnArchivePolyObjects(savebuffer_t *save)
//
// P_FinishMobjs
//
static inline void P_FinishMobjs(void)
FUNCINLINE static ATTRINLINE void P_FinishMobjs(void)
{
thinker_t *currentthinker;
mobj_t *mobj;
@@ -3220,7 +3220,7 @@ static inline void P_FinishMobjs(void)
}
}
static inline mobj_t *RelinkMobj(mobj_t **ptr)
FUNCINLINE static ATTRINLINE mobj_t *RelinkMobj(mobj_t **ptr)
{
UINT32 temp = (UINT32)(size_t)*ptr;
*ptr = NULL;
@@ -3269,7 +3269,7 @@ static void P_RelinkPointers(void)
//
// P_NetArchiveSpecials
//
static inline void P_NetArchiveSpecials(savebuffer_t *save)
FUNCINLINE static ATTRINLINE void P_NetArchiveSpecials(savebuffer_t *save)
{
size_t i, z;
@@ -3347,7 +3347,7 @@ static void P_NetUnArchiveSpecials(savebuffer_t *save)
// =======================================================================
// Misc
// =======================================================================
static inline void P_ArchiveMisc(savebuffer_t *save)
FUNCINLINE static ATTRINLINE void P_ArchiveMisc(savebuffer_t *save)
{
if (gamecomplete)
WRITEINT16(save->p, gamemap | 8192);
@@ -3360,7 +3360,7 @@ static inline void P_ArchiveMisc(savebuffer_t *save)
WRITESTRINGN(save->p, timeattackfolder, sizeof(timeattackfolder));
}
static inline void P_UnArchiveSPGame(savebuffer_t *save, INT16 mapoverride)
FUNCINLINE static ATTRINLINE void P_UnArchiveSPGame(savebuffer_t *save, INT16 mapoverride)
{
char testname[sizeof(timeattackfolder)];
+104 -144
View File
@@ -41,8 +41,7 @@
/** \brief view info
*/
INT32 linesize, viewwidth, viewheight, viewwindowx, viewwindowy;
UINT8 *renderscreen; // haleyjd
INT32 viewwidth, viewheight, viewwindowx, viewwindowy;
// =========================================================================
// COLUMN DRAWING CODE STUFF
@@ -489,6 +488,92 @@ void R_FlushTranslationColormapCache(void)
// in reality, the few routines that can work for either mode, are
// put here
enum columncontext_e columncontext = COLUMNCONTEXT_DIRECT;
enum ColumnFlushType
{
FLUSH_NONE = 0x0000,
FLUSH_OPAQUE = 0x0001,
FLUSH_TRANS = 0x0002,
FLUSH_COLORMAP = 0x0004,
FLUSH_COLORMAP_TRANS = 0x0008,
};
typedef struct drawcolumndata_temp_s
{
INT32 x;
INT32 yl[8], yh[8];
// e6y: resolution limitation is removed
UINT8 *buf;
INT32 startx;
ColumnFlushType type;
INT32 commontop, commonbot;
UINT8 *transmap;
// SoM 7-28-04: Fix the fuzz problem.
UINT8 *translation;
} drawcolumndata_temp_t;
drawcolumndata_temp_t temp_dc = {};
//
// Error functions that will abort if R_FlushColumns tries to flush
// columns without a column type.
//
FUNCNORETURN static ATTRNORETURN void R_FlushWholeError(void)
{
I_Error("R_FlushWholeColumns called without being initialized.\n");
}
FUNCNORETURN static ATTRNORETURN void R_FlushHTError(void)
{
I_Error("R_FlushHTColumns called without being initialized.\n");
}
FUNCNORETURN static ATTRNORETURN void R_QuadFlushError(void)
{
I_Error("R_FlushQuadColumn called without being initialized.\n");
}
static void (*R_FlushWholeColumns)(void) = R_FlushWholeError;
static void (*R_FlushHTColumns)(void) = R_FlushHTError;
static void (*R_FlushQuadColumn)(void) = R_QuadFlushError;
static void R_FlushColumns(void)
{
if (temp_dc.x != 8 || temp_dc.commontop >= temp_dc.commonbot)
R_FlushWholeColumns();
else
{
R_FlushHTColumns();
R_FlushQuadColumn();
}
temp_dc.x = 0;
}
//
// R_ResetColumnBuffer
//
// haleyjd 09/13/04: new function to call from main rendering loop
// which gets rid of the unnecessary reset of various variables during
// column drawing.
//
void R_ResetColumnBuffer(void)
{
// haleyjd 10/06/05: this must not be done if x == 0!
if (temp_dc.x)
{
R_FlushColumns();
}
temp_dc.type = FLUSH_NONE;
R_FlushWholeColumns = R_FlushWholeError;
R_FlushHTColumns = R_FlushHTError;
R_FlushQuadColumn = R_QuadFlushError;
}
/** \brief The R_InitViewBuffer function
Creates lookup tables for getting the framebuffer address
@@ -521,7 +606,6 @@ static void R_AllocViewMemory(void)
R_AllocVisSpriteMemory();
}
void R_InitViewBuffer(INT32 width, INT32 height)
{
if (width > MAXVIDWIDTH)
@@ -534,27 +618,26 @@ void R_InitViewBuffer(INT32 width, INT32 height)
viewwindowx = 0;
viewwindowy = 0;
linesize = vid.width; // killough 11/98
renderscreen = vid.screens[0]; // haleyjd 07/02/14
}
INT32 bufsize = (vid.width * 8) * sizeof(*temp_dc.buf);
/** \brief viewborder patches lump numbers
*/
lumpnum_t viewborderlump[8];
if (temp_dc.buf)
{
#if defined(__SSE__)
aligned_free(temp_dc.buf);
#else
Z_Free(temp_dc.buf);
#endif
}
/** \brief Store the lumpnumber of the viewborder patches
*/
memset(&temp_dc, 0, sizeof(temp_dc));
void R_InitViewBorder(void)
{
viewborderlump[BRDR_T] = W_GetNumForName("brdr_t");
viewborderlump[BRDR_B] = W_GetNumForName("brdr_b");
viewborderlump[BRDR_L] = W_GetNumForName("brdr_l");
viewborderlump[BRDR_R] = W_GetNumForName("brdr_r");
viewborderlump[BRDR_TL] = W_GetNumForName("brdr_tl");
viewborderlump[BRDR_BL] = W_GetNumForName("brdr_bl");
viewborderlump[BRDR_TR] = W_GetNumForName("brdr_tr");
viewborderlump[BRDR_BR] = W_GetNumForName("brdr_br");
#if defined(__SSE__)
while (bufsize & 15)
bufsize++;
temp_dc.buf = static_cast<UINT8*>(aligned_alloc(16, bufsize));
#else
temp_dc.buf = static_cast<UINT8*>(Z_Calloc(bufsize, PU_STATIC, NULL));
#endif
}
/** \brief The R_VideoErase function
@@ -578,129 +661,6 @@ void R_VideoErase(size_t ofs, INT32 count)
M_Memcpy(vid.screens[0] + ofs, vid.screens[1] + ofs, count);
}
#if 0
/** \brief R_FillBackScreen
Fills the back screen with a pattern for variable screen sizes
Also draws a beveled edge.
*/
void R_FillBackScreen(void)
{
UINT8 *src, *dest;
patch_t *patch;
INT32 x, y, step, boff;
// quickfix, don't cache lumps in both modes
if (rendermode != render_soft)
return;
// draw pattern around the status bar too (when hires),
// so return only when in full-screen without status bar.
if (scaledviewwidth == vid.width && viewheight == vid.height)
return;
src = scr_borderpatch;
dest = vid.screens[1];
for (y = 0; y < vid.height; y++)
{
for (x = 0; x < vid.width/128; x++)
{
M_Memcpy (dest, src+((y&127)<<7), 128);
dest += 128;
}
if (vid.width&127)
{
M_Memcpy(dest, src+((y&127)<<7), vid.width&127);
dest += (vid.width&127);
}
}
// don't draw the borders when viewwidth is full vid.width.
if (scaledviewwidth == vid.width)
return;
step = 8;
boff = 8;
patch = W_CacheLumpNum(viewborderlump[BRDR_T], PU_CACHE);
for (x = 0; x < scaledviewwidth; x += step)
V_DrawPatch(viewwindowx + x, viewwindowy - boff, 1, patch);
patch = W_CacheLumpNum(viewborderlump[BRDR_B], PU_CACHE);
for (x = 0; x < scaledviewwidth; x += step)
V_DrawPatch(viewwindowx + x, viewwindowy + viewheight, 1, patch);
patch = W_CacheLumpNum(viewborderlump[BRDR_L], PU_CACHE);
for (y = 0; y < viewheight; y += step)
V_DrawPatch(viewwindowx - boff, viewwindowy + y, 1, patch);
patch = W_CacheLumpNum(viewborderlump[BRDR_R],PU_CACHE);
for (y = 0; y < viewheight; y += step)
V_DrawPatch(viewwindowx + scaledviewwidth, viewwindowy + y, 1,
patch);
// Draw beveled corners.
V_DrawPatch(viewwindowx - boff, viewwindowy - boff, 1,
W_CacheLumpNum(viewborderlump[BRDR_TL], PU_CACHE));
V_DrawPatch(viewwindowx + scaledviewwidth, viewwindowy - boff, 1,
W_CacheLumpNum(viewborderlump[BRDR_TR], PU_CACHE));
V_DrawPatch(viewwindowx - boff, viewwindowy + viewheight, 1,
W_CacheLumpNum(viewborderlump[BRDR_BL], PU_CACHE));
V_DrawPatch(viewwindowx + scaledviewwidth, viewwindowy + viewheight, 1,
W_CacheLumpNum(viewborderlump[BRDR_BR], PU_CACHE));
}
/** \brief The R_DrawViewBorder
Draws the border around the view
for different size windows?
*/
void R_DrawViewBorder(void)
{
INT32 top, side, ofs;
if (rendermode == render_none)
return;
#ifdef HWRENDER
if (rendermode != render_soft)
{
HWR_DrawViewBorder(0);
return;
}
else
#endif
#ifdef DEBUG
fprintf(stderr,"RDVB: vidwidth %d vidheight %d scaledviewwidth %d viewheight %d\n",
vid.width, vid.height, scaledviewwidth, viewheight);
#endif
if (scaledviewwidth == vid.width)
return;
top = (vid.height - viewheight)>>1;
side = (vid.width - scaledviewwidth)>>1;
// copy top and one line of left side
R_VideoErase(0, top*vid.width+side);
// copy one line of right side and bottom
ofs = (viewheight+top)*vid.width - side;
R_VideoErase(ofs, top*vid.width + side);
// copy sides using wraparound
ofs = top*vid.width + vid.width-side;
side <<= 1;
// simpler using our VID_Blit routine
VID_BlitLinearScreen(vid.screens[1] + ofs, vid.screens[0] + ofs, side, viewheight - 1,
vid.width, vid.width);
}
#endif
// ==========================================================================
// INCLUDE DRAWING CODE HERE
// ==========================================================================
+22 -32
View File
@@ -25,12 +25,10 @@ extern "C" {
// -------------------------------
// COMMON STUFF FOR 8bpp AND 16bpp
// -------------------------------
extern UINT8 *renderscreen;
extern INT32 linesize;
FUNCINLINE static ATTRINLINE UINT8 *R_Address(INT32 px, INT32 py)
{
return renderscreen + (py + viewwindowy) * linesize + (viewwindowx + px);
return vid.screens[0] + (py + viewwindowy) * vid.width + (viewwindowx + px);
}
@@ -102,6 +100,16 @@ extern floatv3_t *ds_su, *ds_sv, *ds_sz;
extern float focallengthf;
enum columncontext_e
{
COLUMNCONTEXT_DIRECT = 0,
COLUMNCONTEXT_FLUSH,
};
extern enum columncontext_e columncontext;
void R_SetColumnContext(enum columncontext_e _columncontext);
void R_ResetColumnBuffer(void);
typedef void (coldrawfunc_t)(drawcolumndata_t*);
typedef void (spandrawfunc_t)(drawspandata_t*);
@@ -152,27 +160,8 @@ extern spandrawfunc_t *spanfuncs[SPANDRAWFUNC_MAX];
void R_DrawMaskedColumn(drawcolumndata_t* dc, column_t *column);
/// \brief Top border
#define BRDR_T 0
/// \brief Bottom border
#define BRDR_B 1
/// \brief Left border
#define BRDR_L 2
/// \brief Right border
#define BRDR_R 3
/// \brief Topleft border
#define BRDR_TL 4
/// \brief Topright border
#define BRDR_TR 5
/// \brief Bottomleft border
#define BRDR_BL 6
/// \brief Bottomright border
#define BRDR_BR 7
extern lumpnum_t viewborderlump[8];
// ------------------------------------------------
// r_draw.c COMMON ROUTINES FOR BOTH 8bpp and 16bpp
// r_draw.c
// ------------------------------------------------
#define GTC_CACHE 1
@@ -221,17 +210,8 @@ boolean R_BlendLevelVisible(INT32 blendmode, INT32 alphalevel);
// Custom player skin translation
void R_InitViewBuffer(INT32 width, INT32 height);
void R_InitViewBorder(void);
void R_VideoErase(size_t ofs, INT32 count);
// Rendering function.
#if 0
void R_FillBackScreen(void);
// If the view size is not full screen, draws a border around it.
void R_DrawViewBorder(void);
#endif
#define TRANSPARENTPIXEL 247
// -----------------
@@ -250,8 +230,18 @@ void R_DrawTranslatedTranslucentColumn(drawcolumndata_t* dc);
void R_Draw2sMultiPatchColumn(drawcolumndata_t* dc);
void R_Draw2sMultiPatchTranslucentColumn(drawcolumndata_t* dc);
// column drawers which use buffered drawing with flush
void R_DrawColumnFlush(drawcolumndata_t* dc);
void R_DrawTranslucentColumnFlush(drawcolumndata_t* dc);
void R_DrawTranslatedColumnFlush(drawcolumndata_t* dc);
void R_DrawColumnShadowedFlush(drawcolumndata_t* dc);
void R_DrawTranslatedTranslucentColumnFlush(drawcolumndata_t* dc);
void R_Draw2sMultiPatchColumnFlush(drawcolumndata_t* dc);
void R_Draw2sMultiPatchTranslucentColumnFlush(drawcolumndata_t* dc);
void R_DrawFogColumn(drawcolumndata_t* dc);
// span drawers
void R_DrawSpan(drawspandata_t* ds);
+76 -18
View File
@@ -21,6 +21,8 @@
// a has a constant z depth from top to bottom.
//
#include "r_draw_flush.cpp"
enum DrawColumnType
{
DC_BASIC = 0x0000,
@@ -28,10 +30,12 @@ enum DrawColumnType
DC_TRANSMAP = 0x0002,
DC_HOLES = 0x0004,
DC_LIGHTLIST = 0x0008,
DC_DIRECT = 0x0010, // draw our columns directly to screen!
};
template<DrawColumnType Type>
static constexpr UINT8 R_GetColumnTranslated(drawcolumndata_t* dc, UINT8 col, const UINT8 * restrict colormap)
FUNCINLINE static ATTRINLINE constexpr UINT8
R_GetColumnTranslated(const drawcolumndata_t* dc, UINT8 col, const UINT8 * restrict colormap)
{
if constexpr (Type & DrawColumnType::DC_COLORMAP)
{
@@ -41,8 +45,10 @@ static constexpr UINT8 R_GetColumnTranslated(drawcolumndata_t* dc, UINT8 col, co
return colormap[col];
}
// translucency is handled on flush side now!
template<DrawColumnType Type>
static constexpr UINT8 R_GetColumnTranslucent(drawcolumndata_t* dc, UINT8 * restrict dest, UINT8 col, const UINT8 * restrict colormap)
FUNCINLINE static ATTRINLINE constexpr UINT8
R_GetColumnTranslucent(const drawcolumndata_t* dc, UINT8 * restrict dest, UINT8 col, const UINT8 * restrict colormap)
{
col = R_GetColumnTranslated<Type>(dc, col, colormap);
@@ -57,7 +63,8 @@ static constexpr UINT8 R_GetColumnTranslucent(drawcolumndata_t* dc, UINT8 * rest
}
template<DrawColumnType Type>
static constexpr UINT8 R_DrawColumnPixel(drawcolumndata_t* dc, UINT8 * restrict dest, UINT32 bit, const UINT8 * restrict source, const UINT8 * restrict colormap)
FUNCINLINE static ATTRINLINE constexpr UINT8
R_DrawColumnPixel(const drawcolumndata_t* dc, UINT8 * restrict dest, UINT32 bit, const UINT8 * restrict source, const UINT8 * restrict colormap)
{
UINT8 col = source[bit];
@@ -69,7 +76,14 @@ static constexpr UINT8 R_DrawColumnPixel(drawcolumndata_t* dc, UINT8 * restrict
}
}
return R_GetColumnTranslucent<Type>(dc, dest, col, colormap);
if constexpr (Type & DrawColumnType::DC_DIRECT)
{ // if we dont buffer our columns, we need to handle translucency again
return R_GetColumnTranslucent<Type>(dc, dest, col, colormap);
}
else
{
return R_GetColumnTranslated<Type>(dc, col, colormap);
}
}
/** \brief The R_DrawColumn function
@@ -80,8 +94,18 @@ static void R_DrawColumnTemplate(drawcolumndata_t *dc)
{
INT32 count;
// leban 1/17/99:
// removed the + 1 here, adjusted the if test, and added an increment
// later. this helps a compiler pipeline a bit better. the x86
// assembler also does this.
count = dc->yh - dc->yl;
// leban 1/17/99:
// this case isn't executed too often. depending on how many instructions
// there are between here and the second if test below, this case could
// be moved down and might save instructions overall. since there are
// probably different wads that favor one way or the other, i'll leave
// this alone for now.
if (count < 0) // Zero length, column does not exceed a pixel.
{
return;
@@ -150,6 +174,7 @@ static void R_DrawColumnTemplate(drawcolumndata_t *dc)
}
R_DrawColumnTemplate<NewType>(&dc_copy);
if (solid)
{
dc_copy.yl = bheight;
@@ -183,19 +208,37 @@ static void R_DrawColumnTemplate(drawcolumndata_t *dc)
// killough 2/1/98: more performance tuning
intptr_t frac;
// Looks familiar.
const intptr_t fracstep = dc->iscale;
const intptr_t heightmask = dc->sourcelength-1;
const intptr_t heightmask = dc->sourcelength-1; // CPhipps - specify type
constexpr INT32 npow2min = -1;
const INT32 npow2max = dc->sourcelength;
const INT32 stride = vid.width;
const UINT8 * restrict source = dc->source;
const lighttable_t * restrict colormap = dc->colormap;
// Framebuffer destination address.
UINT8 * restrict dest = R_Address(dc->x, dc->yl);
// SoM: MAGIC
UINT8 * restrict dest;
count++;
if constexpr (Type & DrawColumnType::DC_DIRECT)
dest = R_Address(dc->x, dc->yl);
else if constexpr ((Type & (DrawColumnType::DC_COLORMAP | DrawColumnType::DC_TRANSMAP))
== (DrawColumnType::DC_COLORMAP | DrawColumnType::DC_TRANSMAP))
dest = R_GetBufferColormapTrans(dc);
else if constexpr (Type & DrawColumnType::DC_TRANSMAP)
dest = R_GetBufferTrans(dc);
else if constexpr (Type & DrawColumnType::DC_COLORMAP)
dest = R_GetBufferColormap(dc);
else
dest = R_GetBufferOpaque(dc);
INT32 stride = 8; //SoM: Oh, Oh it's MAGIC! You know...
if constexpr (Type & DrawColumnType::DC_DIRECT)
stride = vid.width;
count++; // killough 1/99: minor tuning
// Determine scaling, which is the only mapping to be done.
frac = (dc->texturemid + FixedMul((dc->yl << FRACBITS) - centeryfrac, fracstep));
@@ -205,15 +248,16 @@ static void R_DrawColumnTemplate(drawcolumndata_t *dc)
case 255:
case 127:
{
while(count--)
while (count--)
{
*dest = R_DrawColumnPixel<Type>(dc, dest, (frac>>FRACBITS) & heightmask, source, colormap);
dest += stride;
frac += fracstep;
}
}
break;
case -1:
case npow2min:
{
if (frac < 0)
// adjust in case we underread
@@ -223,6 +267,7 @@ static void R_DrawColumnTemplate(drawcolumndata_t *dc)
while (--count >= 0)
{
*dest = R_DrawColumnPixel<Type>(dc, dest, frac>>FRACBITS, source, colormap);
dest += stride;
frac += fracstep;
}
@@ -235,10 +280,12 @@ static void R_DrawColumnTemplate(drawcolumndata_t *dc)
while ((count -= 2) >= 0) // texture height is a power of 2 -- killough
{
*dest = R_DrawColumnPixel<Type>(dc, dest, (frac>>FRACBITS) & heightmask, source, colormap);
dest += stride;
frac += fracstep;
*dest = R_DrawColumnPixel<Type>(dc, dest, (frac>>FRACBITS) & heightmask, source, colormap);
dest += stride;
frac += fracstep;
}
@@ -271,7 +318,7 @@ static void R_DrawColumnTemplate(drawcolumndata_t *dc)
{
// Re-map color indices from wall texture column
// using a lighting/special effects LUT.
// heightmask is the Tutti-Frutti fix
// heightmask is the Tutti-Frutti fix -- killough
// -1 is the lower clamp bound because column posts have a "safe" byte before the real data
// and a few bytes after as well
@@ -311,13 +358,24 @@ static void R_DrawColumnTemplate(drawcolumndata_t *dc)
R_DrawColumnTemplate<opt>(dc); \
}
DEFINE_COLUMN_FUNC(R_DrawColumn, DC_BASIC)
DEFINE_COLUMN_FUNC(R_DrawTranslucentColumn, DC_TRANSMAP)
DEFINE_COLUMN_FUNC(R_DrawTranslatedColumn, DC_COLORMAP)
DEFINE_COLUMN_FUNC(R_DrawColumnShadowed, DC_LIGHTLIST)
DEFINE_COLUMN_FUNC(R_DrawTranslatedTranslucentColumn, DC_COLORMAP|DC_TRANSMAP)
DEFINE_COLUMN_FUNC(R_Draw2sMultiPatchColumn, DC_HOLES)
DEFINE_COLUMN_FUNC(R_Draw2sMultiPatchTranslucentColumn, DC_HOLES|DC_TRANSMAP)
DEFINE_COLUMN_FUNC(R_DrawColumn, DC_DIRECT|DC_BASIC)
DEFINE_COLUMN_FUNC(R_DrawTranslucentColumn, DC_DIRECT|DC_TRANSMAP)
DEFINE_COLUMN_FUNC(R_DrawTranslatedColumn, DC_DIRECT|DC_COLORMAP)
DEFINE_COLUMN_FUNC(R_DrawColumnShadowed, DC_DIRECT|DC_LIGHTLIST)
DEFINE_COLUMN_FUNC(R_DrawTranslatedTranslucentColumn, DC_DIRECT|DC_COLORMAP|DC_TRANSMAP)
DEFINE_COLUMN_FUNC(R_Draw2sMultiPatchColumn, DC_DIRECT|DC_HOLES)
DEFINE_COLUMN_FUNC(R_Draw2sMultiPatchTranslucentColumn, DC_DIRECT|DC_HOLES|DC_TRANSMAP)
DEFINE_COLUMN_FUNC(R_DrawColumnFlush, DC_BASIC)
DEFINE_COLUMN_FUNC(R_DrawTranslucentColumnFlush, DC_TRANSMAP)
DEFINE_COLUMN_FUNC(R_DrawTranslatedColumnFlush, DC_COLORMAP)
DEFINE_COLUMN_FUNC(R_DrawColumnShadowedFlush, DC_LIGHTLIST)
DEFINE_COLUMN_FUNC(R_DrawTranslatedTranslucentColumnFlush, DC_COLORMAP|DC_TRANSMAP)
DEFINE_COLUMN_FUNC(R_Draw2sMultiPatchColumnFlush, DC_HOLES)
DEFINE_COLUMN_FUNC(R_Draw2sMultiPatchTranslucentColumnFlush, DC_HOLES|DC_TRANSMAP)
//skymyass
//DEFINE_COLUMN_FUNC(R_DrawSkyColumn, DC_SKY)
/** \brief The R_DrawFogColumn function
Fog wall.
+247
View File
@@ -0,0 +1,247 @@
// SONIC ROBO BLAST 2 KART
//-----------------------------------------------------------------------------
// Copyright (C) 2025 by Kart Krew.
// Copyright (C) 2020 by Sonic Team Junior.
// Copyright (C) 2000 by DooM Legacy Team.
// Copyright (C) 1996 by id Software, Inc.
// Copyright (C) 1999 by Chi Hoang, Lee Killough, Jim Flynn, Rand Phares, Ty Halderman
// Copyright (C) 1999-2000 by Jess Haas, Nicolas Kalkhof, Colin Phipps, Florian Schulze
// Copyright (C) Copyright 2005, 2006 by Florian Schulze, Colin Phipps, Neil Stevens, Andrey Budko
// Copyright (C) 2013 by James Haley, Stephen McGranahan, et al.
//
// 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 r_draw_flush.cpp
/// \brief Optimized quad column buffer code. By SoM.
/// \note no includes because this is included as part of r_draw.cpp
template<ColumnFlushType Type>
FUNCINLINE static ATTRINLINE constexpr UINT8
R_GetFlushPixelTranslated(const drawcolumndata_temp_t *t_dc, UINT8 col)
{
if constexpr (Type & (ColumnFlushType::FLUSH_COLORMAP | ColumnFlushType::FLUSH_COLORMAP_TRANS))
{
col = t_dc->translation[col];
}
return col;
}
template<ColumnFlushType Type>
FUNCINLINE static ATTRINLINE constexpr UINT8
R_GetFlushPixelTranslucent(const drawcolumndata_temp_t *t_dc, UINT8 * restrict dest, UINT8 col)
{
col = R_GetFlushPixelTranslated<Type>(t_dc, col);
if constexpr (Type & (ColumnFlushType::FLUSH_TRANS | ColumnFlushType::FLUSH_COLORMAP_TRANS))
{
// haleyjd 09/11/04: use temptranmap here
return *(t_dc->transmap + (col << 8) + (*dest));
}
else
{
return col;
}
}
template<ColumnFlushType Type>
FUNCINLINE static ATTRINLINE constexpr UINT8
R_DrawFlushPixel(const drawcolumndata_temp_t *t_dc, UINT8 * restrict dest, const UINT8 * restrict source)
{
UINT8 col = *source;
return R_GetFlushPixelTranslucent<Type>(t_dc, dest, col);
}
//
// R_FlushWhole
//
// Flushes the entire columns in the buffer, one at a time.
// This is used when a quad flush isn't possible.
//
template<ColumnFlushType Type>
static void R_FlushWhole(void)
{
UINT8 * restrict source;
UINT8 * restrict dest;
INT32 count, yl;
const INT32 stride = vid.width;
drawcolumndata_temp_t *t_dc = &temp_dc;
UINT8 *restrict buf = t_dc->buf;
while (--t_dc->x >= 0)
{
yl = t_dc->yl[t_dc->x];
source = &buf[t_dc->x + (yl << 3)];
dest = R_Address(t_dc->startx + t_dc->x, yl);
count = t_dc->yh[t_dc->x] - yl + 1;
while (--count >= 0)
{
*dest = R_DrawFlushPixel<Type>(t_dc, dest, source);
source += 8;
dest += stride;
}
}
}
//
// R_FlushHT
//
// Flushes the head and tail of columns in the buffer in
// preparation for a quad flush.
//
template<ColumnFlushType Type>
static void R_FlushHT(void)
{
UINT8 * restrict source;
UINT8 * restrict dest;
INT32 count, colnum = 0;
INT32 yl, yh;
const INT32 stride = vid.width;
const drawcolumndata_temp_t *t_dc = &temp_dc;
UINT8 *restrict buf = t_dc->buf;
while (colnum < 8)
{
yl = t_dc->yl[colnum];
yh = t_dc->yh[colnum];
// flush column head
if (yl < t_dc->commontop)
{
source = &buf[colnum + (yl << 3)];
dest = R_Address(t_dc->startx + colnum, yl);
count = t_dc->commontop - yl;
while (--count >= 0)
{
*dest = R_DrawFlushPixel<Type>(t_dc, dest, source);
source += 8;
dest += stride;
}
}
// flush column tail
if (yh > t_dc->commonbot)
{
source = &buf[colnum + ((t_dc->commonbot + 1) << 3)];
dest = R_Address(t_dc->startx + colnum, t_dc->commonbot + 1);
count = yh - t_dc->commonbot;
while (--count >= 0)
{
*dest = R_DrawFlushPixel<Type>(t_dc, dest, source);
source += 8;
dest += stride;
}
}
++colnum;
}
}
// Begin: Quad column flushing functions.
template<ColumnFlushType Type>
static void R_FlushQuad(void)
{
const INT32 stride = vid.width;
const drawcolumndata_temp_t *t_dc = &temp_dc;
INT32 count = t_dc->commonbot - t_dc->commontop + 1;
const UINT8 *restrict buf = t_dc->buf;
if constexpr (Type & ColumnFlushType::FLUSH_OPAQUE)
{
const INT64 *source = reinterpret_cast<const INT64 *>(buf + (t_dc->commontop << 3));
INT64 *dest = reinterpret_cast<INT64 *>(R_Address(t_dc->startx, t_dc->commontop));
const INT32 deststep = stride / 8;
while (--count >= 0)
{
*dest = *source++;
dest += deststep;
}
}
else
{
const UINT8 * restrict source = buf + (t_dc->commontop << 3);
UINT8 * restrict dest = R_Address(t_dc->startx, t_dc->commontop);
while (--count >= 0)
{
dest[0] = R_DrawFlushPixel<Type>(t_dc, &dest[0], &source[0]);
dest[1] = R_DrawFlushPixel<Type>(t_dc, &dest[1], &source[1]);
dest[2] = R_DrawFlushPixel<Type>(t_dc, &dest[2], &source[2]);
dest[3] = R_DrawFlushPixel<Type>(t_dc, &dest[3], &source[3]);
dest[4] = R_DrawFlushPixel<Type>(t_dc, &dest[4], &source[4]);
dest[5] = R_DrawFlushPixel<Type>(t_dc, &dest[5], &source[5]);
dest[6] = R_DrawFlushPixel<Type>(t_dc, &dest[6], &source[6]);
dest[7] = R_DrawFlushPixel<Type>(t_dc, &dest[7], &source[7]);
source += 8;
dest += stride;
}
}
}
// haleyjd 09/12/04: split up R_GetBuffer into various different
// functions to minimize the number of branches and take advantage
// of as much precalculated information as possible.
template<ColumnFlushType Type>
static UINT8 *R_GetBuffer(drawcolumndata_t *dc)
{
drawcolumndata_temp_t *t_dc = &temp_dc;
// haleyjd: reordered predicates
if (t_dc->x == 8 ||
(t_dc->x && (t_dc->type != Type || t_dc->x + t_dc->startx != dc->x)))
R_FlushColumns();
if (!t_dc->x)
{
++t_dc->x;
t_dc->startx = dc->x;
t_dc->yl[0] = t_dc->commontop = dc->yl;
t_dc->yh[0] = t_dc->commonbot = dc->yh;
t_dc->type = Type;
if constexpr (Type & (ColumnFlushType::FLUSH_TRANS | ColumnFlushType::FLUSH_COLORMAP_TRANS))
{
t_dc->transmap = dc->transmap;
}
if constexpr (Type & (ColumnFlushType::FLUSH_COLORMAP | ColumnFlushType::FLUSH_COLORMAP_TRANS))
{
t_dc->translation = dc->translation;
}
R_FlushWholeColumns = R_FlushWhole<Type>;
R_FlushHTColumns = R_FlushHT<Type>;
R_FlushQuadColumn = R_FlushQuad<Type>;
return &t_dc->buf[dc->yl << 3];
}
t_dc->yl[t_dc->x] = dc->yl;
t_dc->yh[t_dc->x] = dc->yh;
if (dc->yl > t_dc->commontop)
t_dc->commontop = dc->yl;
if (dc->yh < t_dc->commonbot)
t_dc->commonbot = dc->yh;
return &t_dc->buf[(dc->yl << 3) + t_dc->x++];
}
#define DEFINE_GETBUF_FUNC(name, flags) \
FUNCINLINE static ATTRINLINE UINT8 *name(drawcolumndata_t *dc) \
{ \
constexpr ColumnFlushType opt = static_cast<ColumnFlushType>(flags); \
return R_GetBuffer<opt>(dc); \
}
DEFINE_GETBUF_FUNC(R_GetBufferOpaque, FLUSH_OPAQUE)
DEFINE_GETBUF_FUNC(R_GetBufferTrans, FLUSH_TRANS)
DEFINE_GETBUF_FUNC(R_GetBufferColormap, FLUSH_COLORMAP)
DEFINE_GETBUF_FUNC(R_GetBufferColormapTrans, FLUSH_COLORMAP_TRANS)
+41 -20
View File
@@ -50,7 +50,8 @@ enum DrawSpanType
};
template<DrawSpanType Type>
static constexpr UINT8 R_GetSpanTranslated(drawspandata_t* ds, UINT8 col)
FUNCINLINE static ATTRINLINE constexpr UINT8
R_GetSpanTranslated(const drawspandata_t* ds, UINT8 col)
{
if constexpr (Type & DrawSpanType::DS_COLORMAP)
{
@@ -63,7 +64,8 @@ static constexpr UINT8 R_GetSpanTranslated(drawspandata_t* ds, UINT8 col)
}
template<DrawSpanType Type>
static constexpr UINT8 R_GetSpanTranslucent(drawspandata_t* ds, UINT8 *dsrc, const UINT8 *colormap, UINT8 col)
FUNCINLINE static ATTRINLINE constexpr UINT8
R_GetSpanTranslucent(const drawspandata_t* ds, UINT8 *dsrc, const UINT8 *colormap, UINT8 col)
{
col = colormap[R_GetSpanTranslated<Type>(ds, col)];
@@ -78,7 +80,8 @@ static constexpr UINT8 R_GetSpanTranslucent(drawspandata_t* ds, UINT8 *dsrc, con
}
template<DrawSpanType Type>
static constexpr UINT8 R_DrawSpanPixel(drawspandata_t* ds, UINT8 *dsrc, const UINT8 *colormap, UINT32 bit, const UINT8 *source)
FUNCINLINE static ATTRINLINE constexpr UINT8
R_DrawSpanPixel(const drawspandata_t* ds, UINT8 *dsrc, const UINT8 *colormap, UINT32 bit, const UINT8 *source)
{
UINT8 col = source[bit];
@@ -157,14 +160,18 @@ static void R_DrawSpanTemplate(drawspandata_t* ds)
{
bit = ((yposition >> ds->nflatyshift) & ds->nflatmask) | (xposition >> ds->nflatxshift);
dest[i] = R_DrawSpanPixel<Type>(ds, &dsrc[i], colormap, bit, source);
if constexpr (Type & DS_RIPPLE)
dest[i] = R_DrawSpanPixel<Type>(ds, &dsrc[i], colormap, bit, source);
else
dest[i] = R_DrawSpanPixel<Type>(ds, &dest[i], colormap, bit, source);
xposition += xstep;
yposition += ystep;
}
dest += 8;
dsrc += 8;
if constexpr (Type & DS_RIPPLE)
dsrc += 8;
count -= 8;
}
@@ -173,10 +180,14 @@ static void R_DrawSpanTemplate(drawspandata_t* ds)
{
bit = ((yposition >> ds->nflatyshift) & ds->nflatmask) | (xposition >> ds->nflatxshift);
*dest = R_DrawSpanPixel<Type>(ds, dsrc, colormap, bit, source);
if constexpr (Type & DS_RIPPLE)
*dest = R_DrawSpanPixel<Type>(ds, dsrc, colormap, bit, source);
else
*dest = R_DrawSpanPixel<Type>(ds, dest, colormap, bit, source);
dest++;
dsrc++;
if constexpr (Type & DS_RIPPLE)
dsrc++;
xposition += xstep;
yposition += ystep;
@@ -243,15 +254,14 @@ static void R_DrawTiltedSpanTemplate(drawspandata_t* ds)
local_for_thread std::vector<INT32> tiltlighting;
iz = ds->szp.z + ds->szp.y*(centery-ds->y) + ds->szp.x*(ds->x1-centerx);
uz = ds->sup.z + ds->sup.y*(centery-ds->y) + ds->sup.x*(ds->x1-centerx);
vz = ds->svp.z + ds->svp.y*(centery-ds->y) + ds->svp.x*(ds->x1-centerx);
// Lighting is simple. It's just linear interpolation from start to end
R_GetTiltedLighting(tiltlighting, ds, iz, width, stride);
uz = ds->sup.z + ds->sup.y*(centery-ds->y) + ds->sup.x*(ds->x1-centerx);
vz = ds->svp.z + ds->svp.y*(centery-ds->y) + ds->svp.x*(ds->x1-centerx);
const UINT8 *source = ds->source;
const UINT8 *colormap = ds->colormap;
const UINT8 * restrict source = ds->source;
const UINT8 * restrict colormap = ds->colormap;
if constexpr (Type & DS_RIPPLE)
{
@@ -313,12 +323,16 @@ static void R_DrawTiltedSpanTemplate(drawspandata_t* ds)
{
bit = (((v + stepv * i) >> nflatyshift) & nflatmask) | ((u + stepu * i) >> nflatxshift);
colormap = ds->planezlight[tiltlighting[x1 + i]] + (ds->colormap - colormaps);
dest[i] = R_DrawSpanPixel<Type>(ds, &dsrc[i], colormap, bit, source);
if constexpr (Type & DS_RIPPLE)
dest[i] = R_DrawSpanPixel<Type>(ds, &dsrc[i], colormap, bit, source);
else
dest[i] = R_DrawSpanPixel<Type>(ds, &dest[i], colormap, bit, source);
}
ds->x1 += SPANSIZE;
dest += SPANSIZE;
dsrc += SPANSIZE;
if constexpr (Type & DS_RIPPLE)
dsrc += SPANSIZE;
startu = endu;
startv = endv;
width -= SPANSIZE;
@@ -332,7 +346,10 @@ static void R_DrawTiltedSpanTemplate(drawspandata_t* ds)
v = (INT64)(startv);
bit = ((v >> nflatyshift) & nflatmask) | (u >> nflatxshift);
colormap = ds->planezlight[tiltlighting[ds->x1]] + (ds->colormap - colormaps);
*dest = R_DrawSpanPixel<Type>(ds, dsrc, colormap, bit, source);
if constexpr (Type & DS_RIPPLE)
*dest = R_DrawSpanPixel<Type>(ds, dsrc, colormap, bit, source);
else
*dest = R_DrawSpanPixel<Type>(ds, dest, colormap, bit, source);
ds->x1++;
}
else
@@ -355,10 +372,14 @@ static void R_DrawTiltedSpanTemplate(drawspandata_t* ds)
{
bit = ((v >> ds->nflatyshift) & ds->nflatmask) | (u >> ds->nflatxshift);
colormap = ds->planezlight[tiltlighting[ds->x1]] + (ds->colormap - colormaps);
*dest = R_DrawSpanPixel<Type>(ds, dsrc, colormap, bit, source);
if constexpr (Type & DS_RIPPLE)
*dest = R_DrawSpanPixel<Type>(ds, dsrc, colormap, bit, source);
else
*dest = R_DrawSpanPixel<Type>(ds, dest, colormap, bit, source);
dest++;
if constexpr (Type & DS_RIPPLE)
dsrc++;
ds->x1++;
dsrc++;
u += stepu;
v += stepv;
}
@@ -389,11 +410,11 @@ DEFINE_SPAN_COMBO(R_DrawTranslucentWaterSpan, DS_TRANSMAP|DS_RIPPLE)
*/
void R_DrawFogSpan(drawspandata_t* ds)
{
INT32 count = ds->x2 - ds->x1 + 1;
const UINT8 * restrict colormap = ds->colormap;
UINT8 * restrict dest = R_Address(ds->x1, ds->y);
intptr_t count = ds->x2 - ds->x1 + 1;
while (count >= 4)
{
dest[0] = colormap[dest[0]];
@@ -401,7 +422,7 @@ void R_DrawFogSpan(drawspandata_t* ds)
dest[2] = colormap[dest[2]];
dest[3] = colormap[dest[3]];
dest += 4;
dest += 4;
count -= 4;
}
+7 -3
View File
@@ -1023,8 +1023,6 @@ void R_Init(void)
//I_OutputMsg("\nR_InitData");
R_InitData();
//I_OutputMsg("\nR_InitViewBorder");
R_InitViewBorder();
R_SetViewSize(); // setsizeneeded is set true
// this is now done by SCR_Recalc() at the first mode set
@@ -1404,9 +1402,12 @@ void R_RenderPlayerView(player_t *player)
R_ClearPlanes();
R_ClearSprites();
R_SetColumnContext(COLUMNCONTEXT_FLUSH);
R_RenderViewpoint(&masks[nummasks - 1], false);
R_ClipSprites(drawsegs, NULL);
R_ResetColumnBuffer();
R_SetColumnContext(COLUMNCONTEXT_DIRECT);
R_DrawSkyPlanes(); // draw the fucker again to prevent some artifacts
R_DrawPlanes();
R_DrawMasked(masks, nummasks);
@@ -1441,6 +1442,7 @@ void R_RenderPlayerView(player_t *player)
// check for new console commands.
NetUpdate();
R_SetColumnContext(COLUMNCONTEXT_FLUSH);
ps_numbspcalls.value.i = ps_numpolyobjects.value.i = ps_numdrawnodes.value.i = 0;
PS_START_TIMING(ps_bsptime);
R_RenderViewpoint(&masks[nummasks - 1], true);
@@ -1448,6 +1450,7 @@ void R_RenderPlayerView(player_t *player)
PS_START_TIMING(ps_sw_spritecliptime);
R_ClipSprites(drawsegs, NULL);
PS_STOP_TIMING(ps_sw_spritecliptime);
R_ResetColumnBuffer();
ps_numsprites.value.i = numvisiblesprites;
@@ -1484,12 +1487,14 @@ void R_RenderPlayerView(player_t *player)
R_RenderViewpoint(&masks[nummasks - 1], true);
R_ClipSprites(ds_p - (masks[nummasks - 1].drawsegs[1] - masks[nummasks - 1].drawsegs[0]), portal);
R_ResetColumnBuffer();
Portal_Remove(portal);
}
}
PS_STOP_TIMING(ps_sw_portaltime);
R_SetColumnContext(COLUMNCONTEXT_DIRECT);
PS_START_TIMING(ps_sw_planetime);
if (!skybox)
R_DrawSkyPlanes();
@@ -1500,7 +1505,6 @@ void R_RenderPlayerView(player_t *player)
PS_START_TIMING(ps_sw_maskedtime);
R_DrawMasked(masks, nummasks);
PS_STOP_TIMING(ps_sw_maskedtime);
free(masks);
// Check for new console commands.
+1 -1
View File
@@ -97,7 +97,7 @@ FUNCINLINE static ATTRINLINE PUREFUNC INT32 R_PointOnSide(fixed_t x, fixed_t y,
// Try to quickly decide by looking at sign bits.
// also use a mask to avoid branch prediction
INT32 mask = (node->dy ^ node->dx ^ x ^ y) >> 31;
INT32 mask = (((node->dy ^ node->dx ^ x ^ y) < 0) ? -1 : 0);
return (mask & ((node->dy ^ x) < 0)) | // (left is negative)
(~mask & (FixedMul(y, node->dx>>FRACBITS) >= FixedMul(node->dy>>FRACBITS, x)));
}
+47 -25
View File
@@ -19,6 +19,7 @@
#include "r_skins.h"
#include "z_zone.h"
#include "w_wad.h"
#include <vector>
#ifdef HWRENDER
#include "hardware/hw_glob.h"
@@ -37,7 +38,7 @@ static void R_ParseSpriteInfoFrame(spriteinfo_t *info)
UINT8 frameFrame = 0xFF;
INT16 frameXPivot = 0;
INT16 frameYPivot = 0;
rotaxis_t frameRotAxis = 0;
rotaxis_t frameRotAxis = ROTAXIS_X;
// Sprite identifier
sprinfoToken = M_GetToken(NULL);
@@ -158,14 +159,14 @@ static void R_ParseSpriteInfo(boolean spr2)
I_Error("Error parsing SPRTINFO lump: Unknown sprite name \"%s\"", newSpriteName);
if (!memcmp(newSpriteName,sprnames[i],4))
{
sprnum = i;
sprnum = static_cast<spritenum_t>(i);
break;
}
}
}
// allocate a spriteinfo
info = Z_Calloc(sizeof(spriteinfo_t), PU_STATIC, NULL);
info = static_cast<spriteinfo_t*>(Z_Calloc(sizeof(spriteinfo_t), PU_STATIC, NULL));
info->available = true;
// Left Curly Brace
@@ -329,7 +330,7 @@ void R_LoadSpriteInfoLumps(UINT16 wadnum, UINT16 numlumps)
patch_t *Patch_Create(softwarepatch_t *source, size_t srcsize, void *dest)
{
patch_t *patch = (dest == NULL) ? Z_Calloc(sizeof(patch_t), PU_PATCH, NULL) : (patch_t *)(dest);
patch_t *patch = static_cast<patch_t*>((dest == NULL) ? Z_Calloc(sizeof(patch_t), PU_PATCH, NULL) : dest);
if (source)
{
@@ -341,7 +342,7 @@ patch_t *Patch_Create(softwarepatch_t *source, size_t srcsize, void *dest)
patch->height = SHORT(source->height);
patch->leftoffset = SHORT(source->leftoffset);
patch->topoffset = SHORT(source->topoffset);
patch->columnofs = Z_Calloc(size, PU_PATCH_DATA, NULL);
patch->columnofs = static_cast<INT32*>(Z_Calloc(size, PU_PATCH_DATA, NULL));
for (col = 0; col < source->width; col++)
{
@@ -357,7 +358,7 @@ patch_t *Patch_Create(softwarepatch_t *source, size_t srcsize, void *dest)
if (colsize <= 0)
I_Error("Patch_Create: no column data!");
patch->columns = Z_Calloc(colsize, PU_PATCH_DATA, NULL);
patch->columns = static_cast<UINT8*>(Z_Calloc(colsize, PU_PATCH_DATA, NULL));
M_Memcpy(patch->columns, ((UINT8 *)source + LONG(source->columnofs[0])), colsize);
}
@@ -429,8 +430,8 @@ void *Patch_AllocateHardwarePatch(patch_t *patch)
{
if (!patch->hardware)
{
GLPatch_t *glPatch = Z_Calloc(sizeof(GLPatch_t), PU_HWRPATCHINFO, &patch->hardware);
glPatch->mipmap = Z_Calloc(sizeof(GLMipmap_t), PU_HWRPATCHINFO, &glPatch->mipmap);
GLPatch_t *glPatch = static_cast<GLPatch_t*>(Z_Calloc(sizeof(GLPatch_t), PU_HWRPATCHINFO, &patch->hardware));
glPatch->mipmap = static_cast<GLMipmap_t*>(Z_Calloc(sizeof(GLMipmap_t), PU_HWRPATCHINFO, &glPatch->mipmap));
}
return (void *)(patch->hardware);
}
@@ -448,7 +449,8 @@ void *Patch_CreateGL(patch_t *patch)
}
#endif // HWRENDER
static UINT8 *imgbuf = NULL;
// 1 MB should be enough for most cases
static std::vector<UINT8> imgbuf(1024 * 1024);
//
// R_MaskedFlatToPatch
@@ -458,17 +460,27 @@ static UINT8 *imgbuf = NULL;
void *R_PixelsToPatch(UINT8 *raw, INT16 width, INT16 height, INT16 leftoffset, INT16 topoffset, size_t *destsize)
{
INT16 x, y;
UINT8 *img;
UINT8 *img, *imgptr;
UINT8 *colpointers, *startofspan;
size_t size = 0;
if (!raw)
return NULL;
if (!imgbuf)
imgbuf = Z_Malloc(1<<26, PU_STATIC, NULL);
// Allocate a staging buffer with the maximum size needed for a patch of the same size as the input.
UINT8 *imgptr = imgbuf;
// round up to nearest multiple of 254-pixel posts, plus 1 more 254-pixel post for paranoia reasons
size_t maxcolumnsize = (2 + (height - 1) / 256) * 256;
// the patch header, and width columns of the max column size
size_t maxoutsize = maxcolumnsize * width + (8 + 4 * width);
// so, a 512x512 flat should maximally need 393,760 (384.53 KiB) bytes.
// quite a bit smaller than 64 megabytes, and much less annoying to the windows debug allocator!
while (imgbuf.size() < maxoutsize)
{
imgbuf.resize(imgbuf.size() * 2);
}
imgptr = imgbuf.data();
// Write image size and offset
WRITEINT16(imgptr, width);
@@ -488,7 +500,7 @@ void *R_PixelsToPatch(UINT8 *raw, INT16 width, INT16 height, INT16 leftoffset, I
startofspan = NULL;
// Write column pointer
WRITEINT32(colpointers, imgptr - imgbuf);
WRITEINT32(colpointers, imgptr - imgbuf.data());
// Write pixels
for (y = 0; y < height; y++)
@@ -557,9 +569,9 @@ void *R_PixelsToPatch(UINT8 *raw, INT16 width, INT16 height, INT16 leftoffset, I
WRITEUINT8(imgptr, 0xFF);
}
size = imgptr-imgbuf;
img = Z_Malloc(size, PU_STATIC, NULL);
memcpy(img, imgbuf, size);
size = imgptr-imgbuf.data();
img = static_cast<UINT8*>(Z_Malloc(size, PU_STATIC, NULL));
memcpy(img, imgbuf.data(), size);
if (destsize != NULL)
*destsize = size;
@@ -582,17 +594,27 @@ void *R_PixelsToPatch(UINT8 *raw, INT16 width, INT16 height, INT16 leftoffset, I
void *R_MaskedFlatToPatch(UINT16 *raw, INT16 width, INT16 height, INT16 leftoffset, INT16 topoffset, size_t *destsize)
{
INT16 x, y;
UINT8 *img;
UINT8 *img, *imgptr;
UINT8 *colpointers, *startofspan;
size_t size = 0;
if (!raw)
return NULL;
if (!imgbuf)
imgbuf = Z_Malloc(1<<26, PU_STATIC, NULL);
// Allocate a staging buffer with the maximum size needed for a patch of the same size as the input.
UINT8 *imgptr = imgbuf;
// round up to nearest multiple of 254-pixel posts, plus 1 more 254-pixel post for paranoia reasons
size_t maxcolumnsize = (2 + (height - 1) / 256) * 256;
// the patch header, and width columns of the max column size
size_t maxoutsize = maxcolumnsize * width + (8 + 4 * width);
// so, a 512x512 flat should maximally need 393,760 (384.53 KiB) bytes.
// quite a bit smaller than 64 megabytes, and much less annoying to the windows debug allocator!
while (imgbuf.size() < maxoutsize)
{
imgbuf.resize(imgbuf.size() * 2);
}
imgptr = imgbuf.data();
// Write image size and offset
WRITEINT16(imgptr, width);
@@ -612,7 +634,7 @@ void *R_MaskedFlatToPatch(UINT16 *raw, INT16 width, INT16 height, INT16 leftoffs
startofspan = NULL;
// Write column pointer
WRITEINT32(colpointers, imgptr - imgbuf);
WRITEINT32(colpointers, imgptr - imgbuf.data());
// Write pixels
for (y = 0; y < height; y++)
@@ -682,9 +704,9 @@ void *R_MaskedFlatToPatch(UINT16 *raw, INT16 width, INT16 height, INT16 leftoffs
WRITEUINT8(imgptr, 0xFF);
}
size = imgptr-imgbuf;
img = Z_Malloc(size, PU_STATIC, NULL);
memcpy(img, imgbuf, size);
size = imgptr-imgbuf.data();
img = static_cast<UINT8*>(Z_Malloc(size, PU_STATIC, NULL));
memcpy(img, imgbuf.data(), size);
if (destsize != NULL)
*destsize = size;
+8
View File
@@ -14,6 +14,10 @@
#ifndef __R_PATCH__
#define __R_PATCH__
#ifdef __cplusplus
extern "C" {
#endif
#include "r_defs.h"
// Structs
@@ -63,4 +67,8 @@ void *R_PixelsToPatch(UINT8 *raw, INT16 width, INT16 height, INT16 leftoffset, I
UINT16 R_GetPatchPixel(patch_t *patch, INT32 x, INT32 y, boolean flip);
void R_PatchToPixels(patch_t *patch, UINT8 *dst); // Important: dst must have enough space for patch->width*patch->height pixels!
#ifdef __cplusplus
} // extern "C"
#endif
#endif // __R_PATCH__
@@ -15,6 +15,7 @@
#include "r_patchrotation.h"
#include "z_zone.h"
#include "w_wad.h"
#include <vector>
#ifdef ROTSPRITE
//
@@ -89,14 +90,14 @@ patch_t *Patch_GetRotatedSprite(spriteframe_t *sprite, size_t frame, size_t spri
RotatedPatch_DoRotation(rotsprite, patch, rotationangle, xpivot, ypivot, flip);
}
return rotsprite->patches[idx];
return static_cast<patch_t*>(rotsprite->patches[idx]);
}
rotsprite_t *RotatedPatch_Create(INT32 numangles)
{
rotsprite_t *rotsprite = Z_Calloc(sizeof(rotsprite_t), PU_STATIC, NULL);
rotsprite_t *rotsprite = static_cast<rotsprite_t*>(Z_Calloc(sizeof(rotsprite_t), PU_STATIC, NULL));
rotsprite->angles = numangles;
rotsprite->patches = Z_Calloc(rotsprite->angles * 2 * sizeof(void *), PU_STATIC, NULL);
rotsprite->patches = static_cast<void**>(Z_Calloc(rotsprite->angles * 2 * sizeof(void *), PU_STATIC, NULL));
return rotsprite;
}
@@ -118,30 +119,8 @@ static void RotatedPatch_CalculateDimensions(
h1 = FixedInt(FixedCeil(h1 + (FRACUNIT/2)));
h2 = FixedInt(FixedCeil(h2 + (FRACUNIT/2)));
*newwidth = max(width, max(w1, w2));
*newheight = max(height, max(h1, h2));
}
static void RotatedPatch_AllocImgBuf(UINT16 **buf, size_t size, size_t *capacity)
{
if (!*buf)
{
*buf = Z_Malloc(*capacity, PU_STATIC, NULL);
}
size_t allocsize = size * sizeof(UINT16);
// make sure our buffer always fits with what we need
if (allocsize > *capacity)
{
while (*capacity < allocsize)
*capacity *= 2;
Z_Free(*buf);
*buf = Z_Malloc(*capacity, PU_STATIC, NULL);
}
//CONS_Printf("RotatedPatch_AllocBuf: Allocated %.2f KB\n", *capacity / 1024.0);
*newwidth = std::max(width, std::max(w1, w2));
*newheight = std::max(height, std::max(h1, h2));
}
void RotatedPatch_DoRotation(rotsprite_t *rotsprite, patch_t *patch, INT32 angle, INT32 xpivot, INT32 ypivot, boolean flip)
@@ -149,10 +128,10 @@ void RotatedPatch_DoRotation(rotsprite_t *rotsprite, patch_t *patch, INT32 angle
UINT32 i;
patch_t *rotated;
static UINT16 *rawdst = NULL, *rawconv = NULL;
static std::vector<UINT16> rawdst(1024 * 1024), rawconv(1024 * 1024); // 1 MB should be enough for most cases
UINT16 *rawout;
size_t size;
static size_t dst_capacity = (1024 * 1024), conv_capacity = (1024 * 1024); // 1 MB should be enough for most cases
INT32 bflip = (flip != 0x00);
INT32 width = patch->width;
@@ -206,7 +185,10 @@ void RotatedPatch_DoRotation(rotsprite_t *rotsprite, patch_t *patch, INT32 angle
if (!size)
size = (width * height);
RotatedPatch_AllocImgBuf(&rawdst, size, &dst_capacity);
while (rawdst.size() < size)
{
rawdst.resize(rawdst.size() * 2);
}
for (i = 0; i < size; i++)
rawdst[i] = 0xFF00;
@@ -250,11 +232,11 @@ void RotatedPatch_DoRotation(rotsprite_t *rotsprite, patch_t *patch, INT32 angle
size = (width * height);
RotatedPatch_AllocImgBuf(&rawconv, size, &conv_capacity);
memset(rawconv, 0, conv_capacity * sizeof(UINT16));
rawconv.resize(size);
memset(rawconv.data(), 0, size * sizeof(UINT16));
src = &rawdst[(miny * newwidth) + minx];
dest = rawconv;
dest = rawconv.data();
dy = height;
while (dy--)
@@ -267,14 +249,14 @@ void RotatedPatch_DoRotation(rotsprite_t *rotsprite, patch_t *patch, INT32 angle
ox -= minx;
oy -= miny;
rawout = rawconv;
rawout = rawconv.data();
}
else
{
width = newwidth;
height = newheight;
rawout = rawdst;
rawout = rawdst.data();
}
// make patch
+10 -13
View File
@@ -716,13 +716,10 @@ void R_DrawPlanes(void)
visplane_t *pl;
INT32 i;
drawspandata_t ds = {};
#ifdef HAVE_THREADS
srb2::ThreadPool::Sema tp_sema;
#endif
R_UpdatePlaneRipple(&ds);
#ifdef HAVE_THREADS
srb2::ThreadPool::Sema tp_sema;
srb2::g_main_threadpool->begin_sema();
#endif
for (i = 0; i < MAXVISPLANES; i++, pl++)
@@ -749,6 +746,13 @@ void R_DrawSkyPlanes(void)
visplane_t *pl;
INT32 i;
// If we're not supposed to draw the sky (e.g. for skyboxes), don't do anything!
// This probably utterly ruins sky rendering for FOFs and polyobjects, unfortunately
if (!newview->sky)
{
return;
}
#ifdef HAVE_THREADS
srb2::ThreadPool::Sema tp_sema;
srb2::g_main_threadpool->begin_sema();
@@ -777,17 +781,10 @@ static void R_DrawSkyPlane(visplane_t *pl, void(*colfunc2)(drawcolumndata_t*), b
if (!(pl->minx <= pl->maxx))
return;
// If we're not supposed to draw the sky (e.g. for skyboxes), don't do anything!
// This probably utterly ruins sky rendering for FOFs and polyobjects, unfortunately
if (!newview->sky)
{
return;
}
drawcolumndata_t dc = {};
const INT32 texture = texturetranslation[skytexture];
// Reset column drawer function (note: couldn't we just call walldrawerfunc directly?)
// Reset column drawer function (note: couldn't we just call colfuncs[BASEDRAWFUNC] directly?)
// (that is, unless we'll need to switch drawers in future for some reason)
R_SetColumnFunc(BASEDRAWFUNC);
@@ -1159,7 +1156,7 @@ void R_DrawSinglePlane(drawspandata_t* ds, visplane_t *pl, boolean allow_paralle
offset = (scry*vid.width) + scrx;
// No idea if this works
VID_BlitLinearScreen(renderscreen + offset,
VID_BlitLinearScreen(vid.screens[0] + offset,
vid.screens[1] + (top*vid.width), // intentionally not +offset
viewwidth, bottom-top,
vid.width, vid.width);
+5 -8
View File
@@ -26,7 +26,6 @@
#include "p_local.h" // Camera...
#include "p_setup.h"
#include "p_slopes.h"
#include "console.h" // con_clipviewtop
#include "screen.h"
#include "core/memory.h"
@@ -628,8 +627,6 @@ void R_RenderThickSideRange(drawseg_t *drawseg, INT32 x1, INT32 x2, ffloor_t *pf
sector_t tempsec;
INT32 templight;
INT32 i, p;
fixed_t bottombounds = viewheight << FRACBITS;
fixed_t topbounds = (con_clipviewtop - 1) << FRACBITS;
fixed_t offsetvalue = 0;
lightlist_t *light;
r_lightlist_t *rlight;
@@ -936,7 +933,7 @@ void R_RenderThickSideRange(drawseg_t *drawseg, INT32 x1, INT32 x2, ffloor_t *pf
bottom_frac += bottom_step;
// SoM: If column is out of range, why bother with it??
if (windowbottom < topbounds || windowtop > bottombounds)
if (windowbottom < 0 || windowtop > (viewheight << FRACBITS))
{
if (dc->numlights)
{
@@ -2239,7 +2236,7 @@ void R_StoreWallRange(INT32 start, INT32 stop)
lowcutslope = std::max(worldbottomslope, worldlowslope) + viewz;
highcutslope = std::min(worldtopslope, worldhighslope) + viewz;
auto check_fof_offscreen = [&](INT32 bottom, INT32 bottomslope, INT32 top, INT32 topslope)
auto check_fof_offscreen = [&](ffloor_t* rover, INT32 bottom, INT32 bottomslope, INT32 top, INT32 topslope)
{
return ((P_GetFFloorTopZAt (rover, segleft .x, segleft .y) <= bottom + viewz
&& P_GetFFloorTopZAt (rover, segright.x, segright.y) <= bottomslope + viewz)
@@ -2379,7 +2376,7 @@ void R_StoreWallRange(INT32 start, INT32 stop)
continue;
// Oy vey.
if (check_fof_offscreen(worldbottom, worldbottomslope, worldtop, worldtopslope))
if (check_fof_offscreen(rover, worldbottom, worldbottomslope, worldtop, worldtopslope))
continue;
ds_p->thicksides[i] = rover;
@@ -2397,10 +2394,10 @@ void R_StoreWallRange(INT32 start, INT32 stop)
continue;
// Oy vey.
if (check_fof_offscreen(worldbottom, worldbottomslope, worldtop, worldtopslope))
if (check_fof_offscreen(rover, worldbottom, worldbottomslope, worldtop, worldtopslope))
continue;
if (check_fof_offscreen(worldlow, worldlowslope, worldhigh, worldhighslope))
if (check_fof_offscreen(rover, worldlow, worldlowslope, worldhigh, worldhighslope))
continue;
ds_p->thicksides[i] = rover;
+12 -7
View File
@@ -2518,8 +2518,6 @@ void R_InitDrawNodes(void)
// R_DrawSprite
//
//Fab : 26-04-98:
// NOTE : uses con_clipviewtop, so that when console is on,
// don't draw the part of sprites hidden under the console
static void R_DrawSprite(vissprite_t *spr)
{
mfloorclip = spr->clipbot;
@@ -2803,6 +2801,11 @@ void R_ClipSprites(drawseg_t* dsstart, portal_t* portal)
drawseg_t* ds;
INT32 i;
if (visspritecount - clippedvissprites <= 0)
{
return;
}
// e6y
// Reducing of cache misses in the following R_DrawSprite()
// Makes sense for scenes with huge amount of drawsegs.
@@ -2812,13 +2815,9 @@ void R_ClipSprites(drawseg_t* dsstart, portal_t* portal)
drawsegs_xranges[i].count = 0;
}
if (visspritecount - clippedvissprites <= 0)
{
return;
}
if (drawsegs_xrange_size < maxdrawsegs)
{
// haleyjd: fix reallocation to track 2x size
drawsegs_xrange_size = 2 * maxdrawsegs;
for (i = 0; i < DS_RANGES_COUNT; i++)
@@ -2858,6 +2857,9 @@ void R_ClipSprites(drawseg_t* dsstart, portal_t* portal)
}
}
// haleyjd: terminate with a nullptr user for faster loop - adds ~3 FPS
drawsegs_xranges[0].items[drawsegs_xranges[0].count].user = nullptr;
for (; clippedvissprites < visspritecount; clippedvissprites++)
{
vissprite_t *spr = R_GetVisSprite(clippedvissprites);
@@ -3062,6 +3064,9 @@ void R_DrawMasked(maskcount_t* masks, INT32 nummasks)
heads = static_cast<drawnode_t*>(calloc(nummasks, sizeof(drawnode_t)));
if (!heads)
I_Error("R_DrawMasked: No more free memory\n");
for (i = 0; i < nummasks; i++)
{
heads[i].next = heads[i].prev = &heads[i];
+35 -15
View File
@@ -80,11 +80,7 @@ consvar_t cv_accuratefps = {"fpssampling", "1", CV_SAVE, accuratefps_cons_t, NUL
// SCREEN VARIABLES
// =========================================================================
UINT8 *scr_borderpatch; // flat used to fill the reduced view borders set at ST_Init()
// =========================================================================
static void SCR_SetDrawFuncs(void)
static void SCR_SetDrawFuncs(enum columncontext_e _columncontext)
{
//
// setup the right draw routines
@@ -103,13 +99,27 @@ static void SCR_SetDrawFuncs(void)
spanfuncs[SPANDRAWFUNC_FOG] = R_DrawFogSpan;
spanfuncs[SPANDRAWFUNC_TILTEDFOG] = R_DrawFogSpan_Tilted;
colfuncs[BASEDRAWFUNC] = R_DrawColumn;
colfuncs[COLDRAWFUNC_FUZZY] = R_DrawTranslucentColumn;
colfuncs[COLDRAWFUNC_TRANS] = R_DrawTranslatedColumn;
colfuncs[COLDRAWFUNC_SHADOWED] = R_DrawColumnShadowed;
colfuncs[COLDRAWFUNC_TRANSTRANS] = R_DrawTranslatedTranslucentColumn;
colfuncs[COLDRAWFUNC_TWOSMULTIPATCH] = R_Draw2sMultiPatchColumn;
colfuncs[COLDRAWFUNC_TWOSMULTIPATCHTRANS] = R_Draw2sMultiPatchTranslucentColumn;
if (_columncontext == COLUMNCONTEXT_FLUSH)
{
colfuncs[BASEDRAWFUNC] = R_DrawColumnFlush;
colfuncs[COLDRAWFUNC_FUZZY] = R_DrawTranslucentColumnFlush;
colfuncs[COLDRAWFUNC_TRANS] = R_DrawTranslatedColumnFlush;
colfuncs[COLDRAWFUNC_SHADOWED] = R_DrawColumnShadowedFlush;
colfuncs[COLDRAWFUNC_TRANSTRANS] = R_DrawTranslatedTranslucentColumnFlush;
colfuncs[COLDRAWFUNC_TWOSMULTIPATCH] = R_Draw2sMultiPatchColumnFlush;
colfuncs[COLDRAWFUNC_TWOSMULTIPATCHTRANS] = R_Draw2sMultiPatchTranslucentColumnFlush;
}
else
{
colfuncs[BASEDRAWFUNC] = R_DrawColumn;
colfuncs[COLDRAWFUNC_FUZZY] = R_DrawTranslucentColumn;
colfuncs[COLDRAWFUNC_TRANS] = R_DrawTranslatedColumn;
colfuncs[COLDRAWFUNC_SHADOWED] = R_DrawColumnShadowed;
colfuncs[COLDRAWFUNC_TRANSTRANS] = R_DrawTranslatedTranslucentColumn;
colfuncs[COLDRAWFUNC_TWOSMULTIPATCH] = R_Draw2sMultiPatchColumn;
colfuncs[COLDRAWFUNC_TWOSMULTIPATCHTRANS] = R_Draw2sMultiPatchTranslucentColumn;
}
colfuncs[COLDRAWFUNC_FOG] = R_DrawFogColumn;
R_SetColumnFunc(BASEDRAWFUNC);
@@ -131,12 +141,23 @@ void SCR_SetMode(void)
V_SetPalette(0);
SCR_SetDrawFuncs();
SCR_SetDrawFuncs(COLUMNCONTEXT_DIRECT);
// set the apprpriate drawer for the sky (tall or INT16)
setmodeneeded = 0;
}
// used to switch between column buffering and drawing them directly to screen
// our sky "plane" drawer cannot handle the buffer system due to multithreading
// (that would require alot of extra complexity for smth with massive diminishing results)
// Our masked drawing step draws things in a very particular order, which results in alot of flushing to screen
// effectively adding massive overhead due to excessive flushing, so we draw our masked thing directly to screen instead
void R_SetColumnContext(enum columncontext_e _columncontext)
{
columncontext = _columncontext;
SCR_SetDrawFuncs(_columncontext); // set our column drawers
}
void R_SetColumnFunc(size_t id)
{
I_Assert(id < COLDRAWFUNC_MAX);
@@ -298,7 +319,6 @@ void SCR_SetDefaultMode(void)
// Change fullscreen on/off according to cv_fullscreen
void SCR_ChangeFullscreen(void)
{
#ifdef DIRECTFULLSCREEN
I_SetBorderlessWindow(); // Running this here so we can have borderless window at startup
// allow_fullscreen is set by VID_PrepareModeList
@@ -311,8 +331,8 @@ void SCR_ChangeFullscreen(void)
VID_PrepareModeList();
setmodeneeded = VID_GetModeForSize(vid.width, vid.height) + 1;
}
return;
#endif
}
boolean SCR_IsAspectCorrect(INT32 width, INT32 height)
+1 -2
View File
@@ -84,8 +84,6 @@ enum
extern viddef_t vid;
extern INT32 setmodeneeded; // mode number to set if needed, or 0
extern UINT8 *scr_borderpatch; // patch used to fill the view borders
extern consvar_t cv_scr_width, cv_scr_height, cv_renderview, cv_frameskip, cv_fullscreen, cv_vhseffect, cv_shittyscreen;
extern consvar_t cv_parallelsoftware;
extern consvar_t cv_paralleldrawmasked;
@@ -96,6 +94,7 @@ extern consvar_t cv_vidwait;
extern consvar_t cv_votebgscaling;
//void R_SetColumnContext(enum columncontext_e _columncontext); // declared in r_draw!
void R_SetColumnFunc(size_t id);
void R_SetSpanFunc(size_t id);
boolean R_CheckColumnFunc(size_t id);
+2 -2
View File
@@ -45,7 +45,7 @@ MTL=midl.exe
# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
# ADD CPP /nologo /G5 /W3 /GX /Zi /Ot /Og /Oi /Op /Oy /Ob1 /I "..\..\libs\libpng-src" /I "..\..\libs\zlib" /D "NDEBUG" /D "SDLMAIN" /D "NO_STDIO_REDIRECT" /D "USE_WGL_SWAP" /D "DIRECTFULLSCREEN" /D "HAVE_SDL" /D "HWRENDER" /D "HAVE_FILTER" /D "HAVE_MIXER" /D "USEASM" /D "HAVE_PNG" /FR /FD /GF /c
# ADD CPP /nologo /G5 /W3 /GX /Zi /Ot /Og /Oi /Op /Oy /Ob1 /I "..\..\libs\libpng-src" /I "..\..\libs\zlib" /D "NDEBUG" /D "SDLMAIN" /D "NO_STDIO_REDIRECT" /D "USE_WGL_SWAP" /D "HAVE_SDL" /D "HWRENDER" /D "HAVE_FILTER" /D "HAVE_MIXER" /D "USEASM" /D "HAVE_PNG" /FR /FD /GF /c
# ADD BASE RSC /l 0x409 /d "NDEBUG"
# ADD RSC /l 0x409 /d "NDEBUG"
# SUBTRACT RSC /x
@@ -72,7 +72,7 @@ LINK32=link.exe
# PROP Target_Dir ""
MTL=midl.exe
# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
# ADD CPP /nologo /G6 /W4 /WX /Gm /GX /ZI /Od /Op /I "..\..\libs\libpng-src" /I "..\..\libs\zlib" /D "_DEBUG" /D "USE_WGL_SWAP" /D "DIRECTFULLSCREEN" /D "HAVE_SDL" /D "HWRENDER" /D "HAVE_FILTER" /D "HAVE_MIXER" /D "USEASM" /D "HAVE_PNG" /FR /FD /GZ /c
# ADD CPP /nologo /G6 /W4 /WX /Gm /GX /ZI /Od /Op /I "..\..\libs\libpng-src" /I "..\..\libs\zlib" /D "_DEBUG" /D "USE_WGL_SWAP" /D "HAVE_SDL" /D "HWRENDER" /D "HAVE_FILTER" /D "HAVE_MIXER" /D "USEASM" /D "HAVE_PNG" /FR /FD /GZ /c
# SUBTRACT CPP /YX
# ADD BASE RSC /l 0x409 /d "_DEBUG"
# ADD RSC /l 0x409 /d "_DEBUG"
+2 -2
View File
@@ -6,9 +6,9 @@
<ItemDefinitionGroup>
<ClCompile>
<!-- x86/x64 defines: has specific libraries that ARM does not -->
<PreprocessorDefinitions Condition="'$(Platform)' == 'Win32' OR '$(Platform)' == 'x64'">HAVE_ZLIB;HAVE_LIBGME;USE_WGL_SWAP;DIRECTFULLSCREEN;HAVE_SDL;HWRENDER;HAVE_FILTER;HAVE_MIXER;SDLMAIN;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<PreprocessorDefinitions Condition="'$(Platform)' == 'Win32' OR '$(Platform)' == 'x64'">HAVE_ZLIB;HAVE_LIBGME;USE_WGL_SWAP;HAVE_SDL;HWRENDER;HAVE_FILTER;HAVE_MIXER;SDLMAIN;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<!-- ARM defines -->
<PreprocessorDefinitions Condition="'$(Platform)' != 'Win32' AND '$(Platform)' != 'x64'">USE_WGL_SWAP;DIRECTFULLSCREEN;HAVE_SDL;HWRENDER;HAVE_FILTER;HAVE_MIXER;SDLMAIN;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<PreprocessorDefinitions Condition="'$(Platform)' != 'Win32' AND '$(Platform)' != 'x64'">USE_WGL_SWAP;HAVE_SDL;HWRENDER;HAVE_FILTER;HAVE_MIXER;SDLMAIN;%(PreprocessorDefinitions)</PreprocessorDefinitions>
</ClCompile>
</ItemDefinitionGroup>
<ItemGroup />
-4
View File
@@ -219,10 +219,6 @@ void ST_UnloadGraphics(void)
void ST_LoadGraphics(void)
{
// SRB2 border patch
//st_borderpatchnum = W_GetNumForName("GFZFLR01");
//scr_borderpatch = W_CacheLumpNum(st_borderpatchnum, PU_HUDGFX);
// the original Doom uses 'STF' as base name for all face graphics
// Graue 04-08-2004: face/name graphics are now indexed by skins
// but load them in R_AddSkins, that gets called
+15 -1
View File
@@ -3094,6 +3094,9 @@ INT32 V_SubStringWidth(const char *string, INT32 length, INT32 option)
INT32 spacewidth = 4, charwidth = 0;
ssize_t i;
if (!string)
return 0;
if (length < 0)
length = strlen(string);
@@ -3136,6 +3139,9 @@ INT32 V_SmallSubStringWidth(const char *string, INT32 length, INT32 option)
INT32 spacewidth = 2, charwidth = 0;
ssize_t i;
if (!string)
return 0;
if (length < 0)
length = strlen(string);
@@ -3176,9 +3182,14 @@ INT32 V_ThinSubStringWidth(const char *string, INT32 length, INT32 option)
{
INT32 c, w = 0;
INT32 spacewidth = 2, charwidth = 0;
boolean lowercase = (option & V_ALLOWLOWERCASE);
boolean lowercase;
ssize_t i;
if (!string)
return 0;
lowercase = (option & V_ALLOWLOWERCASE);
if (length < 0)
length = strlen(string);
@@ -3233,6 +3244,9 @@ INT32 V_SubStringLengthToFit(const char *string, INT32 width, INT32 option)
INT32 spacewidth = 4, charwidth = 0;
INT32 i;
if (!string)
return 0;
switch (option & V_SPACINGMASK)
{
case V_MONOSPACE:
+1
View File
@@ -0,0 +1 @@
win_dbg.c