ubergames/ef2gamesource
0
0
Fork 0
mirror of https://github.com/UberGames/EF2GameSource.git synced 2024-11-10 06:31:42 +00:00
Code Issues Projects Releases Packages Wiki Activity
ef2gamesource/dlls/game/debuglines.cpp
Walter Julius Hennecke 5bbf27cabd Initial code commit ...
2012-12-30 17:37:54 +01:00

809 lines
15 KiB
C++
Raw Blame History

//-----------------------------------------------------------------------------
//
// $Logfile:: /Code/DLLs/game/debuglines.cpp $
// $Revision:: 7 $
// $Date:: 10/13/03 8:53a $
//
// Copyright (C) 1999 by Ritual Entertainment, Inc.
// All rights reserved.
//
// This source is may not be distributed and/or modified without
// expressly written permission by Ritual Entertainment, Inc.
//
//
// DESCRIPTION:
//
#include "_pch_cpp.h"
//#include "g_local.h"
#include "debuglines.h"
#define NUM_CIRCLE_SEGMENTS 24
debugline_t *DebugLines = NULL;
Vector currentVertex( 0.0f, 0.0f, 0.0f );
Vector vertColor( 1.0f, 1.0f, 1.0f );
float vertAlpha = 1.0f;
float vertexIndex = 0.0f;
float linewidth = 1.0f;
unsigned short lineStippleFactor = 1;
unsigned short linePattern = 0xffff;
void G_InitDebugLines
(
void
)
{
*gi.DebugLines = DebugLines;
*gi.numDebugLines = 0;
currentVertex = vec_zero;
vertColor = Vector( 1, 1, 1 );
vertAlpha = 1;
vertexIndex = 0;
linewidth = 1;
lineStippleFactor = 1;
linePattern = 0xffff;
}
void G_AllocDebugLines
(
void
)
{
// we do a malloc here so that we don't interfere with the game's memory footprint
DebugLines = ( debugline_t * )malloc( ( int )g_numdebuglines->integer * sizeof( debugline_t ) );
G_InitDebugLines();
}
void G_DeAllocDebugLines
(
void
)
{
if ( DebugLines )
{
// we do a free here, because we used malloc above
free( DebugLines );
DebugLines = NULL;
*gi.DebugLines = DebugLines;
*gi.numDebugLines = 0;
}
}
void G_DebugLine
(
const Vector &start,
const Vector &end,
float r,
float g,
float b,
float alpha
)
{
debugline_t *line;
if ( !g_numdebuglines )
{
return;
}
if ( *gi.numDebugLines >= g_numdebuglines->integer )
{
gi.DPrintf( "G_DebugLine: Exceeded MAX_DEBUG_LINES\n" );
return;
}
line = &DebugLines[ *gi.numDebugLines ];
( *gi.numDebugLines )++;
VectorCopy( start, line->start );
VectorCopy( end, line->end );
VectorSet( line->color, r, g, b );
line->alpha = alpha;
line->width = linewidth;
line->factor = lineStippleFactor;
line->pattern = linePattern;
}
void G_DebugLineC
(
const vec3_t start,
const vec3_t end,
float r,
float g,
float b,
float alpha
)
{
debugline_t *line;
if ( !g_numdebuglines )
{
return;
}
if ( *gi.numDebugLines >= g_numdebuglines->integer )
{
gi.DPrintf( "G_DebugLine: Exceeded MAX_DEBUG_LINES\n" );
return;
}
line = &DebugLines[ *gi.numDebugLines ];
( *gi.numDebugLines )++;
VectorCopy( start, line->start );
VectorCopy( end, line->end );
VectorSet( line->color, r, g, b );
line->alpha = alpha;
line->width = linewidth;
line->factor = lineStippleFactor;
line->pattern = linePattern;
}
void G_LineStipple
(
int factor,
unsigned short pattern
)
{
lineStippleFactor = factor;
linePattern = pattern;
}
void G_LineWidth
(
float width
)
{
linewidth = width;
}
void G_Color3f
(
float r,
float g,
float b
)
{
vertColor = Vector( r, g, b );
}
void G_Color3v
(
const Vector &color
)
{
vertColor = color;
}
void G_Color4f
(
float r,
float g,
float b,
float alpha
)
{
vertColor = Vector( r, g, b );
vertAlpha = alpha;
}
void G_Color3vf
(
const Vector &color,
float alpha
)
{
vertColor = color;
vertAlpha = alpha;
}
void G_BeginLine
(
void
)
{
currentVertex = vec_zero;
vertexIndex = 0;
}
void G_Vertex
(
const Vector &v
)
{
vertexIndex++;
if ( vertexIndex > 1.0f )
{
G_DebugLine( currentVertex, v, vertColor[ 0 ], vertColor[ 1 ], vertColor[ 2 ], vertAlpha );
}
currentVertex = v;
}
void G_EndLine
(
void
)
{
currentVertex = vec_zero;
vertexIndex = 0;
}
void G_DebugBBox
(
const Vector &org,
const Vector &mins,
const Vector &maxs,
float r,
float g,
float b,
float alpha
)
{
int i;
Vector points[8];
/*
** compute a full bounding box
*/
for ( i = 0; i < 8; i++ )
{
Vector tmp;
if ( i & 1 )
tmp[0] = org[0] + mins[0];
else
tmp[0] = org[0] + maxs[0];
if ( i & 2 )
tmp[1] = org[1] + mins[1];
else
tmp[1] = org[1] + maxs[1];
if ( i & 4 )
tmp[2] = org[2] + mins[2];
else
tmp[2] = org[2] + maxs[2];
points[i] = tmp;
}
G_Color4f( r, g, b, alpha );
G_BeginLine();
G_Vertex( points[0] );
G_Vertex( points[1] );
G_Vertex( points[3] );
G_Vertex( points[2] );
G_Vertex( points[0] );
G_EndLine();
G_BeginLine();
G_Vertex( points[4] );
G_Vertex( points[5] );
G_Vertex( points[7] );
G_Vertex( points[6] );
G_Vertex( points[4] );
G_EndLine();
for ( i = 0; i < 4; i++ )
{
G_BeginLine();
G_Vertex( points[i] );
G_Vertex( points[4 + i] );
G_EndLine();
}
}
//
// LED style digits
//
// ****1***
// * * 8 == /
// 6 *4
// * * *
// ****2***
// * * *
// 7 *--8 5 9
// ** * **10
// ****3*** 12**
// 11
static int Numbers[ 12 ][ 8 ] =
{
{ 1, 3, 4, 5, 6, 7, 0, 0 }, // 0
{ 4, 5, 0, 0, 0, 0, 0, 0 }, // 1
{ 1, 4, 2, 7, 3, 0, 0, 0 }, // 2
{ 1, 4, 2, 5, 3, 0, 0, 0 }, // 3
{ 6, 4, 2, 5, 0, 0, 0, 0 }, // 4
{ 1, 6, 2, 5, 3, 0, 0, 0 }, // 5
{ 1, 6, 2, 5, 7, 3, 0, 0 }, // 6
{ 1, 8, 0, 0, 0, 0, 0, 0 }, // 7
{ 1, 2, 3, 4, 5, 6, 7, 0 }, // 8
{ 1, 6, 4, 2, 5, 3, 0, 0 }, // 9
{ 9, 10, 11, 12, 0, 0, 0, 0 }, // .
{ 2, 0, 0, 0, 0, 0, 0, 0 }, // -
};
static float Lines[ 13 ][ 4 ] =
{
{ 0, 0, 0, 0 }, // Unused
{ -4, 8, 4, 8 }, // 1
{ -4, 4, 4, 4 }, // 2
{ -4, 0, 4, 0 }, // 3
{ 4, 8, 4, 4 }, // 4
{ 4, 4, 4, 0 }, // 5
{ -4, 8, -4, 4 }, // 6
{ -4, 4, -4, 0 }, // 7
{ 4, 8, -4, 0 }, // 8
{ -1, 2, 1, 2 }, // 9
{ 1, 2, 1, 0 }, // 10
{ -1, 0, 1, 0 }, // 11
{ -1, 0, -1, 2 }, // 12
};
void G_DrawDebugNumber
(
const Vector &org,
float number,
float scale,
float r,
float g,
float b,
int precision
)
{
int i;
int j;
int l;
int num;
Vector up;
Vector left;
Vector pos;
Vector start;
Vector ang;
str text;
Vector delta;
char format[ 20 ];
// only draw entity numbers within a certain radius
delta = Vector( g_entities[ 0 ].s.origin ) - org;
if ( ( delta * delta ) > ( 1000.0f * 1000.0f ) )
{
return;
}
G_Color4f( r, g, b, 1.0 );
ang = game.clients[ 0 ].ps.viewangles;
ang.AngleVectors( NULL, &left, &up );
up *= scale;
left *= scale;
if ( precision > 0 )
{
sprintf( format, "%%.%df", precision );
text = va( format, number );
}
else
{
text = va( "%d", ( int )number );
}
start = org + ( (float)( text.length() - 1 ) * 5.0f * left );
for( i = 0; i < text.length(); i++ )
{
if ( text[ i ] == '.' )
{
num = 10;
}
else if ( text[ i ] == '-' )
{
num = 11;
}
else
{
num = text[ i ] - '0';
}
for( j = 0; j < 8; j++ )
{
l = Numbers[ num ][ j ];
if ( l == 0 )
{
break;
}
G_BeginLine();
pos = start - ( Lines[ l ][ 0 ] * left ) + ( Lines[ l ][ 1 ] * up );
G_Vertex( pos );
pos = start - ( Lines[ l ][ 2 ] * left ) + ( Lines[ l ][ 3 ] * up );
G_Vertex( pos );
G_EndLine();
}
start -= 10.0f * left;
}
}
void G_DebugCircle
(
const Vector &org,
float radius,
float r,
float g,
float b,
float alpha,
qboolean horizontal
)
{
int i;
float ang;
Vector angles;
Vector forward;
Vector left;
Vector pos;
Vector delta;
// only draw circles within a certain radius
delta = Vector( g_entities[ 0 ].s.origin ) - org;
if ( ( delta * delta ) > ( ( 1000.0f + radius ) * ( 1000.0f + radius ) ) )
{
return;
}
G_Color4f( r, g, b, alpha );
if ( horizontal )
{
forward = Vector(1, 0, 0);
left = Vector(0, -1, 0);
}
else
{
angles = game.clients[ 0 ].ps.viewangles;
angles.AngleVectors( NULL, &left, &forward );
}
G_BeginLine();
for( i = 0; i <= NUM_CIRCLE_SEGMENTS; i++ )
{
ang = DEG2RAD( i * 360.0f / NUM_CIRCLE_SEGMENTS );
pos = org + ( sin( ang ) * radius * forward ) - ( cos( ang ) * radius * left );
G_Vertex( pos );
}
G_EndLine();
}
void G_DebugOrientedCircle
(
const Vector &org,
float radius,
float r,
float g,
float b,
float alpha,
Vector angles
)
{
int i;
float ang;
Vector forward;
Vector left;
Vector pos;
Vector delta;
// only draw circles within a certain radius
delta = Vector( g_entities[ 0 ].s.origin ) - org;
if ( ( delta * delta ) > ( ( 1000.0f + radius ) * ( 1000.0f + radius ) ) )
{
return;
}
G_Color4f( r, g, b, alpha );
angles.AngleVectors( NULL, &left, &forward );
G_BeginLine();
for( i = 0; i <= NUM_CIRCLE_SEGMENTS; i++ )
{
ang = DEG2RAD( i * 360.0f / NUM_CIRCLE_SEGMENTS );
pos = org + ( sin( ang ) * radius * forward ) - ( cos( ang ) * radius * left );
G_Vertex( pos );
}
G_EndLine();
//
// Draw the cross sign
//
G_BeginLine();
ang = DEG2RAD( 45.0f * 360.0f / NUM_CIRCLE_SEGMENTS );
pos = org + ( sin( ang ) * radius * forward ) - ( cos( ang ) * radius * left );
G_Vertex( pos );
ang = DEG2RAD( 225.0f * 360.0f / NUM_CIRCLE_SEGMENTS );
pos = org + ( sin( ang ) * radius * forward ) - ( cos( ang ) * radius * left );
G_Vertex( pos );
G_BeginLine();
ang = DEG2RAD( 315.0f * 360.0f / NUM_CIRCLE_SEGMENTS );
pos = org + ( sin( ang ) * radius * forward ) - ( cos( ang ) * radius * left );
G_Vertex( pos );
ang = DEG2RAD( 135.0f * 360.0f / NUM_CIRCLE_SEGMENTS );
pos = org + ( sin( ang ) * radius * forward ) - ( cos( ang ) * radius * left );
G_Vertex( pos );
}
void G_DebugPyramid
(
const Vector &org,
float radius,
float r,
float g,
float b,
float alpha
)
{
Vector delta;
Vector points[ 4 ];
// only draw pyramids within a certain radius
delta = Vector( g_entities[ 0 ].s.origin ) - org;
if ( ( delta * delta ) > ( ( 1000.0f + radius ) * ( 1000.0f + radius ) ) )
{
return;
}
G_Color4f( r, g, b, alpha );
points[ 0 ] = org;
points[ 0 ].z += radius;
points[ 1 ] = org;
points[ 1 ].z -= radius;
points[ 2 ] = points[ 1 ];
points[ 3 ] = points[ 1 ];
points[ 1 ].x += (float)cos( DEG2RAD( 0.0f ) ) * radius;
points[ 1 ].y += (float)sin( DEG2RAD( 0.0f ) ) * radius;
points[ 2 ].x += (float)cos( DEG2RAD( 120.0f ) ) * radius;
points[ 2 ].y += (float)sin( DEG2RAD( 120.0f ) ) * radius;
points[ 3 ].x += (float)cos( DEG2RAD( 240.0f ) ) * radius;
points[ 3 ].y += (float)sin( DEG2RAD( 240.0f ) ) * radius;
G_BeginLine();
G_Vertex( points[ 0 ] );
G_Vertex( points[ 1 ] );
G_Vertex( points[ 2 ] );
G_Vertex( points[ 0 ] );
G_EndLine();
G_BeginLine();
G_Vertex( points[ 0 ] );
G_Vertex( points[ 2 ] );
G_Vertex( points[ 3 ] );
G_Vertex( points[ 0 ] );
G_EndLine();
G_BeginLine();
G_Vertex( points[ 0 ] );
G_Vertex( points[ 3 ] );
G_Vertex( points[ 1 ] );
G_Vertex( points[ 0 ] );
G_EndLine();
G_BeginLine();
G_Vertex( points[ 1 ] );
G_Vertex( points[ 2 ] );
G_Vertex( points[ 3 ] );
G_Vertex( points[ 1 ] );
G_EndLine();
}
void G_DrawCoordSystem
(
const Vector &pos,
const Vector &forward,
const Vector &right,
const Vector &up,
int length
)
{
if ( g_showaxis->integer )
{
G_DebugLine( pos, pos + ( forward * length ), 1.0f, 0.0f, 0.0f, 1.0f );
G_DebugLine( pos, pos + ( right * length ), 0.0f, 1.0f, 0.0f, 1.0f );
G_DebugLine( pos, pos + ( up * length ), 0.0f, 0.0f, 1.0f, 1.0f );
}
}
void G_DrawCSystem
(
void
)
{
Vector pos;
Vector ang;
Vector f;
Vector l;
Vector u;
Vector v;
pos.x = csys_posx->value;
pos.y = csys_posy->value;
pos.z = csys_posz->value;
ang.x = csys_x->value;
ang.y = csys_y->value;
ang.z = csys_z->value;
ang.AngleVectors( &f, &l, &u );
G_DebugLine( pos, pos + ( f * 48 ), 1.0f, 0.0f, 0.0f, 1.0f );
G_DebugLine( pos, pos - ( l * 48 ), 0.0f, 1.0f, 0.0f, 1.0f );
G_DebugLine( pos, pos + ( u * 48 ), 0.0f, 0.0f, 1.0f, 1.0f );
}
void G_DebugArrow
(
const Vector &org,
const Vector &dir,
float length,
float r,
float g,
float b,
float alpha
)
{
Vector right;
Vector up;
Vector startpoint;
Vector endpoint;
PerpendicularVector( right, ( Vector )dir );
up.CrossProduct( right, dir );
startpoint = org;
endpoint = startpoint + ( dir * length );
length /= 6.0f;
G_DebugLine( startpoint, endpoint, r, g, b, alpha );
G_DebugLine( endpoint, endpoint - (right * length) - (dir * length), r, g, b, alpha );
G_DebugLine( endpoint, endpoint + (right * length) - (dir * length), r, g, b, alpha );
G_DebugLine( endpoint, endpoint - (up * length) - (dir * length), r, g, b, alpha );
G_DebugLine( endpoint, endpoint + (up * length) - (dir * length), r, g, b, alpha );
}
void G_DebugHighlightFacet
(
const Vector &org,
const Vector &mins,
const Vector &maxs,
facet_t facet,
float r,
float g,
float b,
float alpha
)
{
int i;
Vector points[8];
/*
** compute a full bounding box
*/
for ( i = 0; i < 8; i++ )
{
Vector tmp;
if ( i & 1 )
tmp[0] = org[0] + mins[0];
else
tmp[0] = org[0] + maxs[0];
if ( i & 2 )
tmp[1] = org[1] + mins[1];
else
tmp[1] = org[1] + maxs[1];
if ( i & 4 )
tmp[2] = org[2] + mins[2];
else
tmp[2] = org[2] + maxs[2];
points[i] = tmp;
}
G_Color4f( r, g, b, alpha );
switch( facet )
{
case facet_north:
G_BeginLine();
G_Vertex( points[0] );
G_Vertex( points[5] );
G_EndLine();
G_BeginLine();
G_Vertex( points[1] );
G_Vertex( points[4] );
G_EndLine();
break;
case facet_south:
G_BeginLine();
G_Vertex( points[2] );
G_Vertex( points[7] );
G_EndLine();
G_BeginLine();
G_Vertex( points[3] );
G_Vertex( points[6] );
G_EndLine();
break;
case facet_east:
G_BeginLine();
G_Vertex( points[0] );
G_Vertex( points[6] );
G_EndLine();
G_BeginLine();
G_Vertex( points[4] );
G_Vertex( points[2] );
G_EndLine();
break;
case facet_west:
G_BeginLine();
G_Vertex( points[1] );
G_Vertex( points[7] );
G_EndLine();
G_BeginLine();
G_Vertex( points[5] );
G_Vertex( points[3] );
G_EndLine();
break;
case facet_up:
G_BeginLine();
G_Vertex( points[0] );
G_Vertex( points[3] );
G_EndLine();
G_BeginLine();
G_Vertex( points[1] );
G_Vertex( points[2] );
G_EndLine();
break;
case facet_down:
G_BeginLine();
G_Vertex( points[4] );
G_Vertex( points[7] );
G_EndLine();
G_BeginLine();
G_Vertex( points[5] );
G_Vertex( points[6] );
G_EndLine();
break;
}
}
Reference in a new issue View git blame Copy permalink