1126 lines
36 KiB
C++
1126 lines
36 KiB
C++
// Copyright (C) 2007 Id Software, Inc.
|
|
//
|
|
|
|
|
|
#include "../precompiled.h"
|
|
#pragma hdrstop
|
|
|
|
|
|
#if defined( _DEBUG ) && !defined( ID_REDIRECT_NEWDELETE )
|
|
#define new DEBUG_NEW
|
|
#undef THIS_FILE
|
|
static char THIS_FILE[] = __FILE__;
|
|
#endif
|
|
|
|
#include "UserInterfaceManager.h"
|
|
#include "UIWindow.h"
|
|
#include "UICrosshairInfo.h"
|
|
#include "UserInterfaceLocal.h"
|
|
#include "../CrosshairInfo.h"
|
|
#include "../Player.h"
|
|
#include "../misc/WorldToScreen.h"
|
|
#include "../script/Script_Helper.h"
|
|
#include "../roles/WayPointManager.h"
|
|
#include "../ContentMask.h"
|
|
|
|
#include "../../sys/sys_local.h"
|
|
|
|
idCVar g_damageIndicatorFadeTime( "g_damageIndicatorFadeTime", "2.0", CVAR_FLOAT | CVAR_GAME | CVAR_NOCHEAT, "number of seconds that a damage indicator stays visible" );
|
|
idCVar g_damageIndicatorWidth( "g_damageIndicatorWidth", "256", CVAR_FLOAT | CVAR_GAME | CVAR_NOCHEAT, "width of the damage indicators" );
|
|
idCVar g_damageIndicatorHeight( "g_damageIndicatorHeight", "128", CVAR_FLOAT | CVAR_GAME | CVAR_NOCHEAT, "height of the damage indicators" );
|
|
idCVar g_damageIndicatorColor( "g_damageIndicatorColor", "1 0 0", CVAR_GAME | CVAR_NOCHEAT, "color of the damage indicators" );
|
|
idCVar g_damageIndicatorAlphaScale( "g_damageIndicatorAlphaScale", "0.3", CVAR_FLOAT | CVAR_GAME | CVAR_NOCHEAT, "alpha of the damage indicators" );
|
|
idCVar g_repairIndicatorColor( "g_repairIndicatorColor", "0 1 0", CVAR_GAME | CVAR_NOCHEAT, "color of the repair indicators" );
|
|
idCVar g_repairIndicatorAlphaScale( "g_repairIndicatorAlphaScale", "0.3", CVAR_FLOAT | CVAR_GAME | CVAR_NOCHEAT, "alpha of the repair indicators" );
|
|
idCVar g_waypointAlphaScale( "g_waypointAlphaScale", "0.7", CVAR_GAME | CVAR_FLOAT | CVAR_ARCHIVE | CVAR_PROFILE, "alpha to apply to world-based objective icons" );
|
|
idCVar g_showWayPoints( "g_showWayPoints", "1", CVAR_GAME | CVAR_BOOL | CVAR_ARCHIVE | CVAR_PROFILE, "show or hide world-based objective icons" );
|
|
idCVar g_waypointSizeMin( "g_waypointSizeMin", "16", CVAR_GAME | CVAR_FLOAT | CVAR_ARCHIVE | CVAR_PROFILE, "min world-view icon size" );
|
|
idCVar g_waypointSizeMax( "g_waypointSizeMax", "32", CVAR_GAME | CVAR_FLOAT | CVAR_ARCHIVE | CVAR_PROFILE, "max world-view icon size" );
|
|
idCVar g_waypointDistanceMin( "g_waypointDistanceMin", "512", CVAR_GAME | CVAR_FLOAT | CVAR_ARCHIVE | CVAR_PROFILE, "max distance at which to show min icon size" );
|
|
idCVar g_waypointDistanceMax( "g_waypointDistanceMax", "3084", CVAR_GAME | CVAR_FLOAT | CVAR_ARCHIVE | CVAR_PROFILE, "min distance at which to show max icon size" );
|
|
|
|
using namespace sdProperties;
|
|
|
|
const char sdUITemplateFunctionInstance_IdentifierCrosshairInfo[] = "sdUICrosshairInfoFunction";
|
|
idHashMap< sdUICrosshairInfo::CrosshairInfoTemplateFunction* > sdUICrosshairInfo::crosshairInfoFunctions;
|
|
|
|
const int sdUICrosshairInfo::lineTextScale = 12;
|
|
|
|
static const float HIGHLIGHT_TIME = 2000.0f;
|
|
|
|
|
|
/*
|
|
================
|
|
sdUICrosshairInfo::sdUICrosshairInfo
|
|
================
|
|
*/
|
|
sdUICrosshairInfo::sdUICrosshairInfo( void ) {
|
|
|
|
crosshairParts.SetNum( CP_MAX );
|
|
scriptState.GetProperties().RegisterProperty( "barMaterial", barMaterial );
|
|
scriptState.GetProperties().RegisterProperty( "barFillMaterial", barFillMaterial );
|
|
scriptState.GetProperties().RegisterProperty( "barLineMaterial", barLineMaterial );
|
|
scriptState.GetProperties().RegisterProperty( "barLineColor", barLineColor );
|
|
|
|
scriptState.GetProperties().RegisterProperty( "bracketBaseColor", bracketBaseColor );
|
|
scriptState.GetProperties().RegisterProperty( "bracketLeftMaterial", bracketLeftMaterial );
|
|
scriptState.GetProperties().RegisterProperty( "bracketRightMaterial", bracketRightMaterial );
|
|
scriptState.GetProperties().RegisterProperty( "damageMaterial", damageMaterial );
|
|
scriptState.GetProperties().RegisterProperty( "crosshairInfoFlags", crosshairInfoFlags );
|
|
|
|
barLineColor = colorWhite;
|
|
bracketBaseColor = colorWhite;
|
|
|
|
UI_ADD_STR_CALLBACK( barMaterial, sdUICrosshairInfo, OnBarMaterialChanged );
|
|
UI_ADD_STR_CALLBACK( barFillMaterial, sdUICrosshairInfo, OnBarFillMaterialChanged );
|
|
UI_ADD_STR_CALLBACK( barLineMaterial, sdUICrosshairInfo, OnBarLineMaterialChanged );
|
|
UI_ADD_STR_CALLBACK( bracketLeftMaterial, sdUICrosshairInfo, OnLeftBracketMaterialChanged );
|
|
UI_ADD_STR_CALLBACK( bracketRightMaterial, sdUICrosshairInfo, OnRightBracketMaterialChanged );
|
|
|
|
UI_ADD_STR_CALLBACK( damageMaterial, sdUICrosshairInfo, OnDamageMaterialChanged );
|
|
|
|
waypointTextFadeTime = 0;
|
|
bracketFadeTime = 0;
|
|
dockedIcons.SetNum( 6 );
|
|
}
|
|
|
|
/*
|
|
================
|
|
sdUICrosshairInfo::~sdUICrosshairInfo
|
|
================
|
|
*/
|
|
sdUICrosshairInfo::~sdUICrosshairInfo( void ) {
|
|
DisconnectGlobalCallbacks();
|
|
}
|
|
|
|
/*
|
|
============
|
|
sdUICrosshairInfo::GetRepeaterCrosshairInfo
|
|
============
|
|
*/
|
|
const sdCrosshairInfo& sdUICrosshairInfo::GetRepeaterCrosshairInfo( void ) {
|
|
return gameLocal.playerView.CalcRepeaterCrosshairInfo();
|
|
}
|
|
|
|
/*
|
|
============
|
|
sdUICrosshairInfo::DrawCrosshairInfo
|
|
============
|
|
*/
|
|
void sdUICrosshairInfo::DrawCrosshairInfo( idPlayer* player ) {
|
|
const float width = SCREEN_WIDTH * 1.0f / deviceContext->GetAspectRatioCorrection();
|
|
|
|
const sdCrosshairInfo& info = gameLocal.serverIsRepeater ? GetRepeaterCrosshairInfo() : player->GetCrosshairInfoDirect();
|
|
|
|
if( info.IsValid() && ( TestCrosshairInfoFlag( CF_CROSSHAIR ) || g_radialMenuStyle.GetInteger() == 1 ) ) {
|
|
float w, h;
|
|
idVec4 color;
|
|
|
|
idVec2 point( ( width * 0.5f ), ( SCREEN_HEIGHT * 0.5f ) + 30.0f );
|
|
|
|
for( int i = 0; i < info.GetNumLines(); i++ ) {
|
|
const chInfoLine_t& line = info.GetLine( i );
|
|
|
|
switch( line.type ) {
|
|
case CI_TEXT: {
|
|
sdBounds2D rect( 0.0f, point.y, width, lineTextHeight );
|
|
|
|
color = line.foreColor;
|
|
color[ 3 ] *= info.GetAlpha();
|
|
sdUIWindow::DrawText( line.text.c_str(), color, lineTextScale, rect, cachedFontHandle, DTF_CENTER | DTF_BOTTOM | DTF_SINGLELINE | DTF_DROPSHADOW );
|
|
|
|
point.y += lineTextHeight + 4.0f;
|
|
break;
|
|
}
|
|
case CI_BAR: {
|
|
w = line.xy.x;
|
|
h = line.xy.y;
|
|
|
|
color = borderColor;//line.backColor;
|
|
color[ 3 ] *= info.GetAlpha();
|
|
idVec4 rect( point.x - ( w * 0.5f ), point.y, w, h );
|
|
|
|
DrawThreeHorizontalParts( rect, color, vec2_one, crosshairParts[ CP_BAR_FILL_LEFT ], crosshairParts[ CP_BAR_FILL_CENTER ], crosshairParts[ CP_BAR_FILL_RIGHT ] );
|
|
|
|
color = line.foreColor;
|
|
color[ 3 ] *= info.GetAlpha();
|
|
|
|
sdBounds2D clipRect( rect.x, rect.y, rect.z * line.frac, rect.w );
|
|
|
|
deviceContext->PushClipRect( clipRect );
|
|
DrawHorizontalProgress( rect, color, vec2_one, crosshairParts[ CP_BAR_LEFT ], crosshairParts[ CP_BAR_CENTER ], crosshairParts[ CP_BAR_RIGHT ] );
|
|
deviceContext->PopClipRect();
|
|
|
|
color = barLineColor;
|
|
color[ 3 ] *= info.GetAlpha();
|
|
DrawThreeHorizontalParts( rect, color, vec2_one, crosshairParts[ CP_BAR_LINE_LEFT ], crosshairParts[ CP_BAR_LINE_CENTER ], crosshairParts[ CP_BAR_LINE_RIGHT ] );
|
|
|
|
point.y += h + 4.0f;
|
|
break;
|
|
}
|
|
case CI_IMAGE: {
|
|
|
|
color = line.foreColor;
|
|
color[ 3 ] *= info.GetAlpha();
|
|
|
|
deviceContext->DrawMaterial( point.x - ( line.xy.x * 0.5f ), point.y, line.xy.x, line.xy.y, line.material, color );
|
|
|
|
point.y += line.xy.y + 4.0f;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
============
|
|
sdUICrosshairInfo::DrawDamageIndicators
|
|
============
|
|
*/
|
|
void sdUICrosshairInfo::DrawDamageIndicators( idPlayer* player ) {
|
|
const float width = SCREEN_WIDTH * 1.0f / deviceContext->GetAspectRatioCorrection();
|
|
|
|
static idWinding2D drawWinding;
|
|
|
|
float w = g_damageIndicatorWidth.GetFloat();
|
|
float h = g_damageIndicatorHeight.GetFloat();
|
|
float x = -( w * 0.5f );
|
|
float y = -( h * 0.5f ) - g_damageIndicatorHeight.GetFloat();
|
|
|
|
float viewYaw = player->renderView.viewaxis.ToAngles().yaw;
|
|
|
|
float fadeTime = SEC2MS( g_damageIndicatorFadeTime.GetFloat() );
|
|
|
|
idMat2 matrix;
|
|
|
|
for( int i = 0; i < player->damageEvents.Num(); i++ ) {
|
|
const idPlayer::damageEvent_t& event = player->damageEvents[ i ];
|
|
if( event.hitTime <= 0 ) {
|
|
continue;
|
|
}
|
|
|
|
idVec4 color;
|
|
if ( event.hitDamage > 0 ) {
|
|
color.ToVec3() = sdTypeFromString< idVec3 >( g_damageIndicatorColor.GetString() );
|
|
} else {
|
|
color.ToVec3() = sdTypeFromString< idVec3 >( g_repairIndicatorColor.GetString() );
|
|
}
|
|
|
|
color.w = 1.0f - static_cast< float > ( gameLocal.time - event.hitTime ) / fadeTime;
|
|
if ( event.hitDamage > 0 ) {
|
|
color.w *= g_damageIndicatorAlphaScale.GetFloat();
|
|
} else {
|
|
color.w *= g_repairIndicatorAlphaScale.GetFloat();
|
|
}
|
|
if( color.w <= 0.0f || color.w > 1.0f ) {
|
|
continue;
|
|
}
|
|
|
|
uiDrawPart_t* part = NULL;
|
|
if( event.hitDamage <= 20.0f ) {
|
|
part = &crosshairParts[ CP_SMALL_DAMAGE ];
|
|
} else if( event.hitDamage <= 40.0f ) {
|
|
part = &crosshairParts[ CP_MEDIUM_DAMAGE ];
|
|
} else {
|
|
part = &crosshairParts[ CP_LARGE_DAMAGE ];
|
|
}
|
|
|
|
drawWinding.Clear();
|
|
|
|
drawWinding.AddPoint( x, y, part->mi.st0.x, part->mi.st0.y );
|
|
drawWinding.AddPoint( x + w, y, part->mi.st1.x, part->mi.st0.y );
|
|
drawWinding.AddPoint( x + w, y + h, part->mi.st1.x, part->mi.st1.y );
|
|
drawWinding.AddPoint( x, y + h, part->mi.st0.x, part->mi.st1.y );
|
|
|
|
float angle = event.hitAngle;
|
|
if ( event.updateDirection ) {
|
|
angle -= viewYaw;
|
|
}
|
|
matrix.Rotation( DEG2RAD( angle ) );
|
|
|
|
for( int i = 0; i < drawWinding.GetNumPoints(); i++ ) {
|
|
idVec2& pt = drawWinding[ i ];
|
|
pt *= matrix;
|
|
pt.x += width * 0.5f;
|
|
pt.y += SCREEN_HEIGHT * 0.5f;
|
|
}
|
|
|
|
deviceContext->DrawWindingMaterial( drawWinding, part->mi.material, color );
|
|
}
|
|
}
|
|
|
|
/*
|
|
============
|
|
sdUICrosshairInfo::DrawLocal
|
|
============
|
|
*/
|
|
void sdUICrosshairInfo::DrawLocal() {
|
|
if( g_showCrosshairInfo.GetInteger() != 1 ) {
|
|
return;
|
|
}
|
|
|
|
idPlayer* player = gameLocal.GetLocalViewPlayer();
|
|
if ( player == NULL ) {
|
|
if ( gameLocal.serverIsRepeater ) {
|
|
DrawCrosshairInfo( NULL );
|
|
}
|
|
return;
|
|
}
|
|
|
|
idEntity* entity = DrawContextEntity( player );
|
|
DrawWayPoints( entity );
|
|
DrawEntityIcons();
|
|
DrawPlayerIcons2D();
|
|
ClearInactiveDockIcons();
|
|
DrawDockedIcons();
|
|
DrawCrosshairInfo( player );
|
|
DrawDamageIndicators( player );
|
|
}
|
|
|
|
/*
|
|
============
|
|
sdUICrosshairInfo::ApplyLayout
|
|
============
|
|
*/
|
|
void sdUICrosshairInfo::ApplyLayout() {
|
|
if( windowState.recalculateLayout ) {
|
|
BeginLayout();
|
|
lineTextHeight = deviceContext->GetFontHeight( cachedFontHandle, lineTextScale );
|
|
EndLayout();
|
|
}
|
|
sdUIObject::ApplyLayout();
|
|
}
|
|
|
|
/*
|
|
============
|
|
sdUICrosshairInfo::FindFunction
|
|
============
|
|
*/
|
|
const sdUICrosshairInfo::CrosshairInfoTemplateFunction* sdUICrosshairInfo::FindFunction( const char* name ) {
|
|
sdUICrosshairInfo::CrosshairInfoTemplateFunction** ptr;
|
|
return crosshairInfoFunctions.Get( name, &ptr ) ? *ptr : NULL;
|
|
}
|
|
|
|
/*
|
|
============
|
|
sdUICrosshairInfo::GetFunction
|
|
============
|
|
*/
|
|
sdUIFunctionInstance* sdUICrosshairInfo::GetFunction( const char* name ) {
|
|
const CrosshairInfoTemplateFunction* function = sdUICrosshairInfo::FindFunction( name );
|
|
if ( !function ) {
|
|
return sdUIWindow::GetFunction( name );
|
|
}
|
|
return new sdUITemplateFunctionInstance< sdUICrosshairInfo, sdUITemplateFunctionInstance_IdentifierCrosshairInfo >( this, function );
|
|
}
|
|
|
|
/*
|
|
============
|
|
sdUICrosshairInfo::RunNamedMethod
|
|
============
|
|
*/
|
|
bool sdUICrosshairInfo::RunNamedMethod( const char* name, sdUIFunctionStack& stack ) {
|
|
const CrosshairInfoTemplateFunction* func = sdUICrosshairInfo::FindFunction( name );
|
|
if ( !func ) {
|
|
return sdUIWindow::RunNamedMethod( name, stack );
|
|
}
|
|
|
|
CALL_MEMBER_FN_PTR( this, func->GetFunction() )( stack );
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
============
|
|
sdUICrosshairInfo::InitFunctions
|
|
============
|
|
*/
|
|
void sdUICrosshairInfo::InitFunctions() {
|
|
sdDeclGUI::AddDefine( va( "CF_CROSSHAIR %i", CF_CROSSHAIR ) );
|
|
sdDeclGUI::AddDefine( va( "CF_PLAYER_ICONS %i", CF_PLAYER_ICONS ) );
|
|
sdDeclGUI::AddDefine( va( "CF_TASKS %i", CF_TASKS ) );
|
|
sdDeclGUI::AddDefine( va( "CF_OBJ_MIS %i", CF_OBJ_MIS ) );
|
|
}
|
|
|
|
/*
|
|
============
|
|
sdUICrosshairInfo::OnBarMaterialChanged
|
|
============
|
|
*/
|
|
void sdUICrosshairInfo::OnBarMaterialChanged( const idStr& oldValue, const idStr& newValue ) {
|
|
GetUI()->SetupPart( crosshairParts[ CP_BAR_LEFT ], "b", newValue );
|
|
GetUI()->SetupPart( crosshairParts[ CP_BAR_CENTER ], "c", newValue );
|
|
GetUI()->SetupPart( crosshairParts[ CP_BAR_RIGHT ], "e", newValue );
|
|
}
|
|
|
|
/*
|
|
============
|
|
sdUICrosshairInfo::OnBarFillMaterialChanged
|
|
============
|
|
*/
|
|
void sdUICrosshairInfo::OnBarFillMaterialChanged( const idStr& oldValue, const idStr& newValue ) {
|
|
GetUI()->SetupPart( crosshairParts[ CP_BAR_FILL_LEFT ], "l", newValue );
|
|
GetUI()->SetupPart( crosshairParts[ CP_BAR_FILL_CENTER ], "c", newValue );
|
|
GetUI()->SetupPart( crosshairParts[ CP_BAR_FILL_RIGHT ], "r", newValue );
|
|
}
|
|
|
|
/*
|
|
============
|
|
sdUICrosshairInfo::OnBarLineMaterialChanged
|
|
============
|
|
*/
|
|
void sdUICrosshairInfo::OnBarLineMaterialChanged( const idStr& oldValue, const idStr& newValue ) {
|
|
GetUI()->SetupPart( crosshairParts[ CP_BAR_LINE_LEFT ], "l", newValue );
|
|
GetUI()->SetupPart( crosshairParts[ CP_BAR_LINE_CENTER ], "c", newValue );
|
|
GetUI()->SetupPart( crosshairParts[ CP_BAR_LINE_RIGHT ], "r", newValue );
|
|
}
|
|
|
|
/*
|
|
============
|
|
sdUICrosshairInfo::EndLevelLoad
|
|
============
|
|
*/
|
|
void sdUICrosshairInfo::EndLevelLoad() {
|
|
sdUIWindow::EndLevelLoad();
|
|
sdUserInterfaceLocal::LookupPartSizes( crosshairParts.Begin(), crosshairParts.Num() );
|
|
}
|
|
|
|
/*
|
|
============
|
|
sdUICrosshairInfo::OnDamageMaterialChanged
|
|
============
|
|
*/
|
|
void sdUICrosshairInfo::OnDamageMaterialChanged( const idStr& oldValue, const idStr& newValue ) {
|
|
GetUI()->SetupPart( crosshairParts[ CP_SMALL_DAMAGE ], "s", newValue );
|
|
GetUI()->SetupPart( crosshairParts[ CP_MEDIUM_DAMAGE ], "m", newValue );
|
|
GetUI()->SetupPart( crosshairParts[ CP_LARGE_DAMAGE ], "l", newValue );
|
|
}
|
|
|
|
/*
|
|
============
|
|
sdUICrosshairInfo::OnLeftBracketMaterialChanged
|
|
============
|
|
*/
|
|
void sdUICrosshairInfo::OnLeftBracketMaterialChanged( const idStr& oldValue, const idStr& newValue ) {
|
|
GetUI()->SetupPart( crosshairParts[ CP_L_BRACKET_TOP ], "t", newValue );
|
|
GetUI()->SetupPart( crosshairParts[ CP_L_BRACKET_CENTER ], "c", newValue );
|
|
GetUI()->SetupPart( crosshairParts[ CP_L_BRACKET_BOTTOM ], "b", newValue );
|
|
}
|
|
|
|
/*
|
|
============
|
|
sdUICrosshairInfo::OnRightBracketMaterialChanged
|
|
============
|
|
*/
|
|
void sdUICrosshairInfo::OnRightBracketMaterialChanged( const idStr& oldValue, const idStr& newValue ) {
|
|
GetUI()->SetupPart( crosshairParts[ CP_R_BRACKET_TOP ], "t", newValue );
|
|
GetUI()->SetupPart( crosshairParts[ CP_R_BRACKET_CENTER ], "c", newValue );
|
|
GetUI()->SetupPart( crosshairParts[ CP_R_BRACKET_BOTTOM ], "b", newValue );
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
===============
|
|
sdUICrosshairInfo::DrawEntityIcons
|
|
==============
|
|
*/
|
|
void sdUICrosshairInfo::DrawEntityIcons( void ) {
|
|
idPlayer* viewPlayer = gameLocal.GetLocalViewPlayer();
|
|
if ( viewPlayer == NULL ) {
|
|
return;
|
|
}
|
|
|
|
// TODO: Add crosshair info flag like for player icons?
|
|
const float width = SCREEN_WIDTH * 1.0f / deviceContext->GetAspectRatioCorrection();
|
|
|
|
sdWorldToScreenConverter converter( gameLocal.playerView.GetCurrentView() );
|
|
|
|
// find out how many icons we need to draw
|
|
int numIcons = 0;
|
|
for ( idLinkList< idEntity >* node = gameLocal.GetIconEntities(); node; node = node->NextNode() ) {
|
|
idEntity* ent = node->Owner();
|
|
assert( ent->GetDisplayIconInterface() );
|
|
|
|
if ( ent->GetDisplayIconInterface()->HasIcon( viewPlayer, converter ) ) {
|
|
numIcons++;
|
|
}
|
|
}
|
|
|
|
if ( numIcons == 0 ) {
|
|
return;
|
|
}
|
|
|
|
// allocate temporary storage for the icons & fill them in
|
|
sdEntityDisplayIconInfo* icons = ( sdEntityDisplayIconInfo* )_alloca16( numIcons * sizeof( sdEntityDisplayIconInfo ) );
|
|
int iconUpto = 0;
|
|
for ( idLinkList< idEntity >* node = gameLocal.GetIconEntities(); node; node = node->NextNode() ) {
|
|
idEntity* ent = node->Owner();
|
|
assert( ent->GetDisplayIconInterface() );
|
|
|
|
if ( ent->GetDisplayIconInterface()->GetEntityDisplayIconInfo( viewPlayer, converter, icons[ iconUpto ] ) ) {
|
|
iconUpto++;
|
|
}
|
|
}
|
|
|
|
// sort them by distance
|
|
sdEntityDisplayIconInfo** sortedIcons = ( sdEntityDisplayIconInfo** )_alloca16( numIcons * sizeof( sdEntityDisplayIconInfo* ) );
|
|
for ( int i = 0; i < numIcons; i++ ) {
|
|
sortedIcons[ i ] = &icons[ i ];
|
|
}
|
|
|
|
sdQuickSort( sortedIcons, sortedIcons + numIcons, sdEntityDisplayIconInfo::SortByDistance );
|
|
|
|
// now we can draw
|
|
for ( int i = 0; i < numIcons; i++ ) {
|
|
sdEntityDisplayIconInfo* icon = sortedIcons[ i ];
|
|
|
|
bool draw = true;
|
|
|
|
const float MARGIN_OFFSET = ( width * 0.0125f );
|
|
const float LEFT_MARGIN = MARGIN_OFFSET;
|
|
const float RIGHT_MARGIN = width - MARGIN_OFFSET;
|
|
|
|
if ( icon->origin.x + icon->size.x <= LEFT_MARGIN || icon->origin.x - icon->size.x >= RIGHT_MARGIN ) {
|
|
draw = false;
|
|
}
|
|
|
|
if ( draw ) {
|
|
float height = icon->origin.y;
|
|
|
|
idVec2 screenPos( icon->origin.x - ( icon->size.x * 0.5f ), height - icon->size.y );
|
|
|
|
deviceContext->DrawMaterial( screenPos.x, screenPos.y, icon->size.x, icon->size.y, icon->material, icon->color );
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
===============
|
|
sdUICrosshairInfo::DrawPlayerIcons2D
|
|
==============
|
|
*/
|
|
void sdUICrosshairInfo::DrawPlayerIcons2D( void ) {
|
|
idPlayer* viewPlayer = gameLocal.GetLocalViewPlayer();
|
|
if ( viewPlayer == NULL ) {
|
|
return;
|
|
}
|
|
|
|
if ( viewPlayer->IsBeingBriefed() ) {
|
|
return;
|
|
}
|
|
|
|
if ( !TestCrosshairInfoFlag( CF_PLAYER_ICONS ) ) {
|
|
return;
|
|
}
|
|
|
|
const float width = SCREEN_WIDTH * 1.0f / deviceContext->GetAspectRatioCorrection();
|
|
|
|
sdWorldToScreenConverter converter( gameLocal.playerView.GetCurrentView() );
|
|
|
|
// fill the icons list up
|
|
sdPlayerDisplayIconList playerIcons;
|
|
for ( int i = 0; i < MAX_CLIENTS; i++ ) {
|
|
idPlayer* other = gameLocal.GetClient( i );
|
|
if ( other == NULL || other->IsInLimbo() ) {
|
|
continue;
|
|
}
|
|
|
|
if ( !pm_thirdPerson.GetBool() && viewPlayer == other ) {
|
|
continue;
|
|
}
|
|
|
|
sdPlayerDisplayIcon icon;
|
|
if ( other->GetPlayerIcon( viewPlayer, icon, converter ) ) {
|
|
playerIcons.Append( icon );
|
|
}
|
|
}
|
|
|
|
// sort the list by distance
|
|
sdPlayerDisplayIconPtrList sortedPlayerIcons;
|
|
sortedPlayerIcons.SetNum( playerIcons.Num() );
|
|
for ( int i = 0; i < playerIcons.Num(); i++ ) {
|
|
sortedPlayerIcons[ i ] = &playerIcons[ i ];
|
|
}
|
|
|
|
sortedPlayerIcons.Sort( sdPlayerDisplayIcon::SortByDistance );
|
|
|
|
for ( int i = 0; i < sortedPlayerIcons.Num(); i++ ) {
|
|
sdPlayerDisplayIcon* icon = sortedPlayerIcons[ i ];
|
|
|
|
bool draw = true;
|
|
|
|
const float HALF_ICON_WIDTH = icon->icon.size.x * 0.5f;
|
|
const float MARGIN_OFFSET = ( width * 0.0125f );
|
|
const float LEFT_MARGIN = MARGIN_OFFSET;
|
|
const float RIGHT_MARGIN = width - MARGIN_OFFSET;
|
|
|
|
sdBounds2D iconBounds;
|
|
iconBounds.Clear();
|
|
iconBounds.AddPoint( icon->icon.size * 0.5f );
|
|
iconBounds.AddPoint( icon->arrowIcon.size * 0.5f );
|
|
|
|
if ( icon->offScreenIcon.material != NULL ) {
|
|
if ( icon->origin.x - iconBounds.GetMaxs().x <= LEFT_MARGIN ) {
|
|
draw = false;
|
|
|
|
idVec2 startOrg( LEFT_MARGIN, icon->origin.y );
|
|
idVec2 endOrg( startOrg.x, SCREEN_HEIGHT * 0.5f );
|
|
|
|
MakeDockIcon( icon->player, true, startOrg, endOrg, icon->offScreenIcon, icon->icon );
|
|
} else if ( ( icon->origin.x + iconBounds.GetMaxs().x ) >= RIGHT_MARGIN ) {
|
|
draw = false;
|
|
|
|
idVec2 startOrg( RIGHT_MARGIN, icon->origin.y );
|
|
idVec2 endOrg( startOrg.x, SCREEN_HEIGHT * 0.5f );
|
|
|
|
MakeDockIcon( icon->player, false, startOrg, endOrg, icon->offScreenIcon, icon->icon );
|
|
}
|
|
} else {
|
|
if ( icon->origin.x <= LEFT_MARGIN || ( icon->origin.x + icon->icon.size.x ) >= RIGHT_MARGIN ) {
|
|
draw = false;
|
|
}
|
|
}
|
|
|
|
if ( draw ) {
|
|
float height = icon->origin.y;
|
|
if ( icon->arrowIcon.material != NULL ) {
|
|
idVec2 screenPos( icon->origin.x - ( icon->arrowIcon.size.x * 0.5f ), height - icon->arrowIcon.size.y );
|
|
|
|
deviceContext->DrawMaterial( screenPos.x, screenPos.y, icon->arrowIcon.size.x, icon->arrowIcon.size.y, icon->arrowIcon.material, icon->arrowIcon.color );
|
|
height -= icon->arrowIcon.size.y;
|
|
}
|
|
|
|
idVec2 screenPos( icon->origin.x - ( icon->icon.size.x * 0.5f ), height - icon->icon.size.y );
|
|
|
|
deviceContext->DrawMaterial( screenPos.x, screenPos.y, icon->icon.size.x, icon->icon.size.y, icon->icon.material, icon->icon.color );
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
============
|
|
sdUICrosshairInfo::DrawWayPoints
|
|
============
|
|
*/
|
|
void sdUICrosshairInfo::DrawWayPoints( idEntity* exclude ) {
|
|
|
|
if ( !g_showWayPoints.GetBool() && !sdWayPointManager::GetInstance().GetShowWayPoints() ) {
|
|
return;
|
|
}
|
|
|
|
if ( !TestCrosshairInfoFlag( CF_TASKS | CF_OBJ_MIS ) ) {
|
|
return;
|
|
}
|
|
|
|
idVec4 color = colorWhite;
|
|
|
|
idPlayer* localPlayer = gameLocal.GetLocalPlayer();
|
|
if ( localPlayer == NULL || localPlayer->IsSpectating() ) {
|
|
return;
|
|
}
|
|
|
|
idPlayer* viewPlayer = gameLocal.GetLocalViewPlayer();
|
|
if ( viewPlayer == NULL ) {
|
|
return;
|
|
}
|
|
|
|
if ( viewPlayer->IsBeingBriefed() ) {
|
|
return;
|
|
}
|
|
|
|
const float screenWidth = SCREEN_WIDTH * 1.0f / deviceContext->GetAspectRatioCorrection();
|
|
|
|
const float MARGIN_SIZE = ( screenWidth * 0.0125f );
|
|
const float LEFT_MARGIN = MARGIN_SIZE;
|
|
const float RIGHT_MARGIN = screenWidth - MARGIN_SIZE;
|
|
|
|
idVec3 org = viewPlayer->renderView.vieworg;
|
|
idMat3 axes = viewPlayer->renderView.viewaxis;
|
|
|
|
sdWorldToScreenConverter converter( gameLocal.playerView.GetCurrentView() );
|
|
|
|
sdWayPoint* highlightedWaypoint = NULL;
|
|
idVec2 bestDistanceFromCenter( idMath::INFINITY, idMath::INFINITY );
|
|
idVec2 bestDrawCenter;
|
|
float bestIconWidth;
|
|
float bestWidth;
|
|
float bestDistSqr;
|
|
float bestLeft;
|
|
|
|
for ( sdWayPoint* wayPoint = sdWayPointManager::GetInstance().GetFirstActiveWayPoint(); wayPoint != NULL; wayPoint = wayPoint->GetActiveNode().Next() ) {
|
|
if ( !wayPoint->IsValid() ) {
|
|
continue;
|
|
}
|
|
|
|
idBounds bounds = wayPoint->GetBounds();
|
|
idVec3 size = bounds.GetSize();
|
|
idVec3 center = bounds.GetCenter();
|
|
|
|
float smallestAxis = idMath::INFINITY;
|
|
float largestAxis = -idMath::INFINITY;
|
|
for( int i = 0; i < 3; i++ ) {
|
|
if( size[ i ] > largestAxis ) {
|
|
largestAxis = size[ i ];
|
|
}
|
|
if( size[ i ] < smallestAxis ) {
|
|
smallestAxis = size[ i ];
|
|
}
|
|
}
|
|
//bounds.GetMins().Set( -smallestAxis, -smallestAxis, -smallestAxis );
|
|
//bounds.GetMaxs().Set( smallestAxis, smallestAxis, smallestAxis );
|
|
|
|
//bounds.TranslateSelf( center - bounds.GetCenter() );
|
|
|
|
idMat3 axes = wayPoint->GetOrientation();
|
|
idVec3 origin = wayPoint->GetPosition();
|
|
float distSquare = ( org - origin ).LengthSqr();
|
|
float fadeAlpha = distSquare / Square( largestAxis * 2.0f ) - 0.25f;
|
|
|
|
float playerDist = ( viewPlayer->GetPhysics()->GetOrigin() - wayPoint->GetPosition() ).LengthFast() - g_waypointDistanceMin.GetFloat();
|
|
float waypointDist = g_waypointDistanceMax.GetFloat() - g_waypointDistanceMin.GetFloat();
|
|
float rangePct = waypointDist != 0.0f ? idMath::ClampFloat( 0.0f, 1.0f, playerDist / waypointDist ) : 0.0f;
|
|
float iconWidth = g_waypointSizeMin.GetFloat() + ( g_waypointSizeMax.GetFloat() - g_waypointSizeMin.GetFloat() ) * ( 1.0f - rangePct );
|
|
|
|
if ( fadeAlpha <= 0.0f ) {
|
|
continue;
|
|
}
|
|
fadeAlpha = idMath::ClampFloat( 0.0f, 1.0f, fadeAlpha );
|
|
|
|
sdBounds2D screenBounds;
|
|
converter.Transform( bounds, axes, origin, screenBounds );
|
|
|
|
float left = screenBounds.GetLeft();
|
|
float right = screenBounds.GetRight();
|
|
float top = screenBounds.GetTop();
|
|
float bottom = screenBounds.GetBottom();
|
|
float width = screenBounds.GetWidth();
|
|
float height = screenBounds.GetHeight();
|
|
|
|
float visiblePct = idMath::ClampFloat( 0.0f, 100.0f, 100.0f * ( ( width * height ) / ( screenWidth * SCREEN_HEIGHT ) ) );
|
|
|
|
// update the visibility of the waypoint
|
|
idVec3 temp;
|
|
bool isVisible = true;
|
|
if ( wayPoint->ShouldCheckLineOfSight() ){
|
|
isVisible = wayPoint->GetOwner()->IsVisibleOcclusionTest();
|
|
|
|
// ao: implicitly know it's a task if there's LOS check
|
|
if ( !TestCrosshairInfoFlag( CF_TASKS ) ) {
|
|
isVisible = false;
|
|
}
|
|
} else {
|
|
if ( !wayPoint->IsVisible() ) {
|
|
isVisible = false;
|
|
}
|
|
|
|
// ao: implicitly know it's a mission/objective if there's no LOS check
|
|
if ( !TestCrosshairInfoFlag( CF_OBJ_MIS ) ) {
|
|
isVisible = false;
|
|
}
|
|
}
|
|
|
|
if ( !isVisible ) {
|
|
visiblePct = 0.0f;
|
|
}
|
|
|
|
wayPoint->SetVisible( isVisible );
|
|
|
|
// update highlighting
|
|
if ( visiblePct > 0.05f && visiblePct < 40.f ) {
|
|
if ( !wayPoint->IsHighlightActive() ) {
|
|
wayPoint->MakeHighlightActive();
|
|
}
|
|
} else {
|
|
if ( wayPoint->IsHighlightActive() ) {
|
|
wayPoint->MakeHighlightInActive();
|
|
}
|
|
}
|
|
|
|
idVec4 color = colorWhite;
|
|
if ( wayPoint->GetFlags() & sdWayPoint::WF_TEAMCOLOR ) {
|
|
idEntity* owner = wayPoint->GetOwner();
|
|
if ( owner != NULL ) {
|
|
teamAllegiance_t allegiance = owner->GetEntityAllegiance( viewPlayer );
|
|
if ( allegiance != TA_NEUTRAL ) {
|
|
color = idEntity::GetColorForAllegiance( allegiance );
|
|
}
|
|
}
|
|
}
|
|
|
|
float factor = wayPoint->GetActiveFraction() * fadeAlpha;
|
|
|
|
color[ 3 ] *= factor;
|
|
|
|
idVec4 highlightColor = color;
|
|
highlightColor[ 3 ] *= wayPoint->GetHighLightActiveFraction() * fadeAlpha;
|
|
|
|
float scaleFactor = ( 1.0f - ( visiblePct / 0.33f ) );
|
|
converter.Transform( bounds, axes, origin, screenBounds );
|
|
|
|
idVec2 drawCenter = screenBounds.GetCenter();
|
|
|
|
float resize = 0.0f;
|
|
if ( gameLocal.ToGuiTime( gameLocal.time ) < wayPoint->GetFlashEndTime() ) {
|
|
resize = 2.0f;
|
|
}
|
|
|
|
idVec2 drawSize( iconWidth + resize, iconWidth + resize );
|
|
|
|
idVec2 drawHalfSize = drawSize * 0.5f;
|
|
idVec2 drawOrigin = drawCenter - ( drawSize * 0.5f );
|
|
drawOrigin.y = idMath::ClampFloat( MARGIN_SIZE, SCREEN_HEIGHT - MARGIN_SIZE - drawSize.y, drawOrigin.y );
|
|
|
|
idVec2 distanceFromCenter( idMath::Fabs( ( screenWidth * 0.5f ) - drawCenter.x ) / ( screenWidth * 0.5f ),
|
|
idMath::Fabs( ( SCREEN_HEIGHT * 0.5f ) - drawCenter.y ) / ( SCREEN_HEIGHT * 0.5f ) );
|
|
|
|
idVec4 localColor = colorWhite;
|
|
|
|
if ( gameLocal.ToGuiTime( gameLocal.time ) < wayPoint->GetFlashEndTime() ) {
|
|
localColor.w = idMath::Cos( gameLocal.ToGuiTime( gameLocal.time ) * 0.02f ) * 0.5f + 0.5f;
|
|
}
|
|
|
|
localColor.w = localColor.w * fadeAlpha * g_waypointAlphaScale.GetFloat();
|
|
|
|
iconInfo_t icon;
|
|
icon.material = wayPoint->GetOffScreenMaterial();
|
|
icon.color = idVec4( color.x, color.y, color.z, idMath::ClampFloat( 0.35f, 1.0f, color.w * scaleFactor ) );
|
|
icon.size = drawHalfSize;
|
|
|
|
if ( drawOrigin.x <= LEFT_MARGIN ) {
|
|
if ( localColor.w >= 0.01f ) {
|
|
idVec2 startOrg( LEFT_MARGIN, drawOrigin.y );
|
|
idVec2 endOrg( startOrg.x, SCREEN_HEIGHT * 0.5f );
|
|
|
|
if ( isVisible ) {
|
|
MakeDockIcon( wayPoint, true, endOrg, endOrg, icon, iconInfo_t() );
|
|
}
|
|
}
|
|
} else if ( ( drawOrigin.x + drawSize.x ) >= RIGHT_MARGIN ) {
|
|
if ( localColor.w >= 0.01f ) {
|
|
idVec2 startOrg( RIGHT_MARGIN, drawOrigin.y );
|
|
idVec2 endOrg( startOrg.x, SCREEN_HEIGHT * 0.5f );
|
|
|
|
if ( isVisible ) {
|
|
MakeDockIcon( wayPoint, false, endOrg, endOrg, icon, iconInfo_t() );
|
|
}
|
|
}
|
|
} else {
|
|
if ( isVisible ) {
|
|
if ( wayPoint->GetMaterial() != NULL ) {
|
|
float time = wayPoint->Selected();
|
|
if( time >= 0.0f ) {
|
|
float value = 1.0f - idMath::ClampFloat( 0.0f, 1.0f, static_cast< float >( gameLocal.time - time ) / HIGHLIGHT_TIME );
|
|
deviceContext->SetRegister( 4, value );
|
|
} else {
|
|
deviceContext->SetRegister( 4, 0.0f );
|
|
}
|
|
deviceContext->DrawMaterial( drawOrigin.x, drawOrigin.y, drawSize.x, drawSize.y, wayPoint->GetMaterial(), localColor );
|
|
}
|
|
}
|
|
}
|
|
if( isVisible ) {
|
|
sdDockedScreenIcon* icon = FindDockedIcon( wayPoint );
|
|
if( icon != NULL ) {
|
|
icon->highlightedTime = wayPoint->Selected();
|
|
}
|
|
}
|
|
|
|
if( isVisible && distanceFromCenter.x < 0.1f && distanceFromCenter.y < 0.1f && distanceFromCenter.x < bestDistanceFromCenter.x && distanceFromCenter.y < bestDistanceFromCenter.y ) {
|
|
waypointTextFadeTime = gameLocal.time;
|
|
bestDistanceFromCenter = distanceFromCenter;
|
|
highlightedWaypoint = wayPoint;
|
|
bestDrawCenter = drawCenter;
|
|
bestIconWidth = iconWidth;
|
|
bestWidth = width;
|
|
bestDistSqr = distSquare;
|
|
bestLeft = left;
|
|
}
|
|
|
|
if ( wayPoint->Bracketed() ) {
|
|
if( exclude != NULL && wayPoint->GetOwner() == exclude ) {
|
|
if( idMath::ClampFloat( 0.0f, 1.0f, idMath::Fabs( bracketFadeTime - gameLocal.time ) / ( float )sdWayPoint::ACTIVATE_TIME ) <= idMath::FLT_EPSILON ) {
|
|
continue;
|
|
}
|
|
}
|
|
idVec3 bracketOrigin = wayPoint->GetBracketPosition();
|
|
|
|
converter.Transform( bounds, axes, bracketOrigin, screenBounds );
|
|
|
|
DrawBrackets( screenBounds, highlightColor );
|
|
}
|
|
}
|
|
|
|
static const int TEXT_FADE_TIME = SEC2MS( 1 );
|
|
|
|
const sdCrosshairInfo& info = localPlayer->GetCrosshairInfoDirect();
|
|
if( !info.IsValid() && highlightedWaypoint != NULL && ( gameLocal.time - waypointTextFadeTime ) <= TEXT_FADE_TIME ) {
|
|
static const int TEXT_SCALE = 12;
|
|
idVec4 colorLocal = colorWhite;
|
|
colorLocal[ 3 ] *= 1.0f - ( static_cast< float >( gameLocal.time - waypointTextFadeTime ) / TEXT_FADE_TIME );
|
|
|
|
idWStrList args;
|
|
args.SetNum( 2 );
|
|
args[ 0 ] = va( L"%i", ( int )InchesToMetres( idMath::Sqrt( bestDistSqr ) ) );
|
|
args[ 1 ] = common->LocalizeText( "game/meters" );
|
|
|
|
idWStr text = common->LocalizeText( "game/range", args );
|
|
|
|
sdBounds2D rect( bestLeft, bestDrawCenter.y + bestIconWidth, bestWidth, lineTextHeight );
|
|
|
|
sdUIWindow::DrawText( text.c_str(), colorLocal, TEXT_SCALE, rect, cachedFontHandle, DTF_CENTER | DTF_BOTTOM | DTF_SINGLELINE | DTF_DROPSHADOW );
|
|
|
|
rect.TranslateSelf( 0.0f, lineTextHeight );
|
|
|
|
sdUIWindow::DrawText( highlightedWaypoint->GetText(), colorLocal, TEXT_SCALE, rect, cachedFontHandle, DTF_CENTER | DTF_BOTTOM | DTF_SINGLELINE | DTF_DROPSHADOW );
|
|
}
|
|
}
|
|
|
|
/*
|
|
============
|
|
sdUICrosshairInfo::DrawDockedIcons
|
|
============
|
|
*/
|
|
void sdUICrosshairInfo::DrawDockedIcons( void ) {
|
|
idVec2 offsets( 0.f, 0.f );
|
|
|
|
const float DOCK_SPACING = 32.0f;
|
|
|
|
for ( int i = 0; i < dockedIcons.Num(); i++ ) {
|
|
const sdDockedScreenIcon& dock = dockedIcons[ i ];
|
|
if ( !dock.active ) {
|
|
continue;
|
|
}
|
|
|
|
if ( dock.arrowIcon.material == NULL ) {
|
|
assert( false );
|
|
continue;
|
|
}
|
|
|
|
float percent = static_cast< float >( gameLocal.time - ( dock.startTime + 300 ) ) / sdDockedScreenIcon::DOCK_ANIMATION_MS;
|
|
percent = idMath::ClampFloat( 0.0f, 1.0f, percent );
|
|
|
|
idVec2 drawOrigin = Lerp( dock.startOrigin, dock.endOrigin, percent );
|
|
|
|
int index = dock.flipped ? 1 : 0;
|
|
|
|
drawOrigin.y += offsets[ index ];
|
|
|
|
float scale = dock.flipped ? 1.0f : -1.0f;
|
|
|
|
float xOffset = 0.f;
|
|
float yOffset = 0.f;
|
|
|
|
float time = dock.highlightedTime;
|
|
float value = 1.0f - idMath::ClampFloat( 0.0f, 1.0f, dock.highlightedTime < 0 ? 1.0f : ( static_cast< float >( gameLocal.time - time ) / HIGHLIGHT_TIME ) );
|
|
float drawScale = 1.0f + ( 1.0f * value );
|
|
deviceContext->SetRegister( 4, value );
|
|
|
|
|
|
if ( dock.icon.material != NULL ) {
|
|
idVec2 screenPos = drawOrigin;
|
|
screenPos.y -= ( DOCK_SPACING * 0.5f );
|
|
if ( !dock.flipped ) {
|
|
screenPos.x -= dock.icon.size.x;
|
|
}
|
|
|
|
float drawScale = 1.0f;
|
|
|
|
deviceContext->DrawMaterial( screenPos.x, screenPos.y, dock.icon.size.x * drawScale, dock.icon.size.y * drawScale, dock.icon.material, dock.icon.color, 1.f );
|
|
|
|
xOffset -= scale * dock.arrowIcon.size.x;
|
|
|
|
yOffset = dock.icon.size.y;
|
|
}
|
|
|
|
idVec2 screenPos = drawOrigin;
|
|
if ( dock.icon.material != NULL ) {
|
|
screenPos.y -= ( DOCK_SPACING * 0.5f - dock.icon.size.y * 0.25f );
|
|
} else {
|
|
screenPos.y -= ( DOCK_SPACING * 0.5f );
|
|
}
|
|
if ( !dock.flipped ) {
|
|
screenPos.x -= dock.arrowIcon.size.x;
|
|
}
|
|
deviceContext->DrawMaterial( xOffset + screenPos.x, screenPos.y, dock.arrowIcon.size.x * drawScale, dock.arrowIcon.size.y * drawScale, dock.arrowIcon.material, dock.arrowIcon.color, scale );
|
|
if ( dock.arrowIcon.size.y > yOffset ) {
|
|
yOffset = dock.arrowIcon.size.y;
|
|
}
|
|
|
|
offsets[ index ] += yOffset * 1.25f;
|
|
}
|
|
}
|
|
|
|
/*
|
|
============
|
|
sdUICrosshairInfo::FindDockedIcon
|
|
============
|
|
*/
|
|
sdDockedScreenIcon* sdUICrosshairInfo::FindDockedIcon( void* tag ) {
|
|
for ( int i = 0; i < dockedIcons.Num(); i++ ) {
|
|
if ( !dockedIcons[ i ].active ) {
|
|
continue;
|
|
}
|
|
|
|
if ( dockedIcons[ i ].tag == tag ) {
|
|
return &dockedIcons[ i ];
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
============
|
|
sdUICrosshairInfo::FindFreeDockedIcon
|
|
============
|
|
*/
|
|
sdDockedScreenIcon* sdUICrosshairInfo::FindFreeDockedIcon( void ) {
|
|
for( int i = 0; i < dockedIcons.Num(); i++ ) {
|
|
if ( !dockedIcons[ i ].active ) {
|
|
return &dockedIcons[ i ];
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
============
|
|
sdUICrosshairInfo::MakeDockIcon
|
|
============
|
|
*/
|
|
void sdUICrosshairInfo::MakeDockIcon( void* tag, bool flipped, const idVec2& startOrg, const idVec2& endOrg, const iconInfo_t& arrowInfo, const iconInfo_t& iconInfo ) {
|
|
sdDockedScreenIcon* icon = FindDockedIcon( tag );
|
|
if ( icon == NULL ) {
|
|
icon = FindFreeDockedIcon();
|
|
if ( icon == NULL ) {
|
|
return;
|
|
}
|
|
icon->tag = tag;
|
|
icon->startTime = gameLocal.time;
|
|
icon->active = true;
|
|
}
|
|
|
|
icon->icon = iconInfo;
|
|
icon->arrowIcon = arrowInfo;
|
|
icon->endOrigin = endOrg;
|
|
icon->flipped = flipped;
|
|
icon->lastUpdateTime = gameLocal.time;
|
|
icon->startOrigin = startOrg;
|
|
|
|
// Can get some very large y values
|
|
if ( icon->startOrigin.y > SCREEN_HEIGHT ) {
|
|
icon->startOrigin.y = SCREEN_HEIGHT + icon->icon.size.y;
|
|
} else if ( icon->startOrigin.y + icon->icon.size.y < 0 ) {
|
|
icon->startOrigin.y = -icon->icon.size.y;
|
|
}
|
|
}
|
|
|
|
/*
|
|
============
|
|
sdUICrosshairInfo::ClearInactiveDockIcons
|
|
============
|
|
*/
|
|
void sdUICrosshairInfo::ClearInactiveDockIcons( void ) {
|
|
for ( int i = 0; i < dockedIcons.Num(); i++ ) {
|
|
if ( dockedIcons[ i ].lastUpdateTime != gameLocal.time ) {
|
|
dockedIcons[ i ].active = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
============
|
|
sdUICrosshairInfo::DrawBrackets
|
|
============
|
|
*/
|
|
void sdUICrosshairInfo::DrawBrackets( const sdBounds2D& bounds, const idVec4& color ) {
|
|
const float screenWidth = SCREEN_WIDTH * 1.0f / deviceContext->GetAspectRatioCorrection();
|
|
|
|
float left = bounds.GetLeft();
|
|
float right = bounds.GetRight();
|
|
float top = bounds.GetTop();
|
|
float bottom = bounds.GetBottom();
|
|
float width = bounds.GetWidth();
|
|
float height = bounds.GetHeight();
|
|
|
|
idVec2 center( left + width * 0.5f, top + height * 0.5f );
|
|
|
|
float size = width * 0.25f;
|
|
|
|
//
|
|
// left half
|
|
//
|
|
idVec4 rect;
|
|
rect.Set( left - crosshairParts[ CP_L_BRACKET_TOP ].width, top, crosshairParts[ CP_L_BRACKET_TOP ].width, height );
|
|
|
|
DrawThreeVerticalParts( rect, color, vec2_one, crosshairParts[ CP_L_BRACKET_TOP ], crosshairParts[ CP_L_BRACKET_CENTER ], crosshairParts[ CP_L_BRACKET_BOTTOM ] );
|
|
|
|
rect.Set( right, top, crosshairParts[ CP_L_BRACKET_TOP ].width, height );
|
|
DrawThreeVerticalParts( rect, color, vec2_one, crosshairParts[ CP_R_BRACKET_TOP ], crosshairParts[ CP_R_BRACKET_CENTER ], crosshairParts[ CP_R_BRACKET_BOTTOM ] );
|
|
|
|
}
|
|
|
|
/*
|
|
============
|
|
sdUICrosshairInfo::DrawContextEntity
|
|
============
|
|
*/
|
|
idEntity* sdUICrosshairInfo::DrawContextEntity( idPlayer* player ) {
|
|
return NULL;
|
|
/* jrad - disabled this, as it was confusing
|
|
idEntity* entity = gameLocal.localPlayerProperties.GetContextEntity();
|
|
|
|
// see if we've moused over something that can be acted on
|
|
if( entity == NULL ) {
|
|
const sdProgram::sdFunction* callback = player->GetScriptFunction( "ContextUpdateOrder" );
|
|
if ( callback != NULL ) {
|
|
sdScriptHelper h;
|
|
h.Push( "" );
|
|
player->CallNonBlockingScriptEvent( callback, h );
|
|
|
|
const char* returnVal = h.GetReturnedString();
|
|
idStrList list;
|
|
idSplitStringIntoList( list, returnVal, "|" );
|
|
bool enabled;
|
|
if ( list.Num() >= 5 ) {
|
|
enabled = sdTypeFromString< bool >( list[ 4 ] );
|
|
} else {
|
|
enabled = true;
|
|
}
|
|
if ( enabled && list.Num() >= 6 ) {
|
|
enabled &= list[ 5 ].Icmp( "Invalid" ) != 0;
|
|
}
|
|
if( enabled ) {
|
|
const sdCrosshairInfo& info = player->GetCrosshairInfoDirect();
|
|
entity = info.GetEntity();
|
|
bracketFadeTime = gameLocal.time;
|
|
lastBracketEntity = entity;
|
|
}
|
|
}
|
|
}
|
|
|
|
// try using a cached one
|
|
if( entity == NULL ) {
|
|
entity = lastBracketEntity;
|
|
}
|
|
|
|
if( entity != NULL ) {
|
|
idVec3 org = entity->GetPhysics()->GetOrigin();
|
|
idMat3 axes = entity->GetAxis();
|
|
idBounds bounds = entity->GetPhysics()->GetBounds();
|
|
|
|
sdWorldToScreenConverter converter( gameLocal.playerView.GetCurrentView() );
|
|
|
|
sdBounds2D bracketBounds;
|
|
converter.Transform( bounds, axes, org, bracketBounds );
|
|
|
|
idVec4 color = colorWhite;
|
|
color.w = idMath::ClampFloat( 0.0f, 1.0f, idMath::Fabs( bracketFadeTime - gameLocal.time ) / ( float )sdWayPoint::ACTIVATE_TIME );
|
|
color.w = 1.0f - color.w;
|
|
DrawBrackets( bracketBounds, color );
|
|
}
|
|
|
|
return entity;
|
|
*/
|
|
}
|