Half-Life-RTX/xash3d-fwgs
1
0
Fork 0
mirror of https://github.com/w23/xash3d-fwgs synced 2025-01-18 23:00:01 +01:00
Code Issues Projects Releases Wiki Activity

ref: gl: cleanup unused functions in frustum

Browse Source
This commit is contained in:
Alibek Omarov 2023-04-03 05:05:18 +03:00
parent fd795d5612
commit 550ced9c36
5 changed files with 0 additions and 235 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

43
public/xash3d_mathlib.c
View File

@ -183,49 +183,6 @@ int PlaneTypeForNormal( const vec3_t normal )
return PLANE_NONAXIAL;
}
/*
=================
PlanesGetIntersectionPoint
=================
*/
qboolean PlanesGetIntersectionPoint( const mplane_t *plane1, const mplane_t *plane2, const mplane_t *plane3, vec3_t out )
{
vec3_t n1, n2, n3;
vec3_t n1n2, n2n3, n3n1;
float denom;
VectorNormalize2( plane1->normal, n1 );
VectorNormalize2( plane2->normal, n2 );
VectorNormalize2( plane3->normal, n3 );
CrossProduct( n1, n2, n1n2 );
CrossProduct( n2, n3, n2n3 );
CrossProduct( n3, n1, n3n1 );
denom = DotProduct( n1, n2n3 );
VectorClear( out );
// check if the denominator is zero (which would mean that no intersection is to be found
if( denom == 0.0f )
{
// no intersection could be found, return <0,0,0>
return false;
}
// compute intersection point
#if 0
VectorMAMAM( plane1->dist, n2n3, plane2->dist, n3n1, plane3->dist, n1n2, out );
#else
VectorMA( out, plane1->dist, n2n3, out );
VectorMA( out, plane2->dist, n3n1, out );
VectorMA( out, plane3->dist, n1n2, out );
#endif
VectorScale( out, ( 1.0f / denom ), out );
return true;
}
/*
=================
NearestPOW

1
public/xash3d_mathlib.h
View File

@ -188,7 +188,6 @@ void VectorVectors( const vec3_t forward, vec3_t right, vec3_t up );
void VectorAngles( const float *forward, float *angles );
void AngleVectors( const vec3_t angles, vec3_t forward, vec3_t right, vec3_t up );
void VectorsAngles( const vec3_t forward, const vec3_t right, const vec3_t up, vec3_t angles );
qboolean PlanesGetIntersectionPoint( const struct mplane_s *plane1, const struct mplane_s *plane2, const struct mplane_s *plane3, vec3_t out );
void PlaneIntersect( const struct mplane_s *plane, const vec3_t p0, const vec3_t p1, vec3_t out );
void ClearBounds( vec3_t mins, vec3_t maxs );

12
ref/gl/gl_cull.c
View File

@ -35,18 +35,6 @@ qboolean R_CullBox( const vec3_t mins, const vec3_t maxs )
return GL_FrustumCullBox( &RI.frustum, mins, maxs, 0 );
}
/*
=================
R_CullSphere
Returns true if the sphere is completely outside the frustum
=================
*/
qboolean R_CullSphere( const vec3_t centre, const float radius )
{
return GL_FrustumCullSphere( &RI.frustum, centre, radius, 0 );
}
/*
=============
R_CullModel

169
ref/gl/gl_frustum.c
View File

@ -16,21 +16,6 @@ GNU General Public License for more details.
#include "gl_local.h"
#include "xash3d_mathlib.h"
void GL_FrustumEnablePlane( gl_frustum_t *out, int side )
{
Assert( side >= 0 && side < FRUSTUM_PLANES );
// make sure what plane is ready
if( !VectorIsNull( out->planes[side].normal ))
SetBits( out->clipFlags, BIT( side ));
}
void GL_FrustumDisablePlane( gl_frustum_t *out, int side )
{
Assert( side >= 0 && side < FRUSTUM_PLANES );
ClearBits( out->clipFlags, BIT( side ));
}
void GL_FrustumSetPlane( gl_frustum_t *out, int side, const vec3_t vecNormal, float flDist )
{
Assert( side >= 0 && side < FRUSTUM_PLANES );
@ -43,30 +28,6 @@ void GL_FrustumSetPlane( gl_frustum_t *out, int side, const vec3_t vecNormal, fl
SetBits( out->clipFlags, BIT( side ));
}
void GL_FrustumNormalizePlane( gl_frustum_t *out, int side )
{
float length;
Assert( side >= 0 && side < FRUSTUM_PLANES );
// normalize
length = VectorLength( out->planes[side].normal );
if( length )
{
float ilength = (1.0f / length);
out->planes[side].normal[0] *= ilength;
out->planes[side].normal[1] *= ilength;
out->planes[side].normal[2] *= ilength;
out->planes[side].dist *= ilength;
}
out->planes[side].type = PlaneTypeForNormal( out->planes[side].normal );
out->planes[side].signbits = SignbitsForPlane( out->planes[side].normal );
SetBits( out->clipFlags, BIT( side ));
}
void GL_FrustumInitProj( gl_frustum_t *out, float flZNear, float flZFar, float flFovX, float flFovY )
{
float xs, xc;
@ -135,136 +96,6 @@ void GL_FrustumInitOrtho( gl_frustum_t *out, float xLeft, float xRight, float yT
GL_FrustumSetPlane( out, FRUSTUM_BOTTOM, iup, -yBottom - orgOffset );
}
void GL_FrustumInitBox( gl_frustum_t *out, const vec3_t org, float radius )
{
vec3_t normal;
int i;
for( i = 0; i < FRUSTUM_PLANES; i++ )
{
// setup normal for each direction
VectorClear( normal );
normal[((i >> 1) + 1) % 3] = (i & 1) ? 1.0f : -1.0f;
GL_FrustumSetPlane( out, i, normal, DotProduct( org, normal ) - radius );
}
}
void GL_FrustumInitProjFromMatrix( gl_frustum_t *out, const matrix4x4 projection )
{
int i;
// left
out->planes[FRUSTUM_LEFT].normal[0] = projection[0][3] + projection[0][0];
out->planes[FRUSTUM_LEFT].normal[1] = projection[1][3] + projection[1][0];
out->planes[FRUSTUM_LEFT].normal[2] = projection[2][3] + projection[2][0];
out->planes[FRUSTUM_LEFT].dist = -(projection[3][3] + projection[3][0]);
// right
out->planes[FRUSTUM_RIGHT].normal[0] = projection[0][3] - projection[0][0];
out->planes[FRUSTUM_RIGHT].normal[1] = projection[1][3] - projection[1][0];
out->planes[FRUSTUM_RIGHT].normal[2] = projection[2][3] - projection[2][0];
out->planes[FRUSTUM_RIGHT].dist = -(projection[3][3] - projection[3][0]);
// bottom
out->planes[FRUSTUM_BOTTOM].normal[0] = projection[0][3] + projection[0][1];
out->planes[FRUSTUM_BOTTOM].normal[1] = projection[1][3] + projection[1][1];
out->planes[FRUSTUM_BOTTOM].normal[2] = projection[2][3] + projection[2][1];
out->planes[FRUSTUM_BOTTOM].dist = -(projection[3][3] + projection[3][1]);
// top
out->planes[FRUSTUM_TOP].normal[0] = projection[0][3] - projection[0][1];
out->planes[FRUSTUM_TOP].normal[1] = projection[1][3] - projection[1][1];
out->planes[FRUSTUM_TOP].normal[2] = projection[2][3] - projection[2][1];
out->planes[FRUSTUM_TOP].dist = -(projection[3][3] - projection[3][1]);
// near
out->planes[FRUSTUM_NEAR].normal[0] = projection[0][3] + projection[0][2];
out->planes[FRUSTUM_NEAR].normal[1] = projection[1][3] + projection[1][2];
out->planes[FRUSTUM_NEAR].normal[2] = projection[2][3] + projection[2][2];
out->planes[FRUSTUM_NEAR].dist = -(projection[3][3] + projection[3][2]);
// far
out->planes[FRUSTUM_FAR].normal[0] = projection[0][3] - projection[0][2];
out->planes[FRUSTUM_FAR].normal[1] = projection[1][3] - projection[1][2];
out->planes[FRUSTUM_FAR].normal[2] = projection[2][3] - projection[2][2];
out->planes[FRUSTUM_FAR].dist = -(projection[3][3] - projection[3][2]);
for( i = 0; i < FRUSTUM_PLANES; i++ )
{
GL_FrustumNormalizePlane( out, i );
}
}
void GL_FrustumComputeCorners( gl_frustum_t *out, vec3_t corners[8] )
{
memset( corners, 0, sizeof( vec3_t ) * 8 );
PlanesGetIntersectionPoint( &out->planes[FRUSTUM_LEFT], &out->planes[FRUSTUM_TOP], &out->planes[FRUSTUM_FAR], corners[0] );
PlanesGetIntersectionPoint( &out->planes[FRUSTUM_RIGHT], &out->planes[FRUSTUM_TOP], &out->planes[FRUSTUM_FAR], corners[1] );
PlanesGetIntersectionPoint( &out->planes[FRUSTUM_LEFT], &out->planes[FRUSTUM_BOTTOM], &out->planes[FRUSTUM_FAR], corners[2] );
PlanesGetIntersectionPoint( &out->planes[FRUSTUM_RIGHT], &out->planes[FRUSTUM_BOTTOM], &out->planes[FRUSTUM_FAR], corners[3] );
if( FBitSet( out->clipFlags, BIT( FRUSTUM_NEAR )))
{
PlanesGetIntersectionPoint( &out->planes[FRUSTUM_LEFT], &out->planes[FRUSTUM_TOP], &out->planes[FRUSTUM_NEAR], corners[4] );
PlanesGetIntersectionPoint( &out->planes[FRUSTUM_RIGHT], &out->planes[FRUSTUM_TOP], &out->planes[FRUSTUM_NEAR], corners[5] );
PlanesGetIntersectionPoint( &out->planes[FRUSTUM_LEFT], &out->planes[FRUSTUM_BOTTOM], &out->planes[FRUSTUM_NEAR], corners[6] );
PlanesGetIntersectionPoint( &out->planes[FRUSTUM_RIGHT], &out->planes[FRUSTUM_BOTTOM], &out->planes[FRUSTUM_NEAR], corners[7] );
}
else
{
PlanesGetIntersectionPoint( &out->planes[FRUSTUM_LEFT], &out->planes[FRUSTUM_RIGHT], &out->planes[FRUSTUM_TOP], corners[4] );
VectorCopy( corners[4], corners[5] );
VectorCopy( corners[4], corners[6] );
VectorCopy( corners[4], corners[7] );
}
}
void GL_FrustumComputeBounds( gl_frustum_t *out, vec3_t mins, vec3_t maxs )
{
vec3_t corners[8];
int i;
GL_FrustumComputeCorners( out, corners );
ClearBounds( mins, maxs );
for( i = 0; i < 8; i++ )
AddPointToBounds( corners[i], mins, maxs );
}
void GL_FrustumDrawDebug( gl_frustum_t *out )
{
vec3_t bbox[8];
int i;
GL_FrustumComputeCorners( out, bbox );
// g-cont. frustum must be yellow :-)
pglColor4f( 1.0f, 1.0f, 0.0f, 1.0f );
pglDisable( GL_TEXTURE_2D );
pglBegin( GL_LINES );
for( i = 0; i < 2; i += 1 )
{
pglVertex3fv( bbox[i+0] );
pglVertex3fv( bbox[i+2] );
pglVertex3fv( bbox[i+4] );
pglVertex3fv( bbox[i+6] );
pglVertex3fv( bbox[i+0] );
pglVertex3fv( bbox[i+4] );
pglVertex3fv( bbox[i+2] );
pglVertex3fv( bbox[i+6] );
pglVertex3fv( bbox[i*2+0] );
pglVertex3fv( bbox[i*2+1] );
pglVertex3fv( bbox[i*2+4] );
pglVertex3fv( bbox[i*2+5] );
}
pglEnd();
pglEnable( GL_TEXTURE_2D );
}
// cull methods
qboolean GL_FrustumCullBox( gl_frustum_t *out, const vec3_t mins, const vec3_t maxs, int userClipFlags )
{

10
ref/gl/gl_frustum.h
View File

@ -33,20 +33,10 @@ typedef struct gl_frustum_s
void GL_FrustumInitProj( gl_frustum_t *out, float flZNear, float flZFar, float flFovX, float flFovY );
void GL_FrustumInitOrtho( gl_frustum_t *out, float xLeft, float xRight, float yTop, float yBottom, float flZNear, float flZFar );
void GL_FrustumInitBox( gl_frustum_t *out, const vec3_t org, float radius ); // used for pointlights
void GL_FrustumInitProjFromMatrix( gl_frustum_t *out, const matrix4x4 projection );
void GL_FrustumSetPlane( gl_frustum_t *out, int side, const vec3_t vecNormal, float flDist );
void GL_FrustumNormalizePlane( gl_frustum_t *out, int side );
void GL_FrustumComputeBounds( gl_frustum_t *out, vec3_t mins, vec3_t maxs );
void GL_FrustumComputeCorners( gl_frustum_t *out, vec3_t bbox[8] );
void GL_FrustumDrawDebug( gl_frustum_t *out );
// cull methods
qboolean GL_FrustumCullBox( gl_frustum_t *out, const vec3_t mins, const vec3_t maxs, int userClipFlags );
qboolean GL_FrustumCullSphere( gl_frustum_t *out, const vec3_t centre, float radius, int userClipFlags );
// plane manipulating
void GL_FrustumEnablePlane( gl_frustum_t *out, int side );
void GL_FrustumDisablePlane( gl_frustum_t *out, int side );
#endif//GL_FRUSTUM_H