actually move stuff back to hw_clip lmao

This commit is contained in:
Alug committed 2024-03-11 02:15:43 +01:00
1 parent 8ec7e23217
commit e77453e43a
3 files changed
+279 -281

No files matched your search

+276 -6
View File
@@ -68,16 +68,282 @@
**
*/
#include <math.h>
#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] + \
+1 -275
View File
@@ -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
+2
View File
@@ -123,6 +123,8 @@ extern GLint maximumAnisotropy;
extern INT32 oglflags;
extern GLint textureformatGL;
extern GLfloat projMatrix[16];
typedef enum
{
GLF_NOZBUFREAD = 0x01,