From ba376dbbfe114aa6ffd4217981252e42852f56e4 Mon Sep 17 00:00:00 2001 From: Alug Date: Sun, 10 Mar 2024 18:53:18 +0100 Subject: [PATCH 01/11] Port R_PointToPseudoAngle from dsda-doom --- src/m_fixed.h | 35 +++++++++++++++++++++++++++++++++++ src/r_main.c | 34 ++++++++++++++++++++++++++++++++++ src/r_main.h | 1 + 3 files changed, 70 insertions(+) diff --git a/src/m_fixed.h b/src/m_fixed.h index 4e4c79c65..9fe35c91d 100644 --- a/src/m_fixed.h +++ b/src/m_fixed.h @@ -260,6 +260,41 @@ typedef struct fixed_t y; } vector2_t; +// Source: "Know Your FPU: Fixing Floating Fast" +// http://www.stereopsis.com/sree/fpu2006.html +// +// xs_CRoundToInt: Round toward nearest, but ties round toward even (just like FISTP) +// taken from prboom+ for OpenGL big room fix +#ifndef _xs_DEFAULT_CONVERSION +#define _xs_DEFAULT_CONVERSION 0 +#endif //_xs_DEFAULT_CONVERSION + +#ifdef WORDS_BIGENDIAN + #define _xs_iexp_ 0 + #define _xs_iman_ 1 +#else + #define _xs_iexp_ 1 //intel is little endian + #define _xs_iman_ 0 +#endif //BigEndian_ + +typedef double real64; +typedef union _xs_doubleints +{ + real64 val; + unsigned ival[2]; +} _xs_doubleints; + +FUNCMATH FUNCINLINE ATTRINLINE int xs_CRoundToInt(real64 val) +{ +#if _xs_DEFAULT_CONVERSION==0 + _xs_doubleints uval; + uval.val = val + 6755399441055744.0; + return uval.ival[_xs_iman_]; +#else + return int(floor(val+.5)); +#endif +} + vector2_t *FV2_Load(vector2_t *vec, fixed_t x, fixed_t y); vector2_t *FV2_UnLoad(vector2_t *vec, fixed_t *x, fixed_t *y); vector2_t *FV2_Copy(vector2_t *a_o, const vector2_t *a_i); diff --git a/src/r_main.c b/src/r_main.c index 8a975498d..f2609fb5c 100644 --- a/src/r_main.c +++ b/src/r_main.c @@ -457,6 +457,40 @@ angle_t R_PointToAngle2(fixed_t pviewx, fixed_t pviewy, fixed_t x, fixed_t y) 0; } +// +// R_PointToPseudoAngle +// ! Returns the pseudoangle between the line p1 to (infinity, p1.y) and the +// line from p1 to p2. The pseudoangle has the property that the ordering of +// points by true angle anround p1 and ordering of points by pseudoangle are the +// same. +// +// For clipping exact angles are not needed. Only the ordering matters. +// This is about as fast as the fixed point R_PointToAngle2 but without +// the precision issues associated with that function. +// + +angle_t R_PointToPseudoAngle (fixed_t x, fixed_t y) +{ + // Note: float won't work here as it's less precise than the BAM values being passed as parameters + double vecx = (double)x - viewx; + double vecy = (double)y - viewy; + double epsilon = 1e-9; + + if (fabs(vecx) < epsilon && fabs(vecy) < epsilon) + { + return 0; + } + else + { + double result = vecy / (fabs(vecx) + fabs(vecy)); + if (vecx < 0) + { + result = 2.0 - result; + } + return (angle_t)xs_CRoundToInt(result * (1 << 30)); + } +} + fixed_t R_PointToDist2(fixed_t px2, fixed_t py2, fixed_t px1, fixed_t py1) { return FixedHypot(px1 - px2, py1 - py2); diff --git a/src/r_main.h b/src/r_main.h index 63c7c3ab5..85bb9e827 100644 --- a/src/r_main.h +++ b/src/r_main.h @@ -71,6 +71,7 @@ angle_t R_PointToAngle(fixed_t x, fixed_t y); angle_t R_PointToAngle64(INT64 x, INT64 y); angle_t R_PointToAngleEx(INT32 x2, INT32 y2, INT32 x1, INT32 y1); angle_t R_PointToAngle2(fixed_t px2, fixed_t py2, fixed_t px1, fixed_t py1); +angle_t R_PointToPseudoAngle (fixed_t x, fixed_t y); fixed_t R_PointToDist(fixed_t x, fixed_t y); fixed_t R_PointToDist2(fixed_t px2, fixed_t py2, fixed_t px1, fixed_t py1); angle_t R_PlayerSliptideAngle(player_t *player); From 50ba93541dfbbef9bb5d676ed2ab75cde7a94488 Mon Sep 17 00:00:00 2001 From: Alug Date: Sun, 10 Mar 2024 17:59:24 +0100 Subject: [PATCH 02/11] i am in pain --- src/hardware/hw_clip.c | 264 ------------------------------ src/hardware/hw_main.c | 3 + src/hardware/r_opengl/r_opengl.c | 272 ++++++++++++++++++++++++++++++- 3 files changed, 274 insertions(+), 265 deletions(-) diff --git a/src/hardware/hw_clip.c b/src/hardware/hw_clip.c index 8ef5636aa..9e161b2ea 100644 --- a/src/hardware/hw_clip.c +++ b/src/hardware/hw_clip.c @@ -84,271 +84,7 @@ static GLdouble projMatrix[16]; float frustum[6][4]; #endif -typedef struct clipnode_s - { - struct clipnode_s *prev, *next; - angle_t start, end; - } clipnode_t; -clipnode_t *freelist; -clipnode_t *clipnodes; -clipnode_t *cliphead; - -static clipnode_t * gld_clipnode_GetNew(void); -static clipnode_t * gld_clipnode_NewRange(angle_t start, angle_t end); -static boolean gld_clipper_IsRangeVisible(angle_t startAngle, angle_t endAngle); -static void gld_clipper_AddClipRange(angle_t start, angle_t end); -static void gld_clipper_RemoveRange(clipnode_t * range); -static void gld_clipnode_Free(clipnode_t *node); - -static clipnode_t * gld_clipnode_GetNew(void) -{ - if (freelist) - { - clipnode_t * p = freelist; - freelist = p->next; - return p; - } - else - { - return (clipnode_t*)malloc(sizeof(clipnode_t)); - } -} - -static clipnode_t * gld_clipnode_NewRange(angle_t start, angle_t end) -{ - clipnode_t * c = gld_clipnode_GetNew(); - c->start = start; - c->end = end; - c->next = c->prev=NULL; - return c; -} - -boolean gld_clipper_SafeCheckRange(angle_t startAngle, angle_t endAngle) -{ - if(startAngle > endAngle) - { - return (gld_clipper_IsRangeVisible(startAngle, ANGLE_MAX) || gld_clipper_IsRangeVisible(0, endAngle)); - } - - return gld_clipper_IsRangeVisible(startAngle, endAngle); -} - -static boolean gld_clipper_IsRangeVisible(angle_t startAngle, angle_t endAngle) -{ - clipnode_t *ci; - ci = cliphead; - - if (endAngle == 0 && ci && ci->start == 0) - return false; - - while (ci != NULL && ci->start < endAngle) - { - if (startAngle >= ci->start && endAngle <= ci->end) - { - return false; - } - ci = ci->next; - } - - return true; -} - -static void gld_clipnode_Free(clipnode_t *node) -{ - node->next = freelist; - freelist = node; -} - -static void gld_clipper_RemoveRange(clipnode_t *range) -{ - if (range == cliphead) - { - cliphead = cliphead->next; - } - else - { - if (range->prev) - { - range->prev->next = range->next; - } - if (range->next) - { - range->next->prev = range->prev; - } - } - - gld_clipnode_Free(range); -} - -void gld_clipper_SafeAddClipRange(angle_t startangle, angle_t endangle) -{ - if(startangle > endangle) - { - // The range has to added in two parts. - gld_clipper_AddClipRange(startangle, ANGLE_MAX); - gld_clipper_AddClipRange(0, endangle); - } - else - { - // Add the range as usual. - gld_clipper_AddClipRange(startangle, endangle); - } -} - -static void gld_clipper_AddClipRange(angle_t start, angle_t end) -{ - clipnode_t *node, *temp, *prevNode, *node2, *delnode; - - if (cliphead) - { - //check to see if range contains any old ranges - node = cliphead; - while (node != NULL && node->start < end) - { - if (node->start >= start && node->end <= end) - { - temp = node; - node = node->next; - gld_clipper_RemoveRange(temp); - } - else - { - if (node->start <= start && node->end >= end) - { - return; - } - else - { - node = node->next; - } - } - } - - //check to see if range overlaps a range (or possibly 2) - node = cliphead; - while (node != NULL && node->start <= end) - { - if (node->end >= start) - { - // we found the first overlapping node - if (node->start > start) - { - // the new range overlaps with this node's start point - node->start = start; - } - if (node->end < end) - { - node->end = end; - } - - node2 = node->next; - while (node2 && node2->start <= node->end) - { - if (node2->end > node->end) - { - node->end = node2->end; - } - - delnode = node2; - node2 = node2->next; - gld_clipper_RemoveRange(delnode); - } - return; - } - node = node->next; - } - - //just add range - node = cliphead; - prevNode = NULL; - temp = gld_clipnode_NewRange(start, end); - while (node != NULL && node->start < end) - { - prevNode = node; - node = node->next; - } - temp->next = node; - if (node == NULL) - { - temp->prev = prevNode; - if (prevNode) - { - prevNode->next = temp; - } - if (!cliphead) - { - cliphead = temp; - } - } - else - { - if (node == cliphead) - { - cliphead->prev = temp; - cliphead = temp; - } - else - { - temp->prev = prevNode; - prevNode->next = temp; - node->prev = temp; - } - } - } - else - { - temp = gld_clipnode_NewRange(start, end); - cliphead = temp; - return; - } -} - -void gld_clipper_Clear(void) -{ - clipnode_t *node = cliphead; - clipnode_t *temp; - - while (node != NULL) - { - temp = node; - node = node->next; - gld_clipnode_Free(temp); - } - - cliphead = NULL; -} - -#define RMUL (1.6f/1.333333f) - -angle_t gld_FrustumAngle(angle_t tiltangle) -{ - double floatangle; - angle_t a1; - - float tilt = (float)fabs(((double)(int)tiltangle) / ANG1); - - // NEWCLIP TODO: SRB2CBTODO: make a global render_fov for this function - - float render_fov = FIXED_TO_FLOAT(cv_fov.value); - float render_fovratio = (float)BASEVIDWIDTH / (float)BASEVIDHEIGHT; // SRB2CBTODO: NEWCLIPTODO: Is this right? - float render_multiplier = 64.0f / render_fovratio / RMUL; - - if (tilt > 90.0f) - tilt = 90.0f; - - // If the pitch is larger than this you can look all around at a FOV of 90 - if (abs((signed)tiltangle) > 46 * ANG1) - return 0xffffffff; - - // ok, this is a gross hack that barely works... - // but at least it doesn't overestimate too much... - floatangle = 2.0f + (45.0f + (tilt / 1.9f)) * (float)render_fov * 48.0f / render_multiplier / 90.0f; - a1 = ANG1 * (int)floatangle; - if (a1 >= ANGLE_180) - return 0xffffffff; - return a1; -} // SRB2CB I don't think used any of this stuff, let's disable for now since SRB2 probably doesn't want it either // compiler complains about (p)glGetFloatv anyway, in case anyone wants this diff --git a/src/hardware/hw_main.c b/src/hardware/hw_main.c index 66e520726..e5b775d3f 100644 --- a/src/hardware/hw_main.c +++ b/src/hardware/hw_main.c @@ -5891,6 +5891,9 @@ void HWR_RenderFrame(INT32 viewnumber, player_t *player, boolean skybox) } HWR_ClearClipper(); + + // Set transform. + HWD.pfnSetTransform(&atransform); // Reset the shader state. //HWR_SetShaderState(); diff --git a/src/hardware/r_opengl/r_opengl.c b/src/hardware/r_opengl/r_opengl.c index bb5c1fe3d..33a431015 100644 --- a/src/hardware/r_opengl/r_opengl.c +++ b/src/hardware/r_opengl/r_opengl.c @@ -28,6 +28,7 @@ #include "r_vbo.h" #include "../hw_shaders.h" #include "../hw_main.h" +#include "../hw_clip.h" // Eeeeh not sure is this right way, but it works < sry :c < sry again it had to go :c @@ -884,9 +885,11 @@ static void GLPerspective(GLfloat fovy, GLfloat aspect) m[1][1] = cotangent; m[2][2] = -(zFar + zNear) / deltaZ; m[3][2] = -2.0f * zNear * zFar / deltaZ; + pglMultMatrixf(&m[0][0]); } + // -----------------+ // SetModelView : // -----------------+ @@ -2725,7 +2728,9 @@ EXPORT void HWRAPI(SetTransform) (FTransform *stransform) static boolean special_splitscreen; GLdouble used_fov; boolean shearing = false; + pglLoadIdentity(); + if (stransform) { used_fov = stransform->fovxangle; @@ -2746,7 +2751,7 @@ EXPORT void HWRAPI(SetTransform) (FTransform *stransform) if (stransform->roll) pglRotatef(stransform->rollangle, 0.0f, 0.0f, 1.0f); - pglRotatef(stransform->anglex, 1.0f, 0.0f, 0.0f); + pglRotatef(stransform->anglex , 1.0f, 0.0f, 0.0f); pglRotatef(stransform->angley+270.0f, 0.0f, 1.0f, 0.0f); pglTranslatef(-stransform->x, -stransform->z, -stransform->y); @@ -2780,6 +2785,7 @@ EXPORT void HWRAPI(SetTransform) (FTransform *stransform) } else GLPerspective((GLfloat)used_fov, ASPECT_RATIO); + pglGetFloatv(GL_PROJECTION_MATRIX, projMatrix); // added for new coronas' code (without depth buffer) pglMatrixMode(GL_MODELVIEW); @@ -3347,4 +3353,268 @@ EXPORT void HWRAPI(SetScreenPalette)(RGBA_t *palette) } } +typedef struct clipnode_s + { + struct clipnode_s *prev, *next; + angle_t start, end; + } clipnode_t; + +clipnode_t *freelist; +clipnode_t *clipnodes; +clipnode_t *cliphead; + +static clipnode_t * gld_clipnode_GetNew(void); +static clipnode_t * gld_clipnode_NewRange(angle_t start, angle_t end); +static boolean gld_clipper_IsRangeVisible(angle_t startAngle, angle_t endAngle); +static void gld_clipper_AddClipRange(angle_t start, angle_t end); +static void gld_clipper_RemoveRange(clipnode_t * range); +static void gld_clipnode_Free(clipnode_t *node); + +static clipnode_t * gld_clipnode_GetNew(void) +{ + if (freelist) + { + clipnode_t * p = freelist; + freelist = p->next; + return p; + } + else + { + return (clipnode_t*)malloc(sizeof(clipnode_t)); + } +} + +static clipnode_t * gld_clipnode_NewRange(angle_t start, angle_t end) +{ + clipnode_t * c = gld_clipnode_GetNew(); + c->start = start; + c->end = end; + c->next = c->prev=NULL; + return c; +} + +boolean gld_clipper_SafeCheckRange(angle_t startAngle, angle_t endAngle) +{ + if(startAngle > endAngle) + { + return (gld_clipper_IsRangeVisible(startAngle, ANGLE_MAX) || gld_clipper_IsRangeVisible(0, endAngle)); + } + + return gld_clipper_IsRangeVisible(startAngle, endAngle); +} + +static boolean gld_clipper_IsRangeVisible(angle_t startAngle, angle_t endAngle) +{ + clipnode_t *ci; + ci = cliphead; + + if (endAngle == 0 && ci && ci->start == 0) + return false; + + while (ci != NULL && ci->start < endAngle) + { + if (startAngle >= ci->start && endAngle <= ci->end) + { + return false; + } + ci = ci->next; + } + + return true; +} + +static void gld_clipnode_Free(clipnode_t *node) +{ + node->next = freelist; + freelist = node; +} + +static void gld_clipper_RemoveRange(clipnode_t *range) +{ + if (range == cliphead) + { + cliphead = cliphead->next; + } + else + { + if (range->prev) + { + range->prev->next = range->next; + } + if (range->next) + { + range->next->prev = range->prev; + } + } + + gld_clipnode_Free(range); +} + +void gld_clipper_SafeAddClipRange(angle_t startangle, angle_t endangle) +{ + if(startangle > endangle) + { + // The range has to added in two parts. + gld_clipper_AddClipRange(startangle, ANGLE_MAX); + gld_clipper_AddClipRange(0, endangle); + } + else + { + // Add the range as usual. + gld_clipper_AddClipRange(startangle, endangle); + } +} + +static void gld_clipper_AddClipRange(angle_t start, angle_t end) +{ + clipnode_t *node, *temp, *prevNode, *node2, *delnode; + + if (cliphead) + { + //check to see if range contains any old ranges + node = cliphead; + while (node != NULL && node->start < end) + { + if (node->start >= start && node->end <= end) + { + temp = node; + node = node->next; + gld_clipper_RemoveRange(temp); + } + else + { + if (node->start <= start && node->end >= end) + { + return; + } + else + { + node = node->next; + } + } + } + + //check to see if range overlaps a range (or possibly 2) + node = cliphead; + while (node != NULL && node->start <= end) + { + if (node->end >= start) + { + // we found the first overlapping node + if (node->start > start) + { + // the new range overlaps with this node's start point + node->start = start; + } + if (node->end < end) + { + node->end = end; + } + + node2 = node->next; + while (node2 && node2->start <= node->end) + { + if (node2->end > node->end) + { + node->end = node2->end; + } + + delnode = node2; + node2 = node2->next; + gld_clipper_RemoveRange(delnode); + } + return; + } + node = node->next; + } + + //just add range + node = cliphead; + prevNode = NULL; + temp = gld_clipnode_NewRange(start, end); + while (node != NULL && node->start < end) + { + prevNode = node; + node = node->next; + } + temp->next = node; + if (node == NULL) + { + temp->prev = prevNode; + if (prevNode) + { + prevNode->next = temp; + } + if (!cliphead) + { + cliphead = temp; + } + } + else + { + if (node == cliphead) + { + cliphead->prev = temp; + cliphead = temp; + } + else + { + temp->prev = prevNode; + prevNode->next = temp; + node->prev = temp; + } + } + } + else + { + temp = gld_clipnode_NewRange(start, end); + cliphead = temp; + return; + } +} + +void gld_clipper_Clear(void) +{ + clipnode_t *node = cliphead; + clipnode_t *temp; + + while (node != NULL) + { + temp = node; + node = node->next; + gld_clipnode_Free(temp); + } + + cliphead = NULL; +} + +#define RMUL (1.6f/1.333333f) + +angle_t gld_FrustumAngle(angle_t tiltangle) +{ + double fov2; + double floatangle; + angle_t a1; + + float tilt = (float)fabs(((double)(int)tiltangle) / ANG1); + + // NEWCLIP TODO: SRB2CBTODO: make a global render_fov for this function + + if (tilt > 90.0f) + tilt = 90.0f; + + // If the pitch is larger than this you can look all around at a FOV of 90 + if (abs((signed)tiltangle) > 46 * ANG1) + return 0xffffffff; + + // ok, this is a gross hack that barely works... + // but at least it doesn't overestimate too much... + fov2 = atan(1 / projMatrix[0]) * 360 / M_PIl; + floatangle = 2.0f + (45.0f + (tilt / 1.9f)) * fov2 / 90.0f; + if (floatangle >= 180.0) + return 0xffffffff; + a1 = (angle_t)xs_CRoundToInt(ANG1 * floatangle); + return a1; +} + #endif //HWRENDER From 8ec7e2321756aed53fc625e3f7246d38d49f54b5 Mon Sep 17 00:00:00 2001 From: Alug Date: Sun, 10 Mar 2024 18:50:38 +0100 Subject: [PATCH 03/11] clean up stuff a little --- src/hardware/hw_clip.c | 17 +++++------------ src/hardware/hw_clip.h | 2 +- src/hardware/hw_main.c | 2 +- src/hardware/r_opengl/r_opengl.c | 10 ++++++++++ src/m_menu.c | 4 +++- 5 files changed, 20 insertions(+), 15 deletions(-) diff --git a/src/hardware/hw_clip.c b/src/hardware/hw_clip.c index 9e161b2ea..d8f42e624 100644 --- a/src/hardware/hw_clip.c +++ b/src/hardware/hw_clip.c @@ -68,15 +68,10 @@ ** */ -#include -#include "../v_video.h" -#include "hw_main.h" #include "hw_clip.h" -#include "hw_glob.h" -#include "../r_state.h" -#include "../tables.h" -#include "r_opengl/r_opengl.h" -#include "../r_main.h" // for cv_fov + +// clipping code moved to r_opengl.c, let me qoute the below comment "only r_opengl.c can use the base gl funcs as it turns out.." + #ifdef HAVE_SPHEREFRUSTRUM static GLdouble viewMatrix[16]; @@ -84,15 +79,13 @@ static GLdouble projMatrix[16]; float frustum[6][4]; #endif - - // SRB2CB I don't think used any of this stuff, let's disable for now since SRB2 probably doesn't want it either // compiler complains about (p)glGetFloatv anyway, in case anyone wants this // only r_opengl.c can use the base gl funcs as it turns out, that's a problem for whoever wants sphere frustum checks // btw to renable define HAVE_SPHEREFRUSTRUM in hw_clip.h #ifdef HAVE_SPHEREFRUSTRUM // -// gld_FrustrumSetup +// gld_FrustumSetup // #define CALCMATRIX(a, b, c, d, e, f, g, h)\ @@ -111,7 +104,7 @@ frustum[i][1] /= t; \ frustum[i][2] /= t; \ frustum[i][3] /= t -void gld_FrustrumSetup(void) +void gld_FrustumSetup(void) { float t; float clip[16]; diff --git a/src/hardware/hw_clip.h b/src/hardware/hw_clip.h index 27a2ed1ef..dfaa87f81 100644 --- a/src/hardware/hw_clip.h +++ b/src/hardware/hw_clip.h @@ -19,6 +19,6 @@ void gld_clipper_SafeAddClipRange(angle_t startangle, angle_t endangle); void gld_clipper_Clear(void); angle_t gld_FrustumAngle(angle_t tiltangle); #ifdef HAVE_SPHEREFRUSTRUM -void gld_FrustrumSetup(void); +void gld_FrustumSetup(void); boolean gld_SphereInFrustum(float x, float y, float z, float radius); #endif diff --git a/src/hardware/hw_main.c b/src/hardware/hw_main.c index e5b775d3f..e946fc1d6 100644 --- a/src/hardware/hw_main.c +++ b/src/hardware/hw_main.c @@ -5545,7 +5545,7 @@ void HWR_ClearClipper(void) gld_clipper_Clear(); gld_clipper_SafeAddClipRange(viewangle + a1, viewangle - a1); #ifdef HAVE_SPHEREFRUSTRUM - gld_FrustrumSetup(); + gld_FrustumSetup(); #endif } diff --git a/src/hardware/r_opengl/r_opengl.c b/src/hardware/r_opengl/r_opengl.c index 33a431015..174813eeb 100644 --- a/src/hardware/r_opengl/r_opengl.c +++ b/src/hardware/r_opengl/r_opengl.c @@ -3353,6 +3353,16 @@ EXPORT void HWRAPI(SetScreenPalette)(RGBA_t *palette) } } + +/* + * hw_clip + * SRB2CB + * + * PrBoom's OpenGL clipping + * + * + */ + typedef struct clipnode_s { struct clipnode_s *prev, *next; diff --git a/src/m_menu.c b/src/m_menu.c index 5cf720be7..a9cac9ecd 100644 --- a/src/m_menu.c +++ b/src/m_menu.c @@ -4338,7 +4338,9 @@ void M_Init(void) OP_ExpOptionsMenu[op_exp_fofcut].status = IT_DISABLED; } - if (rendermode == render_opengl){ + if (rendermode == render_opengl) + { + OP_ExpOptionsMenu[op_exp_angleshit].status = IT_DISABLED; OP_ExpOptionsMenu[op_exp_ffclip].status = IT_DISABLED; OP_ExpOptionsMenu[op_exp_sprclip].status = IT_DISABLED; } From e77453e43a129b2d87c2c5b63270b97200567d5b Mon Sep 17 00:00:00 2001 From: Alug Date: Mon, 11 Mar 2024 02:15:34 +0100 Subject: [PATCH 04/11] actually move stuff back to hw_clip lmao --- src/hardware/hw_clip.c | 282 ++++++++++++++++++++++++++++++- src/hardware/r_opengl/r_opengl.c | 276 +----------------------------- src/hardware/r_opengl/r_opengl.h | 2 + 3 files changed, 279 insertions(+), 281 deletions(-) diff --git a/src/hardware/hw_clip.c b/src/hardware/hw_clip.c index d8f42e624..594a0aa87 100644 --- a/src/hardware/hw_clip.c +++ b/src/hardware/hw_clip.c @@ -68,16 +68,282 @@ ** */ + +#include +#include "../v_video.h" +#include "hw_main.h" #include "hw_clip.h" +#include "hw_glob.h" +#include "../r_state.h" +#include "../tables.h" +#include "r_opengl/r_opengl.h" -// clipping code moved to r_opengl.c, let me qoute the below comment "only r_opengl.c can use the base gl funcs as it turns out.." + +typedef struct clipnode_s + { + struct clipnode_s *prev, *next; + angle_t start, end; + } clipnode_t; + +clipnode_t *freelist; +clipnode_t *clipnodes; +clipnode_t *cliphead; + +static clipnode_t * gld_clipnode_GetNew(void); +static clipnode_t * gld_clipnode_NewRange(angle_t start, angle_t end); +static boolean gld_clipper_IsRangeVisible(angle_t startAngle, angle_t endAngle); +static void gld_clipper_AddClipRange(angle_t start, angle_t end); +static void gld_clipper_RemoveRange(clipnode_t * range); +static void gld_clipnode_Free(clipnode_t *node); + +static clipnode_t * gld_clipnode_GetNew(void) +{ + if (freelist) + { + clipnode_t * p = freelist; + freelist = p->next; + return p; + } + else + { + return (clipnode_t*)malloc(sizeof(clipnode_t)); + } +} + +static clipnode_t * gld_clipnode_NewRange(angle_t start, angle_t end) +{ + clipnode_t * c = gld_clipnode_GetNew(); + c->start = start; + c->end = end; + c->next = c->prev=NULL; + return c; +} + +boolean gld_clipper_SafeCheckRange(angle_t startAngle, angle_t endAngle) +{ + if(startAngle > endAngle) + { + return (gld_clipper_IsRangeVisible(startAngle, ANGLE_MAX) || gld_clipper_IsRangeVisible(0, endAngle)); + } + + return gld_clipper_IsRangeVisible(startAngle, endAngle); +} + +static boolean gld_clipper_IsRangeVisible(angle_t startAngle, angle_t endAngle) +{ + clipnode_t *ci; + ci = cliphead; + + if (endAngle == 0 && ci && ci->start == 0) + return false; + + while (ci != NULL && ci->start < endAngle) + { + if (startAngle >= ci->start && endAngle <= ci->end) + { + return false; + } + ci = ci->next; + } + + return true; +} + +static void gld_clipnode_Free(clipnode_t *node) +{ + node->next = freelist; + freelist = node; +} + +static void gld_clipper_RemoveRange(clipnode_t *range) +{ + if (range == cliphead) + { + cliphead = cliphead->next; + } + else + { + if (range->prev) + { + range->prev->next = range->next; + } + if (range->next) + { + range->next->prev = range->prev; + } + } + + gld_clipnode_Free(range); +} + +void gld_clipper_SafeAddClipRange(angle_t startangle, angle_t endangle) +{ + if(startangle > endangle) + { + // The range has to added in two parts. + gld_clipper_AddClipRange(startangle, ANGLE_MAX); + gld_clipper_AddClipRange(0, endangle); + } + else + { + // Add the range as usual. + gld_clipper_AddClipRange(startangle, endangle); + } +} + +static void gld_clipper_AddClipRange(angle_t start, angle_t end) +{ + clipnode_t *node, *temp, *prevNode, *node2, *delnode; + + if (cliphead) + { + //check to see if range contains any old ranges + node = cliphead; + while (node != NULL && node->start < end) + { + if (node->start >= start && node->end <= end) + { + temp = node; + node = node->next; + gld_clipper_RemoveRange(temp); + } + else + { + if (node->start <= start && node->end >= end) + { + return; + } + else + { + node = node->next; + } + } + } + + //check to see if range overlaps a range (or possibly 2) + node = cliphead; + while (node != NULL && node->start <= end) + { + if (node->end >= start) + { + // we found the first overlapping node + if (node->start > start) + { + // the new range overlaps with this node's start point + node->start = start; + } + if (node->end < end) + { + node->end = end; + } + + node2 = node->next; + while (node2 && node2->start <= node->end) + { + if (node2->end > node->end) + { + node->end = node2->end; + } + + delnode = node2; + node2 = node2->next; + gld_clipper_RemoveRange(delnode); + } + return; + } + node = node->next; + } + + //just add range + node = cliphead; + prevNode = NULL; + temp = gld_clipnode_NewRange(start, end); + while (node != NULL && node->start < end) + { + prevNode = node; + node = node->next; + } + temp->next = node; + if (node == NULL) + { + temp->prev = prevNode; + if (prevNode) + { + prevNode->next = temp; + } + if (!cliphead) + { + cliphead = temp; + } + } + else + { + if (node == cliphead) + { + cliphead->prev = temp; + cliphead = temp; + } + else + { + temp->prev = prevNode; + prevNode->next = temp; + node->prev = temp; + } + } + } + else + { + temp = gld_clipnode_NewRange(start, end); + cliphead = temp; + return; + } +} + +void gld_clipper_Clear(void) +{ + clipnode_t *node = cliphead; + clipnode_t *temp; + + while (node != NULL) + { + temp = node; + node = node->next; + gld_clipnode_Free(temp); + } + + cliphead = NULL; +} + +#define RMUL (1.6f/1.333333f) + +angle_t gld_FrustumAngle(angle_t tiltangle) +{ + double fov2; + double floatangle; + angle_t a1; + + float tilt = (float)fabs(((double)(int)tiltangle) / ANG1); + + // NEWCLIP TODO: SRB2CBTODO: make a global render_fov for this function + + if (tilt > 90.0f) + tilt = 90.0f; + + // If the pitch is larger than this you can look all around at a FOV of 90 + if (abs((signed)tiltangle) > 46 * ANG1) + return 0xffffffff; + + // ok, this is a gross hack that barely works... + // but at least it doesn't overestimate too much... + fov2 = atan(1 / projMatrix[0]) * 360 / M_PIl; + floatangle = 2.0f + (45.0f + (tilt / 1.9f)) * fov2 / 90.0f; + if (floatangle >= 180.0) + return 0xffffffff; + a1 = (angle_t)xs_CRoundToInt(ANG1 * floatangle); + return a1; +} -#ifdef HAVE_SPHEREFRUSTRUM -static GLdouble viewMatrix[16]; -static GLdouble projMatrix[16]; -float frustum[6][4]; -#endif // SRB2CB I don't think used any of this stuff, let's disable for now since SRB2 probably doesn't want it either // compiler complains about (p)glGetFloatv anyway, in case anyone wants this @@ -88,6 +354,10 @@ float frustum[6][4]; // gld_FrustumSetup // +static GLdouble viewMatrix[16]; +static GLdouble projMatrix[16]; +float frustum[6][4]; + #define CALCMATRIX(a, b, c, d, e, f, g, h)\ (float)(viewMatrix[a] * projMatrix[b] + \ viewMatrix[c] * projMatrix[d] + \ diff --git a/src/hardware/r_opengl/r_opengl.c b/src/hardware/r_opengl/r_opengl.c index 174813eeb..e287d681d 100644 --- a/src/hardware/r_opengl/r_opengl.c +++ b/src/hardware/r_opengl/r_opengl.c @@ -111,7 +111,7 @@ const GLubyte *gl_extensions = NULL; //Hurdler: 04/10/2000: added for the kick ass coronas as Boris wanted;-) static GLfloat modelMatrix[16]; -static GLfloat projMatrix[16]; +GLfloat projMatrix[16]; static GLint viewport[4]; @@ -3353,278 +3353,4 @@ EXPORT void HWRAPI(SetScreenPalette)(RGBA_t *palette) } } - -/* - * hw_clip - * SRB2CB - * - * PrBoom's OpenGL clipping - * - * - */ - -typedef struct clipnode_s - { - struct clipnode_s *prev, *next; - angle_t start, end; - } clipnode_t; - -clipnode_t *freelist; -clipnode_t *clipnodes; -clipnode_t *cliphead; - -static clipnode_t * gld_clipnode_GetNew(void); -static clipnode_t * gld_clipnode_NewRange(angle_t start, angle_t end); -static boolean gld_clipper_IsRangeVisible(angle_t startAngle, angle_t endAngle); -static void gld_clipper_AddClipRange(angle_t start, angle_t end); -static void gld_clipper_RemoveRange(clipnode_t * range); -static void gld_clipnode_Free(clipnode_t *node); - -static clipnode_t * gld_clipnode_GetNew(void) -{ - if (freelist) - { - clipnode_t * p = freelist; - freelist = p->next; - return p; - } - else - { - return (clipnode_t*)malloc(sizeof(clipnode_t)); - } -} - -static clipnode_t * gld_clipnode_NewRange(angle_t start, angle_t end) -{ - clipnode_t * c = gld_clipnode_GetNew(); - c->start = start; - c->end = end; - c->next = c->prev=NULL; - return c; -} - -boolean gld_clipper_SafeCheckRange(angle_t startAngle, angle_t endAngle) -{ - if(startAngle > endAngle) - { - return (gld_clipper_IsRangeVisible(startAngle, ANGLE_MAX) || gld_clipper_IsRangeVisible(0, endAngle)); - } - - return gld_clipper_IsRangeVisible(startAngle, endAngle); -} - -static boolean gld_clipper_IsRangeVisible(angle_t startAngle, angle_t endAngle) -{ - clipnode_t *ci; - ci = cliphead; - - if (endAngle == 0 && ci && ci->start == 0) - return false; - - while (ci != NULL && ci->start < endAngle) - { - if (startAngle >= ci->start && endAngle <= ci->end) - { - return false; - } - ci = ci->next; - } - - return true; -} - -static void gld_clipnode_Free(clipnode_t *node) -{ - node->next = freelist; - freelist = node; -} - -static void gld_clipper_RemoveRange(clipnode_t *range) -{ - if (range == cliphead) - { - cliphead = cliphead->next; - } - else - { - if (range->prev) - { - range->prev->next = range->next; - } - if (range->next) - { - range->next->prev = range->prev; - } - } - - gld_clipnode_Free(range); -} - -void gld_clipper_SafeAddClipRange(angle_t startangle, angle_t endangle) -{ - if(startangle > endangle) - { - // The range has to added in two parts. - gld_clipper_AddClipRange(startangle, ANGLE_MAX); - gld_clipper_AddClipRange(0, endangle); - } - else - { - // Add the range as usual. - gld_clipper_AddClipRange(startangle, endangle); - } -} - -static void gld_clipper_AddClipRange(angle_t start, angle_t end) -{ - clipnode_t *node, *temp, *prevNode, *node2, *delnode; - - if (cliphead) - { - //check to see if range contains any old ranges - node = cliphead; - while (node != NULL && node->start < end) - { - if (node->start >= start && node->end <= end) - { - temp = node; - node = node->next; - gld_clipper_RemoveRange(temp); - } - else - { - if (node->start <= start && node->end >= end) - { - return; - } - else - { - node = node->next; - } - } - } - - //check to see if range overlaps a range (or possibly 2) - node = cliphead; - while (node != NULL && node->start <= end) - { - if (node->end >= start) - { - // we found the first overlapping node - if (node->start > start) - { - // the new range overlaps with this node's start point - node->start = start; - } - if (node->end < end) - { - node->end = end; - } - - node2 = node->next; - while (node2 && node2->start <= node->end) - { - if (node2->end > node->end) - { - node->end = node2->end; - } - - delnode = node2; - node2 = node2->next; - gld_clipper_RemoveRange(delnode); - } - return; - } - node = node->next; - } - - //just add range - node = cliphead; - prevNode = NULL; - temp = gld_clipnode_NewRange(start, end); - while (node != NULL && node->start < end) - { - prevNode = node; - node = node->next; - } - temp->next = node; - if (node == NULL) - { - temp->prev = prevNode; - if (prevNode) - { - prevNode->next = temp; - } - if (!cliphead) - { - cliphead = temp; - } - } - else - { - if (node == cliphead) - { - cliphead->prev = temp; - cliphead = temp; - } - else - { - temp->prev = prevNode; - prevNode->next = temp; - node->prev = temp; - } - } - } - else - { - temp = gld_clipnode_NewRange(start, end); - cliphead = temp; - return; - } -} - -void gld_clipper_Clear(void) -{ - clipnode_t *node = cliphead; - clipnode_t *temp; - - while (node != NULL) - { - temp = node; - node = node->next; - gld_clipnode_Free(temp); - } - - cliphead = NULL; -} - -#define RMUL (1.6f/1.333333f) - -angle_t gld_FrustumAngle(angle_t tiltangle) -{ - double fov2; - double floatangle; - angle_t a1; - - float tilt = (float)fabs(((double)(int)tiltangle) / ANG1); - - // NEWCLIP TODO: SRB2CBTODO: make a global render_fov for this function - - if (tilt > 90.0f) - tilt = 90.0f; - - // If the pitch is larger than this you can look all around at a FOV of 90 - if (abs((signed)tiltangle) > 46 * ANG1) - return 0xffffffff; - - // ok, this is a gross hack that barely works... - // but at least it doesn't overestimate too much... - fov2 = atan(1 / projMatrix[0]) * 360 / M_PIl; - floatangle = 2.0f + (45.0f + (tilt / 1.9f)) * fov2 / 90.0f; - if (floatangle >= 180.0) - return 0xffffffff; - a1 = (angle_t)xs_CRoundToInt(ANG1 * floatangle); - return a1; -} - #endif //HWRENDER diff --git a/src/hardware/r_opengl/r_opengl.h b/src/hardware/r_opengl/r_opengl.h index ba3cccbce..34b2d3cf7 100644 --- a/src/hardware/r_opengl/r_opengl.h +++ b/src/hardware/r_opengl/r_opengl.h @@ -123,6 +123,8 @@ extern GLint maximumAnisotropy; extern INT32 oglflags; extern GLint textureformatGL; +extern GLfloat projMatrix[16]; + typedef enum { GLF_NOZBUFREAD = 0x01, From 5ade9699c1e77199e080d943f187862d2b969b1d Mon Sep 17 00:00:00 2001 From: Alug Date: Mon, 11 Mar 2024 02:22:40 +0100 Subject: [PATCH 05/11] give this a better name lol --- src/hardware/hw_clip.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/hardware/hw_clip.c b/src/hardware/hw_clip.c index 594a0aa87..be8b21dcd 100644 --- a/src/hardware/hw_clip.c +++ b/src/hardware/hw_clip.c @@ -318,7 +318,7 @@ void gld_clipper_Clear(void) angle_t gld_FrustumAngle(angle_t tiltangle) { - double fov2; + double clipfov; double floatangle; angle_t a1; @@ -335,8 +335,8 @@ angle_t gld_FrustumAngle(angle_t tiltangle) // ok, this is a gross hack that barely works... // but at least it doesn't overestimate too much... - fov2 = atan(1 / projMatrix[0]) * 360 / M_PIl; - floatangle = 2.0f + (45.0f + (tilt / 1.9f)) * fov2 / 90.0f; + clipfov = atan(1 / projMatrix[0]) * 360 / M_PIl; + floatangle = 2.0f + (45.0f + (tilt / 1.9f)) * clipfov / 90.0f; if (floatangle >= 180.0) return 0xffffffff; a1 = (angle_t)xs_CRoundToInt(ANG1 * floatangle); From 95f51a26c1a28e50b4e05d4ef9aead7051dc19ca Mon Sep 17 00:00:00 2001 From: Alug Date: Mon, 11 Mar 2024 03:40:13 +0100 Subject: [PATCH 06/11] attempt at unfucking renderview --- src/hardware/hw_main.c | 95 +++++------------------------------------- 1 file changed, 11 insertions(+), 84 deletions(-) diff --git a/src/hardware/hw_main.c b/src/hardware/hw_main.c index e946fc1d6..6b7d4f8c7 100644 --- a/src/hardware/hw_main.c +++ b/src/hardware/hw_main.c @@ -271,8 +271,6 @@ FTransform atransform; static float gr_viewx, gr_viewy, gr_viewz; float gr_viewsin, gr_viewcos; -static fixed_t dup_viewx, dup_viewy, dup_viewz; - static angle_t gr_aimingangle; static float gr_viewludsin, gr_viewludcos; @@ -854,7 +852,7 @@ void HWR_RenderPlane(subsector_t *subsector, extrasubsector_t *xsub, boolean isc for (i = 0; i < subsector->numlines; i++, line++) { - if (line->linedef->special == HORIZONSPECIAL && R_PointOnSegSide(dup_viewx, dup_viewy, line) == 0) + if (line->linedef->special == HORIZONSPECIAL && R_PointOnSegSide(viewx, viewy, line) == 0) { P_ClosestPointOnLine(viewx, viewy, line->linedef, &v); dist = FIXED_TO_FLOAT(R_PointToDist(v.x, v.y)); @@ -5472,11 +5470,6 @@ void HWR_SetTransform(float fpov, player_t *player) postimg_t *postprocessor = &postimgtype[0]; INT32 i; - // copy view cam position for local use - dup_viewx = viewx; - dup_viewy = viewy; - dup_viewz = viewz; - gr_viewx = FIXED_TO_FLOAT(viewx); gr_viewy = FIXED_TO_FLOAT(viewy); gr_viewz = FIXED_TO_FLOAT(viewz); @@ -5663,7 +5656,9 @@ static void HWR_RenderViewpoint(gl_portal_t *rootportal, const float fpov, playe portalclipline = NULL; else HWR_PortalClipping(rootportal); + validcount++; + HWR_RenderBSPNode((INT32)numnodes-1);// no actual rendering happens // for each found portal: @@ -5681,11 +5676,12 @@ static void HWR_RenderViewpoint(gl_portal_t *rootportal, const float fpov, playe // draw normal things in current frame in current incremented stencil buffer area HWR_SetStencilState(HWR_STENCIL_NORMAL, stencil_level); if (!cv_portalonly.value || rootportal) - { + { + HWR_SetTransform(fpov, player); + HWR_ClearClipper(); HWR_ClearSprites(); - // the frame should be correct, set by either the for loop or the above layer in recursion - HWR_SetTransform(fpov, player); + if (!rootportal) portalclipline = NULL; else @@ -5693,7 +5689,10 @@ static void HWR_RenderViewpoint(gl_portal_t *rootportal, const float fpov, playe HWR_PortalFrame(rootportal);// for portalclipsector, it could have gone null from search HWR_PortalClipping(rootportal); } - //drawcount = 0; + + // Set transform. + HWD.pfnSetTransform(&atransform); + validcount++; if (cv_grbatching.value) @@ -5769,8 +5768,6 @@ static void HWR_RenderViewpoint(gl_portal_t *rootportal, const float fpov, playe void HWR_RenderFrame(INT32 viewnumber, player_t *player, boolean skybox) { const float fpov = FIXED_TO_FLOAT(cv_fov.value+player->fovadd); - postimg_t *postprocessor = &postimgtype[0]; - INT32 i; // set window position gr_centerx = gr_basecenterx; @@ -5809,67 +5806,8 @@ void HWR_RenderFrame(INT32 viewnumber, player_t *player, boolean skybox) // check for new console commands. NetUpdate(); - gr_viewx = FIXED_TO_FLOAT(viewx); - gr_viewy = FIXED_TO_FLOAT(viewy); - gr_viewz = FIXED_TO_FLOAT(viewz); - gr_viewsin = FIXED_TO_FLOAT(viewsin); - gr_viewcos = FIXED_TO_FLOAT(viewcos); - - memset(&atransform, 0x00, sizeof(FTransform)); - - // Set T&L transform - atransform.x = gr_viewx; - atransform.y = gr_viewy; - atransform.z = gr_viewz; - - atransform.scalex = 1; - atransform.scaley = (float)vid.width/vid.height; - atransform.scalez = 1; - - // 14042019 - gr_aimingangle = aimingangle; - atransform.shearing = false; - atransform.viewaiming = aimingangle; - - if (cv_grshearing.value) - { - gr_aimingangle = 0; - atransform.shearing = true; - } - - gr_viewludsin = FIXED_TO_FLOAT(FINECOSINE(gr_aimingangle>>ANGLETOFINESHIFT)); - gr_viewludcos = FIXED_TO_FLOAT(-FINESINE(gr_aimingangle>>ANGLETOFINESHIFT)); - - atransform.anglex = (float)(gr_aimingangle>>ANGLETOFINESHIFT)*(360.0f/(float)FINEANGLES); - atransform.angley = (float)(viewangle>>ANGLETOFINESHIFT)*(360.0f/(float)FINEANGLES); - - atransform.fovxangle = fpov; // Tails - atransform.fovyangle = fpov; // Tails - if (player->viewrollangle != 0) - { - fixed_t rol = AngleFixed(player->viewrollangle); - atransform.rollangle = FIXED_TO_FLOAT(rol); - atransform.roll = true; - } - atransform.splitscreen = splitscreen; - - for (i = 0; i <= splitscreen; i++) - { - if (player == &players[displayplayers[i]]) - postprocessor = &postimgtype[i]; - } - - atransform.flip = false; - if (*postprocessor == postimg_flip) - atransform.flip = true; - - atransform.mirror = false; - if (*postprocessor == postimg_mirror) - atransform.mirror = true; - // Clear view, set viewport (glViewport), set perspective... HWR_ClearView(); - HWR_ClearSprites(); ST_doPaletteStuff(); @@ -5890,19 +5828,8 @@ void HWR_RenderFrame(INT32 viewnumber, player_t *player, boolean skybox) current_bsp_culling_distance = bsp_culling_distances[cv_grrenderdistance.value - 1]; } - HWR_ClearClipper(); - - // Set transform. - HWD.pfnSetTransform(&atransform); - - // Reset the shader state. - //HWR_SetShaderState(); - - validcount++; - portalclipline = NULL; HWR_RenderViewpoint(NULL, fpov, player, 0, !skybox); - HWR_SetTransform(fpov, player);// not sure if needed // Unset transform and shader HWD.pfnSetTransform(NULL); From 01cce7c9c6fd4652932ba8c870b0bc6074aca464 Mon Sep 17 00:00:00 2001 From: Alug Date: Mon, 11 Mar 2024 04:25:41 +0100 Subject: [PATCH 07/11] remove pseudoangle as its slower --- src/r_main.c | 34 ---------------------------------- src/r_main.h | 1 - 2 files changed, 35 deletions(-) diff --git a/src/r_main.c b/src/r_main.c index f2609fb5c..8a975498d 100644 --- a/src/r_main.c +++ b/src/r_main.c @@ -457,40 +457,6 @@ angle_t R_PointToAngle2(fixed_t pviewx, fixed_t pviewy, fixed_t x, fixed_t y) 0; } -// -// R_PointToPseudoAngle -// ! Returns the pseudoangle between the line p1 to (infinity, p1.y) and the -// line from p1 to p2. The pseudoangle has the property that the ordering of -// points by true angle anround p1 and ordering of points by pseudoangle are the -// same. -// -// For clipping exact angles are not needed. Only the ordering matters. -// This is about as fast as the fixed point R_PointToAngle2 but without -// the precision issues associated with that function. -// - -angle_t R_PointToPseudoAngle (fixed_t x, fixed_t y) -{ - // Note: float won't work here as it's less precise than the BAM values being passed as parameters - double vecx = (double)x - viewx; - double vecy = (double)y - viewy; - double epsilon = 1e-9; - - if (fabs(vecx) < epsilon && fabs(vecy) < epsilon) - { - return 0; - } - else - { - double result = vecy / (fabs(vecx) + fabs(vecy)); - if (vecx < 0) - { - result = 2.0 - result; - } - return (angle_t)xs_CRoundToInt(result * (1 << 30)); - } -} - fixed_t R_PointToDist2(fixed_t px2, fixed_t py2, fixed_t px1, fixed_t py1) { return FixedHypot(px1 - px2, py1 - py2); diff --git a/src/r_main.h b/src/r_main.h index 85bb9e827..63c7c3ab5 100644 --- a/src/r_main.h +++ b/src/r_main.h @@ -71,7 +71,6 @@ angle_t R_PointToAngle(fixed_t x, fixed_t y); angle_t R_PointToAngle64(INT64 x, INT64 y); angle_t R_PointToAngleEx(INT32 x2, INT32 y2, INT32 x1, INT32 y1); angle_t R_PointToAngle2(fixed_t px2, fixed_t py2, fixed_t px1, fixed_t py1); -angle_t R_PointToPseudoAngle (fixed_t x, fixed_t y); fixed_t R_PointToDist(fixed_t x, fixed_t y); fixed_t R_PointToDist2(fixed_t px2, fixed_t py2, fixed_t px1, fixed_t py1); angle_t R_PlayerSliptideAngle(player_t *player); From 2fd0d980e39ad3d89465559ae9b3cb66c0adb642 Mon Sep 17 00:00:00 2001 From: Alug Date: Mon, 11 Mar 2024 04:27:52 +0100 Subject: [PATCH 08/11] make 64 default again --- src/r_main.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/r_main.c b/src/r_main.c index 8a975498d..a74be33d8 100644 --- a/src/r_main.c +++ b/src/r_main.c @@ -213,7 +213,7 @@ consvar_t cv_homremoval = {"homremoval", "Yes", CV_SAVE, homremoval_cons_t, NULL consvar_t cv_maxportals = {"maxportals", "2", CV_SAVE, maxportals_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL}; static CV_PossibleValue_t pointoangle_cons_t[] = {{0, "Ex"}, {1, "64"}, {0, NULL}}; -consvar_t cv_pointoangleexor64 = {"r_pointtoangle", "Ex", CV_SAVE, pointoangle_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL}; +consvar_t cv_pointoangleexor64 = {"r_pointtoangle", "64", CV_SAVE, pointoangle_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL}; void SplitScreen_OnChange(void) { From 1457000f81d02c527562c3e8af28c34544a292b0 Mon Sep 17 00:00:00 2001 From: Alug Date: Wed, 13 Mar 2024 09:57:05 +0100 Subject: [PATCH 09/11] remove xs_CRoundToInt while ye, less exact stuff doesent matter too much in the context of doom, it matters more in kart, due to polygon rendering and seg processing being extremely heavy and also generally more complex maps --- src/hardware/hw_clip.c | 2 +- src/m_fixed.h | 35 ----------------------------------- 2 files changed, 1 insertion(+), 36 deletions(-) diff --git a/src/hardware/hw_clip.c b/src/hardware/hw_clip.c index be8b21dcd..de27433c4 100644 --- a/src/hardware/hw_clip.c +++ b/src/hardware/hw_clip.c @@ -339,7 +339,7 @@ angle_t gld_FrustumAngle(angle_t tiltangle) floatangle = 2.0f + (45.0f + (tilt / 1.9f)) * clipfov / 90.0f; if (floatangle >= 180.0) return 0xffffffff; - a1 = (angle_t)xs_CRoundToInt(ANG1 * floatangle); + a1 = ANG1 * (int)floatangle; return a1; } diff --git a/src/m_fixed.h b/src/m_fixed.h index 9fe35c91d..4e4c79c65 100644 --- a/src/m_fixed.h +++ b/src/m_fixed.h @@ -260,41 +260,6 @@ typedef struct fixed_t y; } vector2_t; -// Source: "Know Your FPU: Fixing Floating Fast" -// http://www.stereopsis.com/sree/fpu2006.html -// -// xs_CRoundToInt: Round toward nearest, but ties round toward even (just like FISTP) -// taken from prboom+ for OpenGL big room fix -#ifndef _xs_DEFAULT_CONVERSION -#define _xs_DEFAULT_CONVERSION 0 -#endif //_xs_DEFAULT_CONVERSION - -#ifdef WORDS_BIGENDIAN - #define _xs_iexp_ 0 - #define _xs_iman_ 1 -#else - #define _xs_iexp_ 1 //intel is little endian - #define _xs_iman_ 0 -#endif //BigEndian_ - -typedef double real64; -typedef union _xs_doubleints -{ - real64 val; - unsigned ival[2]; -} _xs_doubleints; - -FUNCMATH FUNCINLINE ATTRINLINE int xs_CRoundToInt(real64 val) -{ -#if _xs_DEFAULT_CONVERSION==0 - _xs_doubleints uval; - uval.val = val + 6755399441055744.0; - return uval.ival[_xs_iman_]; -#else - return int(floor(val+.5)); -#endif -} - vector2_t *FV2_Load(vector2_t *vec, fixed_t x, fixed_t y); vector2_t *FV2_UnLoad(vector2_t *vec, fixed_t *x, fixed_t *y); vector2_t *FV2_Copy(vector2_t *a_o, const vector2_t *a_i); From c96b51d3190b38a1e74d6a4bfd5fcec12ef07308 Mon Sep 17 00:00:00 2001 From: Alug Date: Wed, 13 Mar 2024 10:07:51 +0100 Subject: [PATCH 10/11] forgor menu stuff --- src/m_menu.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/m_menu.c b/src/m_menu.c index a9cac9ecd..7fc8c98bf 100644 --- a/src/m_menu.c +++ b/src/m_menu.c @@ -4340,7 +4340,6 @@ void M_Init(void) if (rendermode == render_opengl) { - OP_ExpOptionsMenu[op_exp_angleshit].status = IT_DISABLED; OP_ExpOptionsMenu[op_exp_ffclip].status = IT_DISABLED; OP_ExpOptionsMenu[op_exp_sprclip].status = IT_DISABLED; } From 3b5f9dd55af965eafd522125a7e0b8093fbaca7d Mon Sep 17 00:00:00 2001 From: Alug Date: Wed, 13 Mar 2024 10:16:07 +0100 Subject: [PATCH 11/11] clean up --- src/hardware/hw_clip.c | 3 --- 1 file changed, 3 deletions(-) diff --git a/src/hardware/hw_clip.c b/src/hardware/hw_clip.c index de27433c4..926f68fc6 100644 --- a/src/hardware/hw_clip.c +++ b/src/hardware/hw_clip.c @@ -324,8 +324,6 @@ angle_t gld_FrustumAngle(angle_t tiltangle) float tilt = (float)fabs(((double)(int)tiltangle) / ANG1); - // NEWCLIP TODO: SRB2CBTODO: make a global render_fov for this function - if (tilt > 90.0f) tilt = 90.0f; @@ -344,7 +342,6 @@ angle_t gld_FrustumAngle(angle_t tiltangle) } - // SRB2CB I don't think used any of this stuff, let's disable for now since SRB2 probably doesn't want it either // compiler complains about (p)glGetFloatv anyway, in case anyone wants this // only r_opengl.c can use the base gl funcs as it turns out, that's a problem for whoever wants sphere frustum checks