#include <HeadUpDisplay.h>

Inheritance diagram for HeadUpDisplay:

Collaboration diagram for HeadUpDisplay:

Instance Methods
(id)	- initWithDictionary:

(id)	- initWithDictionary:inFile:

(void)	- resetGuis:

(void)	- resetGuiPositions

(NSString *)	- hudName

(void)	- setHudName:

(GLfloat)	- scannerZoom

(void)	- setScannerZoom:

(GLfloat)	- overallAlpha

(void)	- setOverallAlpha:

(BOOL)	- reticleTargetSensitive

(void)	- setReticleTargetSensitive:

(NSMutableDictionary *)	- propertiesReticleTargetSensitive

(BOOL)	- isHidden

(void)	- setHidden:

(BOOL)	- allowBigGui

(BOOL)	- hasHidden:

(void)	- setHiddenSelector:hidden:

(void)	- clearHiddenSelectors

(BOOL)	- isCompassActive

(void)	- setCompassActive:

(BOOL)	- isUpdating

(void)	- setDeferredHudName:

(NSString *)	- deferredHudName

(NSString *)	- crosshairDefinition

(BOOL)	- setCrosshairDefinition:

(void)	- addLegend:

(void)	- addDial:

(void)	- addMFD:

(NSUInteger)	- mfdCount

(void)	- renderHUD

(void)	- refreshLastTransmitter

(void)	- setLineWidth:

(GLfloat)	- lineWidth

(BOOL)	- minimalisticScanner

(void)	- setMinimalisticScanner:

(BOOL)	- nonlinearScanner

(void)	- setNonlinearScanner:

(BOOL)	- scannerUltraZoom

(void)	- setScannerUltraZoom:

(OOColor *)	- reticleColorForIndex:

(BOOL)	- setReticleColorForIndex:toColor:

(OOINLINE void)	- GLColorWithOverallAlpha `[implementation]`

(void)	- dealloc `[implementation]`

(void)	- resetGui:withInfo: `[implementation]`

(void)	- resetGuiPosition:withInfo: `[implementation]`

(void)	- drawLegends `[implementation]`

(void)	- drawDials `[implementation]`

(void)	- drawMFDs `[implementation]`

(void)	- drawCrosshairs `[implementation]`

(NSArray *)	- crosshairDefinitionForWeaponType: `[implementation]`

(void)	- drawLegend: `[implementation]`

(void)	- drawHUDItem: `[implementation]`

(BOOL)	- checkPlayerInFlight `[implementation]`

(BOOL)	- checkPlayerInSystemFlight `[implementation]`

(void)	- drawScanner: `[implementation]`

(void)	- drawScannerZoomIndicator: `[implementation]`

(void)	- drawCompass: `[implementation]`

(OOINLINE void)	- SetCompassBlipColor `[implementation]`

(void)	- drawCompassPlanetBlipAt:Size:Alpha: `[implementation]`

(void)	- drawCompassStationBlipAt:Size:Alpha: `[implementation]`

(void)	- drawCompassSunBlipAt:Size:Alpha: `[implementation]`

(void)	- drawCompassTargetBlipAt:Size:Alpha: `[implementation]`

(void)	- drawCompassBeaconBlipAt:Size:Alpha: `[implementation]`

(void)	- drawAegis: `[implementation]`

(void)	- drawCustomBar: `[implementation]`

(void)	- drawCustomText: `[implementation]`

(void)	- drawCustomIndicator: `[implementation]`

(void)	- drawCustomLight: `[implementation]`

(void)	- drawCustomImage: `[implementation]`

(void)	- drawSpeedBar: `[implementation]`

(void)	- drawRollBar: `[implementation]`

(void)	- drawPitchBar: `[implementation]`

(void)	- drawYawBar: `[implementation]`

(void)	- drawEnergyGauge: `[implementation]`

(void)	- drawForwardShieldBar: `[implementation]`

(void)	- drawAftShieldBar: `[implementation]`

(void)	- drawFuelBar: `[implementation]`

(void)	- drawWitchspaceDestination: `[implementation]`

(void)	- drawCabinTempBar: `[implementation]`

(void)	- drawWeaponTempBar: `[implementation]`

(void)	- drawAltitudeBar: `[implementation]`

(void)	- drawIconForMissile:selected:status:x:y:width:height:alpha: `[implementation]`

(void)	- drawIconForEmptyPylonAtX:y:width:height:alpha: `[implementation]`

(void)	- drawMissileDisplay: `[implementation]`

(void)	- drawTargetReticle: `[implementation]`

(void)	- drawSecondaryTargetReticle: `[implementation]`

(void)	- drawWaypoints: `[implementation]`

(void)	- drawStatusLight: `[implementation]`

(void)	- drawDirectionCue: `[implementation]`

(void)	- drawClock: `[implementation]`

(void)	- drawPrimedEquipment: `[implementation]`

(void)	- drawASCTarget: `[implementation]`

(void)	- drawWeaponsOfflineText: `[implementation]`

(void)	- drawFPSInfoCounter: `[implementation]`

(void)	- drawScoopStatus: `[implementation]`

(void)	- drawStickSensitivityIndicator: `[implementation]`

(void)	- drawSurroundInternal:color: `[implementation]`

(void)	- drawSurround: `[implementation]`

(void)	- drawGreenSurround: `[implementation]`

(void)	- drawYellowSurround: `[implementation]`

(void)	- drawTrumbles: `[implementation]`

(void)	- drawMultiFunctionDisplay:withText:asIndex: `[implementation]`

(void)	- OOHUDResetTextEngine(void) `[implementation]`

(NSRect)	- OORectFromString `[implementation]`

(CGFloat)	- OOStringWidthInEm `[implementation]`

(void)	- drawHighlight `[implementation]`

(void)	- OODrawString `[implementation]`

(void)	- OODrawStringAligned `[implementation]`

(void)	- OOStartDrawingStrings `[implementation]`

(void)	- OODrawStringQuadsAligned `[implementation]`

(void)	- OOStopDrawingStrings `[implementation]`

(void)	- OODrawHilightedString `[implementation]`

(void)	- OODrawPlanetInfo `[implementation]`

(void)	- OODrawHilightedPlanetInfo `[implementation]`

(void)	- drawPrimedEquipmentText: `[implementation]`

Class Methods
(Vector)	+ nonlinearScannerScale:Zoom:Scale:

(static GLfloat)	+ drawCharacterQuad `[implementation]`

(static void)	+ InitTextEngine(void) `[implementation]`

(static void)	+ prefetchData `[implementation]`

(static OOPolygonSprite *)	+ IconForMissileRole `[implementation]`

(static void)	+ hudDrawIndicatorAt `[implementation]`

(static void)	+ hudDrawMarkerAt `[implementation]`

(static void)	+ hudDrawBarAt `[implementation]`

(static void)	+ hudDrawSurroundAt `[implementation]`

(static void)	+ hudDrawStatusIconAt `[implementation]`

(static void)	+ hudDrawReticleOnTarget `[implementation]`

(static void)	+ hudDrawWaypoint `[implementation]`

(static void)	+ hudRotateViewpointForVirtualDepth `[implementation]`

(static void)	+ InitTextEngine(void) `[implementation]`

(static void)	+ GLDrawNonlinearCascadeWeapon `[implementation]`

(static GLfloat)	+ nonlinearScannerFunc `[implementation]`

(static void)	+ drawScannerGrid `[implementation]`

(static void)	+ DrawSpecialOval `[implementation]`

Private Attributes
NSMutableArray *	legendArray

NSMutableArray *	dialArray

NSMutableArray *	mfdArray

GLfloat	scanner_zoom

GLfloat	z1

GLfloat	lineWidth

NSString *	hudName

NSString *	deferredHudName

BOOL	hudUpdating

GLfloat	overallAlpha

BOOL	reticleTargetSensitive

NSMutableDictionary *	propertiesReticleTargetSensitive

BOOL	cloakIndicatorOnStatusLight

BOOL	hudHidden

BOOL	allowBigGui

int	last_transmitter

NSMutableSet *	_hiddenSelectors

OOCrosshairs *	_crosshairs

OOWeaponType	_lastWeaponType

GLfloat	_lastOverallAlpha

BOOL	_lastWeaponsOnline

NSDictionary *	_crosshairOverrides

OOColor *	_crosshairColor

GLfloat	_crosshairScale

GLfloat	_crosshairWidth

NSString *	crosshairDefinition

BOOL	_compassActive

NSMutableArray *	_reticleColors

BOOL	minimalistic_scanner

BOOL	nonlinear_scanner

BOOL	scanner_ultra_zoom

Detailed Description

Definition at line 237 of file HeadUpDisplay.h.

Method Documentation

◆ addDial:

- (void) addDial: (NSDictionary *) info

Definition at line 753 of file HeadUpDisplay.m.

                :(NSDictionary *)info
{
    static NSSet *allowedSelectors = nil;
    if (allowedSelectors == nil)
    {
        NSDictionary *whitelist = [ResourceManager whitelistDictionary];
        allowedSelectors = [[NSSet alloc] initWithArray:[whitelist oo_arrayForKey:@"hud_dial_methods"]];
    }
    
    NSString *selectorString = [info oo_stringForKey:SELECTOR_KEY];
    if (selectorString == nil)
    {
        OOLogERR(@"hud.dial.noSelector", @"HUD dial in %@ is missing selector.", hudName);
        return;
    }
    
    if (![allowedSelectors containsObject:selectorString])
    {
        OOLogERR(@"hud.dial.invalidSelector", @"HUD dial in %@ uses selector \"%@\" which is not in whitelist, and will be ignored.", hudName, selectorString);
        return;
    }
    
    SEL selector = NSSelectorFromString(selectorString);
    
    NSAssert2([self respondsToSelector:selector], @"HUD dial in %@ uses selector \"%@\" which is in whitelist, but not implemented.", hudName, selectorString);
    
    //  handle the case above with NS_BLOCK_ASSERTIONS too.
    if (![self respondsToSelector:selector])
    {
        OOLogERR(@"hud.dial.invalidSelector", @"HUD dial in %@ uses selector \"%@\"  which is in whitelist, but not implemented, and will be ignored.", hudName, selectorString);
        return;
    }
    
    // valid dial, now prefetch data
    struct CachedInfo cache;
    prefetchData(info, &cache);
    // add WIDGET_INFO, WIDGET_CACHE, WIDGET_SELECTOR, WIDGET_SELECTOR_NAME to array
    [dialArray addObject:[NSArray arrayWithObjects:info, [NSValue valueWithBytes:&cache objCType:@encode(struct CachedInfo)],
                         [NSValue valueWithPointer:selector], selectorString, nil]];
}

References hudName, nil, OOLogERR, prefetchData, and ResourceManager::whitelistDictionary.

Referenced by initWithDictionary:inFile:.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ addLegend:

- (void) addLegend: (NSDictionary *) info

Definition at line 705 of file HeadUpDisplay.m.

                  :(NSDictionary *)info
{
    NSString            *imageName = nil;
    OOTexture           *texture = nil;
    NSSize              imageSize;
    OOTextureSprite     *legendSprite = nil;
    NSMutableDictionary *legendDict = nil;
    struct CachedInfo   cache;
    
    // prefetch data associated with this legend
    prefetchData(info, &cache);
    
    imageName = [info oo_stringForKey:IMAGE_KEY];
    if (imageName != nil)
    {
        texture = [OOTexture textureWithName:imageName
                                    inFolder:@"Images"
                                     options:kOOTextureDefaultOptions | kOOTextureNoShrink
                                  anisotropy:kOOTextureDefaultAnisotropy
                                     lodBias:kOOTextureDefaultLODBias];
        if (texture == nil)
        {
            OOLogERR(kOOLogFileNotFound, @"HeadUpDisplay couldn't get an image texture name for %@", imageName);
            return;
        }
        
        imageSize = [texture dimensions];
        imageSize.width = [info oo_floatForKey:WIDTH_KEY defaultValue:imageSize.width];
        imageSize.height = [info oo_floatForKey:HEIGHT_KEY defaultValue:imageSize.height];
        
        legendSprite = [[OOTextureSprite alloc] initWithTexture:texture size:imageSize];
        
        legendDict = [info mutableCopy];
        [legendDict setObject:legendSprite forKey:SPRITE_KEY];
        // add WIDGET_INFO, WIDGET_CACHE to array
        [legendArray addObject:[NSArray arrayWithObjects:legendDict, [NSValue valueWithBytes:&cache objCType:@encode(struct CachedInfo)], nil]];                                                                    
        [legendDict release];
        [legendSprite release];
    }
    else if ([info oo_stringForKey:TEXT_KEY] != nil)
    {
        // add WIDGET_INFO, WIDGET_CACHE to array
        [legendArray addObject:[NSArray arrayWithObjects:info, [NSValue valueWithBytes:&cache objCType:@encode(struct CachedInfo)], nil]];
 
    }
}

References OOTexture::dimensions, kOOLogFileNotFound, nil, OOLogERR, prefetchData, TEXT_KEY, and OOTexture::textureWithName:inFolder:options:anisotropy:lodBias:.

Referenced by initWithDictionary:inFile:.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ addMFD:

- (void) addMFD: (NSDictionary *) info

Definition at line 795 of file HeadUpDisplay.m.

               :(NSDictionary *)info
{
    struct CachedInfo cache;
    prefetchData(info, &cache);
    [mfdArray addObject:[NSArray arrayWithObjects:info, [NSValue valueWithBytes:&cache objCType:@encode(struct CachedInfo)],nil]];
}

References prefetchData.

Referenced by initWithDictionary:inFile:.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ allowBigGui

- (BOOL) allowBigGui

References allowBigGui, clearHiddenSelectors, isCompassActive, and isUpdating.

Here is the call graph for this function:

◆ checkPlayerInFlight

- (BOOL) checkPlayerInFlight

implementation

Provided by category HeadUpDisplay(Private).

Definition at line 1150 of file HeadUpDisplay.m.

1151{

1152 return [PLAYER isInSpace] && [PLAYER status] != STATUS_DOCKING;

1153}

References HeadUpDisplay(Private)::checkPlayerInFlight.

Referenced by HeadUpDisplay(Private)::checkPlayerInFlight, HeadUpDisplay(Private)::checkPlayerInSystemFlight, HeadUpDisplay(Private)::drawPrimedEquipmentText:, and HeadUpDisplay(Private)::drawScanner:.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ checkPlayerInSystemFlight

- (BOOL) checkPlayerInSystemFlight

implementation

Provided by category HeadUpDisplay(Private).

Definition at line 1156 of file HeadUpDisplay.m.

{
    OOSunEntity     *the_sun = [UNIVERSE sun];
    OOPlanetEntity  *the_planet = [UNIVERSE planet];
    
    return [self checkPlayerInFlight]       // be in the right mode
        && the_sun && the_planet        // and be in a system
        && ![the_sun goneNova];
}

References checkPlayerInFlight, HeadUpDisplay(Private)::checkPlayerInSystemFlight, and OOSunEntity::goneNova.

Referenced by HeadUpDisplay(Private)::checkPlayerInSystemFlight, HeadUpDisplay(Private)::drawASCTarget:, HeadUpDisplay(Private)::drawCompass:, HeadUpDisplay(Private)::drawDials, and HeadUpDisplay(Private)::drawPrimedEquipmentText:.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ clearHiddenSelectors

- (void) clearHiddenSelectors

Definition at line 668 of file HeadUpDisplay.m.

669{

670 [_hiddenSelectors removeAllObjects];

671}

References clearHiddenSelectors.

Referenced by allowBigGui, and clearHiddenSelectors.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ crosshairDefinition

- (NSString *) crosshairDefinition

References crosshairDefinition, mfdCount, refreshLastTransmitter, and renderHUD.

Here is the call graph for this function:

◆ crosshairDefinitionForWeaponType:

- (NSArray *) crosshairDefinitionForWeaponType: (OOWeaponType) weapon

implementation

Provided by category HeadUpDisplay(Private).

Definition at line 990 of file HeadUpDisplay.m.

                                              :(OOWeaponType)weapon
{
    NSString                    *weaponName = nil;
    NSString                    *weaponName2 = nil;
    static                      NSDictionary *crosshairDefs = nil;
    NSArray                     *result = nil;
    
    /*  Search order:
     (hud.plist).crosshairs.WEAPON_NAME
     (hud.plist).crosshairs.OTHER
     (crosshairs.plist).WEAPON_NAME
     (crosshairs.plist).OTHER
     */
    
    weaponName = OOStringFromWeaponType(weapon);
    weaponName2 = [weaponName substringFromIndex:3]; // strip "EQ_"
    result = [_crosshairOverrides oo_arrayForKey:weaponName];
    if (result == nil) 
    {
        result = [_crosshairOverrides oo_arrayForKey:weaponName2];
    }
    if (result == nil)  result = [_crosshairOverrides oo_arrayForKey:@"OTHER"];
    if (result == nil)
    {
        if (crosshairDefs == nil)
        {
            crosshairDefs = [ResourceManager dictionaryFromFilesNamed:@"crosshairs.plist"
                                                             inFolder:@"Config"
                                                             andMerge:YES];
            [crosshairDefs retain];
        }
        
        result = [crosshairDefs oo_arrayForKey:weaponName];
        if (result == nil) 
        {
            result = [crosshairDefs oo_arrayForKey:weaponName2];
        }
        if (result == nil)  result = [crosshairDefs oo_arrayForKey:@"OTHER"];
    }
    
    return result;
}

References ResourceManager::dictionaryFromFilesNamed:inFolder:andMerge:, nil, and OOStringFromWeaponType().

Referenced by HeadUpDisplay(Private)::drawCrosshairs.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ dealloc

- (void) dealloc

implementation

Definition at line 343 of file HeadUpDisplay.m.

{
    DESTROY(legendArray);
    DESTROY(dialArray); 
    DESTROY(mfdArray);
    DESTROY(hudName);
    DESTROY(deferredHudName);
    DESTROY(propertiesReticleTargetSensitive);
    DESTROY(_crosshairOverrides);
    DESTROY(_crosshairColor);
    DESTROY(_reticleColors);
    DESTROY(crosshairDefinition);
    DESTROY(_hiddenSelectors);
 
    [super dealloc];
}

References _crosshairColor, _crosshairOverrides, _hiddenSelectors, _reticleColors, crosshairDefinition, dealloc, deferredHudName, DESTROY, dialArray, hudName, legendArray, mfdArray, and propertiesReticleTargetSensitive.

Referenced by dealloc.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ deferredHudName

- (NSString *) deferredHudName

References deferredHudName.

◆ drawAegis:

- (void) drawAegis: (NSDictionary *) info

implementation

Provided by category HeadUpDisplay(Private).

Definition at line 1785 of file HeadUpDisplay.m.

                  :(NSDictionary *)info
{
    if (([UNIVERSE viewDirection] == VIEW_GUI_DISPLAY)||([UNIVERSE sun] == nil)||([PLAYER checkForAegis] != AEGIS_IN_DOCKING_RANGE))
        return; // don't draw
    
    int                 x, y;
    NSSize              siz;
    GLfloat             alpha = 0.5f * overallAlpha;
    struct CachedInfo   cached;
    
    [(NSValue *)[sCurrentDrawItem objectAtIndex:WIDGET_CACHE] getValue:&cached];
    
    x = useDefined(cached.x, AEGIS_CENTRE_X) + [[UNIVERSE gameView] x_offset] * cached.x0;
    y = useDefined(cached.y, AEGIS_CENTRE_Y) + [[UNIVERSE gameView] y_offset] * cached.y0;
    siz.width = useDefined(cached.width, AEGIS_WIDTH);
    siz.height = useDefined(cached.height, AEGIS_HEIGHT);
    alpha *= cached.alpha;
    
    // draw the aegis indicator
    //
    GLfloat w = siz.width / 16.0;
    GLfloat h = siz.height / 16.0;
    
    GLfloat strip[] = { -7,8, -6,5, 5,8, 3,5, 7,2, 4,2, 6,-1, 4,2, -4,-1, -6,2, -4,-1, -7,-1, -3,-4, -5,-7, 6,-4, 7,-7 };
    
#if 1
    OOGL(glColor4f(0.0f, 1.0f, 0.0f, alpha));
    OOGLBEGIN(GL_QUAD_STRIP);
        int i;
        for (i = 0; i < 32; i += 2)
        {
            glVertex3f(x + w * strip[i], y - h * strip[i + 1], z1);
        }
    OOGLEND();
#else
    OOGLPushModelView();
    OOGLTranslateModelView(make_vector(x, y, z1));
    OOGLScaleModelView(make_vector(w, -h, 1.0f));
    
    OOGL(glColor4f(0.0f, 1.0f, 0.0f, alpha));
    OOGL(glVertexPointer(2, GL_FLOAT, 0, strip));
    OOGL(glEnableClientState(GL_VERTEX_ARRAY));
    OOGL(glDisableClientState(GL_COLOR_ARRAY));
    
    OOGL(glDrawArrays(GL_QUAD_STRIP, 0, sizeof strip / sizeof *strip / 2));
    OOGL(glDisableClientState(GL_VERTEX_ARRAY));
 
    OOGLPopModelView();
#endif
}

References AEGIS_CENTRE_X, AEGIS_CENTRE_Y, AEGIS_HEIGHT, AEGIS_IN_DOCKING_RANGE, AEGIS_WIDTH, CachedInfo::alpha, CachedInfo::height, nil, OOGL, OOGLBEGIN, OOGLEND, OOGLPopModelView(), OOGLPushModelView(), OOGLScaleModelView(), OOGLTranslateModelView(), PLAYER, UNIVERSE, useDefined(), CachedInfo::width, CachedInfo::x, x, CachedInfo::x0, CachedInfo::y, y, and CachedInfo::y0.

Here is the call graph for this function:

◆ drawAftShieldBar:

- (void) drawAftShieldBar: (NSDictionary *) info

implementation

Provided by category HeadUpDisplay(Private).

Definition at line 2278 of file HeadUpDisplay.m.

                         :(NSDictionary *)info
{
    int                 x, y;
    NSSize              siz;
    BOOL                draw_surround;
    GLfloat             alpha = overallAlpha;
    GLfloat             shield = [PLAYER dialAftShield];
    struct CachedInfo   cached;
    
    [(NSValue *)[sCurrentDrawItem objectAtIndex:WIDGET_CACHE] getValue:&cached];
    
    x = useDefined(cached.x, AFT_SHIELD_BAR_CENTRE_X) + [[UNIVERSE gameView] x_offset] * cached.x0;
    y = useDefined(cached.y, AFT_SHIELD_BAR_CENTRE_Y) + [[UNIVERSE gameView] y_offset] * cached.y0;
    siz.width = useDefined(cached.width, AFT_SHIELD_BAR_WIDTH);
    siz.height = useDefined(cached.height, AFT_SHIELD_BAR_HEIGHT);
    alpha *= cached.alpha;
    draw_surround = [info oo_boolForKey:DRAW_SURROUND_KEY defaultValue:AFT_SHIELD_BAR_DRAW_SURROUND];
    
    if (draw_surround)
    {
        // draw forward_shield surround
        SET_COLOR_SURROUND(green_color);
        hudDrawSurroundAt(x, y, z1, siz);
    }
    // draw forward_shield bar
    if (shield < .25)
    {
        SET_COLOR_LOW(red_color);
    }
    else if (shield < .80)
    {
        SET_COLOR_MEDIUM(yellow_color);
    } 
    else
    {
        SET_COLOR_HIGH(green_color);
    }
    hudDrawBarAt(x, y, z1, siz, shield);
}

References AFT_SHIELD_BAR_CENTRE_X, AFT_SHIELD_BAR_CENTRE_Y, AFT_SHIELD_BAR_HEIGHT, AFT_SHIELD_BAR_WIDTH, CachedInfo::alpha, green_color, CachedInfo::height, hudDrawBarAt(), hudDrawSurroundAt(), red_color, SET_COLOR_HIGH, SET_COLOR_LOW, SET_COLOR_MEDIUM, SET_COLOR_SURROUND, useDefined(), CachedInfo::width, CachedInfo::x, x, CachedInfo::x0, CachedInfo::y, y, CachedInfo::y0, and yellow_color.

Here is the call graph for this function:

◆ drawAltitudeBar:

- (void) drawAltitudeBar: (NSDictionary *) info

implementation

Provided by category HeadUpDisplay(Private).

Definition at line 2488 of file HeadUpDisplay.m.

                        :(NSDictionary *)info
{
    int                 x, y;
    NSSize              siz;
    BOOL                draw_surround;
    GLfloat             alt = [PLAYER dialAltitude];
    GLfloat             alpha = overallAlpha;
    struct CachedInfo   cached;
    
    [(NSValue *)[sCurrentDrawItem objectAtIndex:WIDGET_CACHE] getValue:&cached];
    
    x = useDefined(cached.x, ALTITUDE_BAR_CENTRE_X) + [[UNIVERSE gameView] x_offset] * cached.x0;
    y = useDefined(cached.y, ALTITUDE_BAR_CENTRE_Y) + [[UNIVERSE gameView] y_offset] * cached.y0;
    siz.width = useDefined(cached.width, ALTITUDE_BAR_WIDTH);
    siz.height = useDefined(cached.height, ALTITUDE_BAR_HEIGHT);
    alpha *= cached.alpha;
    draw_surround = [info oo_boolForKey:DRAW_SURROUND_KEY defaultValue:NO];
    
    if (draw_surround)
    {
        SET_COLOR_SURROUND(yellow_color);
        hudDrawSurroundAt(x, y, z1, siz);
    }
    
    int flash = (int)([UNIVERSE getTime] * 4);
    flash &= 1;
    
    // draw altitude bar (evaluating the least amount of ifs per go)
    if (alt < .25)
    {
        if (alt < .10 && flash)
            SET_COLOR_CRITICAL(redplus_color);
        else
            SET_COLOR_HIGH(red_color);
    }
    else
    {
        if (alt < .75)
            SET_COLOR_MEDIUM(yellow_color);
        else
            SET_COLOR_LOW(green_color);
    }
    
    hudDrawBarAt(x, y, z1, siz, alt);
    
}

References CachedInfo::alpha, ALTITUDE_BAR_CENTRE_X, ALTITUDE_BAR_CENTRE_Y, ALTITUDE_BAR_HEIGHT, ALTITUDE_BAR_WIDTH, green_color, CachedInfo::height, hudDrawBarAt(), hudDrawSurroundAt(), int(), red_color, redplus_color, SET_COLOR_CRITICAL, SET_COLOR_HIGH, SET_COLOR_LOW, SET_COLOR_MEDIUM, SET_COLOR_SURROUND, UNIVERSE, useDefined(), CachedInfo::width, CachedInfo::x, x, CachedInfo::x0, CachedInfo::y, y, CachedInfo::y0, and yellow_color.

Here is the call graph for this function:

◆ drawASCTarget:

- (void) drawASCTarget: (NSDictionary *) info

implementation

Provided by category HeadUpDisplay(Private).

Definition at line 3011 of file HeadUpDisplay.m.

                      :(NSDictionary *)info
{
    if (!([self checkPlayerInSystemFlight] && [PLAYER status] != STATUS_LAUNCHING)) // normal system
    {
        // Can't have compass target when docked, etc. (matches blip condition)
        return;
    }
    
    GLfloat             itemColor[4] = { 0.0f, 0.0f, 1.0f, 1.0f };
    struct CachedInfo   cached;
    
    [(NSValue *)[sCurrentDrawItem objectAtIndex:WIDGET_CACHE] getValue:&cached];
 
    NSInteger x = useDefined(cached.x, ASCTARGET_DISPLAY_X) + [[UNIVERSE gameView] x_offset] * cached.x0;
    NSInteger y = useDefined(cached.y, ASCTARGET_DISPLAY_Y) + [[UNIVERSE gameView] y_offset] * cached.y0;
    
    NSSize size =
    {
        .width = useDefined(cached.width, ASCTARGET_DISPLAY_WIDTH),
        .height = useDefined(cached.height, ASCTARGET_DISPLAY_HEIGHT)
    };
 
    GetRGBAArrayFromInfo(info, itemColor);
    itemColor[3] *= overallAlpha;
 
    OOGL(glColor4f(itemColor[0], itemColor[1], itemColor[2], itemColor[3]));
    if ([info oo_intForKey:@"align"] == 1)
    {
        OODrawStringAligned([PLAYER compassTargetLabel], x, y, z1, size,YES);
    }
    else
    {
        OODrawStringAligned([PLAYER compassTargetLabel], x, y, z1, size,NO);
    }
    
}

References ASCTARGET_DISPLAY_HEIGHT, ASCTARGET_DISPLAY_WIDTH, ASCTARGET_DISPLAY_X, ASCTARGET_DISPLAY_Y, HeadUpDisplay(Private)::checkPlayerInSystemFlight, GetRGBAArrayFromInfo(), CachedInfo::height, OODrawStringAligned(), OOGL, PLAYER, useDefined(), CachedInfo::width, CachedInfo::x, x, CachedInfo::x0, CachedInfo::y, y, and CachedInfo::y0.

Here is the call graph for this function:

◆ drawCabinTempBar:

- (void) drawCabinTempBar: (NSDictionary *) info

implementation

Provided by category HeadUpDisplay(Private).

Definition at line 2406 of file HeadUpDisplay.m.

                         :(NSDictionary *)info
{
    int                 x, y;
    NSSize              siz;
    BOOL                draw_surround;
    GLfloat             temp = [PLAYER hullHeatLevel];
    GLfloat             alpha = overallAlpha;
    struct CachedInfo   cached;
    
    [(NSValue *)[sCurrentDrawItem objectAtIndex:WIDGET_CACHE] getValue:&cached];
    
    x = useDefined(cached.x, CABIN_TEMP_BAR_CENTRE_X) + [[UNIVERSE gameView] x_offset] * cached.x0;
    y = useDefined(cached.y, CABIN_TEMP_BAR_CENTRE_Y) + [[UNIVERSE gameView] y_offset] * cached.y0;
    siz.width = useDefined(cached.width, CABIN_TEMP_BAR_WIDTH);
    siz.height = useDefined(cached.height, CABIN_TEMP_BAR_HEIGHT);
    alpha *= cached.alpha;
    draw_surround = [info oo_boolForKey:DRAW_SURROUND_KEY defaultValue:NO];
    
    if (draw_surround)
    {
        SET_COLOR_SURROUND(green_color);
        hudDrawSurroundAt(x, y, z1, siz);
    }
    
    int flash = (int)([UNIVERSE getTime] * 4);
    flash &= 1;
    // what color are we?
    if (temp > .80)
    {
        if (temp > .90 && flash)
            SET_COLOR_CRITICAL(redplus_color);
        else
            SET_COLOR_HIGH(red_color);
    }
    else
    {
        if (temp > .25)
            SET_COLOR_MEDIUM(yellow_color);
        else
            SET_COLOR_LOW(green_color);
    }
 
    
    hudDrawBarAt(x, y, z1, siz, temp);
}

References CachedInfo::alpha, CABIN_TEMP_BAR_CENTRE_X, CABIN_TEMP_BAR_CENTRE_Y, CABIN_TEMP_BAR_HEIGHT, CABIN_TEMP_BAR_WIDTH, green_color, CachedInfo::height, hudDrawBarAt(), hudDrawSurroundAt(), int(), red_color, redplus_color, SET_COLOR_CRITICAL, SET_COLOR_HIGH, SET_COLOR_LOW, SET_COLOR_MEDIUM, SET_COLOR_SURROUND, UNIVERSE, useDefined(), CachedInfo::width, CachedInfo::x, x, CachedInfo::x0, CachedInfo::y, y, CachedInfo::y0, and yellow_color.

Here is the call graph for this function:

◆ drawCharacterQuad

+ (static GLfloat) drawCharacterQuad	(uint8_t)	chr
	(GLfloat)	x
	(GLfloat)	y
	(GLfloat)	z
	(NSSize)	siz

implementation

Definition at line 3914 of file HeadUpDisplay.m.

{
    // 31 (narrow space) and 32 (space) are non-printing characters, so
    // don't print them, just return their width to move the pointer
    if (chr > 32 || chr < 31) {
        GLfloat texture_x = ONE_SIXTEENTH * (chr & 0x0f);
        GLfloat texture_y = ONE_SIXTEENTH * (chr >> 4);
        if (chr > 32)  y += ONE_EIGHTH * siz.height; // Adjust for baseline offset change in 1.71 (needed to keep accented characters in box)
    
        glTexCoord2f(texture_x, texture_y + ONE_SIXTEENTH);
        glVertex3f(x, y, z);
        glTexCoord2f(texture_x + ONE_SIXTEENTH, texture_y + ONE_SIXTEENTH);
        glVertex3f(x + siz.width, y, z);
        glTexCoord2f(texture_x + ONE_SIXTEENTH, texture_y);
        glVertex3f(x + siz.width, y + siz.height, z);
        glTexCoord2f(texture_x, texture_y);
        glVertex3f(x, y + siz.height, z);
    }
    return siz.width * sGlyphWidths[chr];
}

References drawCharacterQuad, ONE_EIGHTH, ONE_SIXTEENTH, sGlyphWidths, x, and y.

Referenced by drawCharacterQuad, OODrawPlanetInfo, and OODrawStringQuadsAligned.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ drawClock:

- (void) drawClock: (NSDictionary *) info

implementation

Provided by category HeadUpDisplay(Private).

Definition at line 2929 of file HeadUpDisplay.m.

                  :(NSDictionary *)info
{
    int                 x, y;
    NSSize              siz;
    GLfloat             itemColor[4] = { 0.0f, 1.0f, 0.0f, 1.0f };
    struct CachedInfo   cached;
    
    [(NSValue *)[sCurrentDrawItem objectAtIndex:WIDGET_CACHE] getValue:&cached];
    
    x = useDefined(cached.x, CLOCK_DISPLAY_X) + [[UNIVERSE gameView] x_offset] * cached.x0;
    y = useDefined(cached.y, CLOCK_DISPLAY_Y) + [[UNIVERSE gameView] y_offset] * cached.y0;
    siz.width = useDefined(cached.width, CLOCK_DISPLAY_WIDTH);
    siz.height = useDefined(cached.height, CLOCK_DISPLAY_HEIGHT);
    
    GetRGBAArrayFromInfo(info, itemColor);
    itemColor[3] *= overallAlpha;
    
    OOGL(glColor4f(itemColor[0], itemColor[1], itemColor[2], itemColor[3]));
    OODrawString([PLAYER dial_clock], x, y, z1, siz);
}

References CLOCK_DISPLAY_HEIGHT, CLOCK_DISPLAY_WIDTH, CLOCK_DISPLAY_X, CLOCK_DISPLAY_Y, GetRGBAArrayFromInfo(), CachedInfo::height, OODrawString(), OOGL, PLAYER, useDefined(), CachedInfo::width, CachedInfo::x, x, CachedInfo::x0, CachedInfo::y, y, and CachedInfo::y0.

Here is the call graph for this function:

◆ drawCompass:

- (void) drawCompass: (NSDictionary *) info

implementation

Provided by category HeadUpDisplay(Private).

Definition at line 1589 of file HeadUpDisplay.m.

                    :(NSDictionary *)info
{
    int                 x, y;
    NSSize              siz;
    GLfloat             alpha;
    GLfloat             compass_color[4] = { 0.0f, 0.0f, 1.0f, 1.0f };
    struct CachedInfo   cached;
    
    [(NSValue *)[sCurrentDrawItem objectAtIndex:WIDGET_CACHE] getValue:&cached];
    
    x = useDefined(cached.x, COMPASS_CENTRE_X) + [[UNIVERSE gameView] x_offset] * cached.x0;
    y = useDefined(cached.y, COMPASS_CENTRE_Y) + [[UNIVERSE gameView] y_offset] * cached.y0;
    siz.width = useDefined(cached.width, COMPASS_HALF_SIZE);
    siz.height = useDefined(cached.height, COMPASS_HALF_SIZE);
    
    GetRGBAArrayFromInfo(info, compass_color);
    compass_color[3] *= overallAlpha;
    alpha = compass_color[3];
    
    // draw the compass
    OOMatrix        rotMatrix = [PLAYER rotationMatrix];
    
    GLfloat h1 = siz.height * 0.125;
    GLfloat h3 = siz.height * 0.375;
    GLfloat w1 = siz.width * 0.125;
    GLfloat w3 = siz.width * 0.375;
    OOGL(GLScaledLineWidth(2.0 * lineWidth)); // thicker
    OOGL(glColor4f(compass_color[0], compass_color[1], compass_color[2], alpha));
    GLDrawOval(x, y, z1, siz, 12);    
    OOGL(glColor4f(compass_color[0], compass_color[1], compass_color[2], 0.5f * alpha));
    OOGLBEGIN(GL_LINES);
        glVertex3f(x - w1, y, z1);  glVertex3f(x - w3, y, z1);
        glVertex3f(x + w1, y, z1);  glVertex3f(x + w3, y, z1);
        glVertex3f(x, y - h1, z1);  glVertex3f(x, y - h3, z1);
        glVertex3f(x, y + h1, z1);  glVertex3f(x, y + h3, z1);
    OOGLEND();
    OOGL(GLScaledLineWidth(lineWidth));   // thinner
    
    if ([self checkPlayerInSystemFlight] && [PLAYER status] != STATUS_LAUNCHING) // normal system
    {
        Entity *reference = [PLAYER compassTarget];
        
        // translate and rotate the view
 
        Vector relativePosition = [PLAYER vectorTo:reference];
        relativePosition = OOVectorMultiplyMatrix(relativePosition, rotMatrix);
        relativePosition = vector_normal_or_fallback(relativePosition, kBasisZVector);
        
        relativePosition.x *= siz.width * 0.4;
        relativePosition.y *= siz.height * 0.4;
        relativePosition.x += x;
        relativePosition.y += y;
        
        siz.width *= 0.2;
        siz.height *= 0.2;
        OOGL(GLScaledLineWidth(2.0*lineWidth));
        switch ([PLAYER compassMode])
        {
            case COMPASS_MODE_INACTIVE:
                break;
            
            case COMPASS_MODE_BASIC:
                if ([reference isStation]) // validateCompassTarget in PlayerEntity.m changes COMPASS_BASIC_MODE target to the main station when inside the planetary aegis or in docking range of the main station
                    [self drawCompassStationBlipAt:relativePosition Size:siz Alpha:alpha];
                else
                    [self drawCompassPlanetBlipAt:relativePosition Size:siz Alpha:alpha];
                break;
                
            case COMPASS_MODE_PLANET:
                [self drawCompassPlanetBlipAt:relativePosition Size:siz Alpha:alpha];
                break;
                
            case COMPASS_MODE_STATION:
                [self drawCompassStationBlipAt:relativePosition Size:siz Alpha:alpha];
                break;
                
            case COMPASS_MODE_SUN:
                [self drawCompassSunBlipAt:relativePosition Size:siz Alpha:alpha];
                break;
                
            case COMPASS_MODE_TARGET:
                [self drawCompassTargetBlipAt:relativePosition Size:siz Alpha:alpha];
                break;
                
            case COMPASS_MODE_BEACONS:
                [self drawCompassBeaconBlipAt:relativePosition Size:siz Alpha:alpha];
                Entity <OOBeaconEntity>     *beacon = [PLAYER nextBeacon];
                [[beacon beaconDrawable] oo_drawHUDBeaconIconAt:NSMakePoint(x, y) size:siz alpha:alpha z:z1];
                break;
        }
        OOGL(GLScaledLineWidth(lineWidth));   // reset
 
        _compassUpdated = YES;
        _compassActive = YES;
    }
}

References _compassUpdated, HeadUpDisplay(Private)::checkPlayerInSystemFlight, COMPASS_CENTRE_X, COMPASS_CENTRE_Y, COMPASS_HALF_SIZE, drawCompassBeaconBlipAt:Size:Alpha:, drawCompassPlanetBlipAt:Size:Alpha:, drawCompassStationBlipAt:Size:Alpha:, drawCompassSunBlipAt:Size:Alpha:, drawCompassTargetBlipAt:Size:Alpha:, GetRGBAArrayFromInfo(), GLDrawOval(), GLScaledLineWidth(), CachedInfo::height, kBasisZVector, OOGL, OOGLBEGIN, OOGLEND, OOVectorMultiplyMatrix(), PLAYER, useDefined(), CachedInfo::width, CachedInfo::x, x, CachedInfo::x0, CachedInfo::y, y, and CachedInfo::y0.

Here is the call graph for this function:

◆ drawCompassBeaconBlipAt:Size:Alpha:

- (void) drawCompassBeaconBlipAt:	(Vector)	relativePosition
Size:	(NSSize)	siz
Alpha:	(GLfloat)	alpha

implementation

Provided by category HeadUpDisplay(Private).

Definition at line 1756 of file HeadUpDisplay.m.

                                :(Vector) relativePosition Size:(NSSize) siz Alpha:(GLfloat) alpha
{
    SetCompassBlipColor(relativePosition.z, alpha);
    
    OOGLBEGIN(GL_LINES);
    /*      glVertex3f(relativePosition.x - 0.5 * siz.width, relativePosition.y - 0.5 * siz.height, z1);
        glVertex3f(relativePosition.x, relativePosition.y + 0.5 * siz.height, z1);
        
        glVertex3f(relativePosition.x + 0.5 * siz.width, relativePosition.y - 0.5 * siz.height, z1);
        glVertex3f(relativePosition.x, relativePosition.y + 0.5 * siz.height, z1);
        
        glVertex3f(relativePosition.x - 0.5 * siz.width, relativePosition.y - 0.5 * siz.height, z1);
        glVertex3f(relativePosition.x + 0.5 * siz.width, relativePosition.y - 0.5 * siz.height, z1); */
    glVertex3f(relativePosition.x + 0.6 * siz.width, relativePosition.y, z1);
    glVertex3f(relativePosition.x, relativePosition.y + 0.6 * siz.height, z1);
 
    glVertex3f(relativePosition.x - 0.6 * siz.width, relativePosition.y, z1);
    glVertex3f(relativePosition.x, relativePosition.y + 0.6 * siz.height, z1);
 
    glVertex3f(relativePosition.x + 0.6 * siz.width, relativePosition.y, z1);
    glVertex3f(relativePosition.x, relativePosition.y - 0.6 * siz.height, z1);
 
    glVertex3f(relativePosition.x - 0.6 * siz.width, relativePosition.y, z1);
    glVertex3f(relativePosition.x, relativePosition.y - 0.6 * siz.height, z1);
 
    OOGLEND();
}

References OOGLBEGIN, and OOGLEND.

Referenced by HeadUpDisplay(Private)::drawCompass:.

Here is the caller graph for this function:

◆ drawCompassPlanetBlipAt:Size:Alpha:

- (void) drawCompassPlanetBlipAt:	(Vector)	relativePosition
Size:	(NSSize)	siz
Alpha:	(GLfloat)	alpha

implementation

Provided by category HeadUpDisplay(Private).

Definition at line 1700 of file HeadUpDisplay.m.

                                :(Vector)relativePosition Size:(NSSize)siz Alpha:(GLfloat)alpha
{
    if (relativePosition.z >= 0)
    {
        OOGL(glColor4f(0.0,1.0,0.0,0.75 * alpha));
        GLDrawFilledOval(relativePosition.x, relativePosition.y, z1, siz, 30);
        OOGL(glColor4f(0.0,1.0,0.0,alpha));
        GLDrawOval(relativePosition.x, relativePosition.y, z1, siz, 30);
    }
    else
    {
        OOGL(glColor4f(1.0,0.0,0.0,alpha));
        GLDrawOval(relativePosition.x, relativePosition.y, z1, siz, 30);
    }
}

References GLDrawFilledOval(), GLDrawOval(), and OOGL.

Referenced by HeadUpDisplay(Private)::drawCompass:.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ drawCompassStationBlipAt:Size:Alpha:

- (void) drawCompassStationBlipAt:	(Vector)	relativePosition
Size:	(NSSize)	siz
Alpha:	(GLfloat)	alpha

implementation

Provided by category HeadUpDisplay(Private).

Definition at line 1717 of file HeadUpDisplay.m.

                                 :(Vector) relativePosition Size:(NSSize) siz Alpha:(GLfloat) alpha
{
    SetCompassBlipColor(relativePosition.z, alpha);
    
    OOGLBEGIN(GL_LINE_LOOP);
        glVertex3f(relativePosition.x - 0.5 * siz.width, relativePosition.y - 0.5 * siz.height, z1);
        glVertex3f(relativePosition.x + 0.5 * siz.width, relativePosition.y - 0.5 * siz.height, z1);
        glVertex3f(relativePosition.x + 0.5 * siz.width, relativePosition.y + 0.5 * siz.height, z1);
        glVertex3f(relativePosition.x - 0.5 * siz.width, relativePosition.y + 0.5 * siz.height, z1);
    OOGLEND();
}

References OOGLBEGIN, and OOGLEND.

Referenced by HeadUpDisplay(Private)::drawCompass:.

Here is the caller graph for this function:

◆ drawCompassSunBlipAt:Size:Alpha:

- (void) drawCompassSunBlipAt:	(Vector)	relativePosition
Size:	(NSSize)	siz
Alpha:	(GLfloat)	alpha

implementation

Provided by category HeadUpDisplay(Private).

Definition at line 1730 of file HeadUpDisplay.m.

                             :(Vector) relativePosition Size:(NSSize) siz Alpha:(GLfloat) alpha
{
    OOGL(glColor4f(1.0, 1.0, 0.0, 0.75 * alpha));
    GLDrawFilledOval(relativePosition.x, relativePosition.y, z1, siz, 30);
    
    SetCompassBlipColor(relativePosition.z, alpha);
    
    GLDrawOval(relativePosition.x, relativePosition.y, z1, siz, 30);
}

References GLDrawFilledOval(), GLDrawOval(), and OOGL.

Referenced by HeadUpDisplay(Private)::drawCompass:.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ drawCompassTargetBlipAt:Size:Alpha:

- (void) drawCompassTargetBlipAt:	(Vector)	relativePosition
Size:	(NSSize)	siz
Alpha:	(GLfloat)	alpha

implementation

Provided by category HeadUpDisplay(Private).

Definition at line 1741 of file HeadUpDisplay.m.

                                :(Vector) relativePosition Size:(NSSize) siz Alpha:(GLfloat) alpha
{
    SetCompassBlipColor(relativePosition.z, alpha);
    
    OOGLBEGIN(GL_LINES);
        glVertex3f(relativePosition.x - siz.width, relativePosition.y, z1);
        glVertex3f(relativePosition.x + siz.width, relativePosition.y, z1);
        glVertex3f(relativePosition.x, relativePosition.y - siz.height, z1);
        glVertex3f(relativePosition.x, relativePosition.y + siz.height, z1);
    OOGLEND();
    
    GLDrawOval(relativePosition.x, relativePosition.y, z1, siz, 30);
}

References GLDrawOval(), OOGLBEGIN, and OOGLEND.

Referenced by HeadUpDisplay(Private)::drawCompass:.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ drawCrosshairs

- (void) drawCrosshairs

implementation

Provided by category HeadUpDisplay(Private).

Definition at line 918 of file HeadUpDisplay.m.

{
    OOViewID                    viewID = [UNIVERSE viewDirection];
    OOWeaponType                weapon = [PLAYER currentWeapon];
    BOOL                        weaponsOnline = [PLAYER weaponsOnline];
    NSArray                     *points = nil;
    
    if (viewID == VIEW_CUSTOM ||
        overallAlpha == 0.0f ||
        !([PLAYER status] == STATUS_IN_FLIGHT || [PLAYER status] == STATUS_WITCHSPACE_COUNTDOWN) ||
        [UNIVERSE displayGUI]
        )
    {
        // Don't draw crosshairs
        return;
    }
    
    if (weapon != _lastWeaponType || overallAlpha != _lastOverallAlpha || weaponsOnline != _lastWeaponsOnline)
    {
        DESTROY(_crosshairs);
    }
    
    if (_crosshairs == nil)
    {
        GLfloat useAlpha = weaponsOnline ? overallAlpha : overallAlpha * 0.5f;
        
        // Make new crosshairs object
        points = [self crosshairDefinitionForWeaponType:weapon];
        
        _crosshairs = [[OOCrosshairs alloc] initWithPoints:points
                                                     scale:_crosshairScale
                                                     color:_crosshairColor
                                              overallAlpha:useAlpha];
        _lastWeaponType = weapon;
        _lastOverallAlpha = useAlpha;
        _lastWeaponsOnline = weaponsOnline;
    }
    
    [_crosshairs render];
}

References crosshairDefinitionForWeaponType:, DESTROY, HeadUpDisplay(Private)::drawCrosshairs, nil, PLAYER, and UNIVERSE.

Referenced by HeadUpDisplay(Private)::drawCrosshairs, and renderHUD.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ drawCustomBar:

- (void) drawCustomBar: (NSDictionary *) info

implementation

Provided by category HeadUpDisplay(Private).

Definition at line 1837 of file HeadUpDisplay.m.

                      :(NSDictionary *)info
{
    int                 x, y;
    NSSize              siz;
    BOOL                draw_surround;
    GLfloat             alpha = overallAlpha;
    GLfloat             ds = OOClamp_0_1_f([PLAYER dialCustomFloat:[info oo_stringForKey:CUSTOM_DIAL_KEY]]);
    struct CachedInfo   cached;
    
    [(NSValue *)[sCurrentDrawItem objectAtIndex:WIDGET_CACHE] getValue:&cached];
    
    x = useDefined(cached.x, 0) + [[UNIVERSE gameView] x_offset] * cached.x0;
    y = useDefined(cached.y, 0) + [[UNIVERSE gameView] y_offset] * cached.y0;
    siz.width = useDefined(cached.width, 50);
    siz.height = useDefined(cached.height, 8);
    alpha *= cached.alpha;
    
    draw_surround = [info oo_boolForKey:DRAW_SURROUND_KEY defaultValue:NO];
    
    SET_COLOR_SURROUND(green_color);
    if (draw_surround)
    {
        // draw custom surround
        hudDrawSurroundAt(x, y, z1, siz);
    }
    // draw custom bar
    if (ds > .75)
    {
        SET_COLOR_HIGH(green_color);
    }
    else if (ds > .25)
    {
        SET_COLOR_MEDIUM(yellow_color);
    }
    else
    {
        SET_COLOR_LOW(red_color);
    }
 
    hudDrawBarAt(x, y, z1, siz, ds);
}

References CachedInfo::alpha, CUSTOM_DIAL_KEY, green_color, CachedInfo::height, hudDrawBarAt(), hudDrawSurroundAt(), PLAYER, red_color, SET_COLOR_HIGH, SET_COLOR_LOW, SET_COLOR_MEDIUM, SET_COLOR_SURROUND, useDefined(), CachedInfo::width, CachedInfo::x, x, CachedInfo::x0, CachedInfo::y, y, CachedInfo::y0, and yellow_color.

Here is the call graph for this function:

◆ drawCustomImage:

- (void) drawCustomImage: (NSDictionary *) info

implementation

Provided by category HeadUpDisplay(Private).

Definition at line 1977 of file HeadUpDisplay.m.

                        :(NSDictionary *)info
{
    int                 x, y;
    GLfloat             alpha = overallAlpha;
 
    struct CachedInfo   cached;
    
    [(NSValue *)[sCurrentDrawItem objectAtIndex:WIDGET_CACHE] getValue:&cached];
    
    x = useDefined(cached.x, 0) + [[UNIVERSE gameView] x_offset] * cached.x0;
    y = useDefined(cached.y, 0) + [[UNIVERSE gameView] y_offset] * cached.y0;
    alpha *= cached.alpha;
 
    NSString *textureFile = [PLAYER dialCustomString:[info oo_stringForKey:CUSTOM_DIAL_KEY]];
    if (textureFile == nil || [textureFile length] == 0) {
        return;
    }
 
    OOTexture *texture = [OOTexture textureWithName:textureFile
                                           inFolder:@"Images"
                                            options:kOOTextureDefaultOptions | kOOTextureNoShrink
                                         anisotropy:kOOTextureDefaultAnisotropy
                                            lodBias:kOOTextureDefaultLODBias];
    if (texture == nil)
    {
        OOLogERR(kOOLogFileNotFound, @"HeadUpDisplay couldn't get an image texture name for %@", textureFile);
        return;
    }
        
    NSSize imageSize = [texture dimensions];
    imageSize.width = useDefined(cached.width, imageSize.width);
    imageSize.height = useDefined(cached.height, imageSize.height);
 
    /* There's possibly some optimisation which could be done by
     * caching the sprite, but regenerating it each frame doesn't
     * appear to take any significant amount of time compared with the
     * time taken to actually render it and the texture will be
     * returned from the cache anyway. - CIM */
    OOTextureSprite *sprite = [[OOTextureSprite alloc] initWithTexture:texture size:imageSize];
 
    [sprite blitCentredToX:x Y:y Z:z1 alpha:alpha];
    [sprite release];
 
}

References CachedInfo::alpha, OOTextureSprite::blitCentredToX:Y:Z:alpha:, OOTexture::dimensions, CachedInfo::height, kOOLogFileNotFound, nil, OOLogERR, OOTexture::textureWithName:inFolder:options:anisotropy:lodBias:, useDefined(), CachedInfo::width, CachedInfo::x, x, CachedInfo::x0, CachedInfo::y, y, and CachedInfo::y0.

Here is the call graph for this function:

◆ drawCustomIndicator:

- (void) drawCustomIndicator: (NSDictionary *) info

implementation

Provided by category HeadUpDisplay(Private).

Definition at line 1911 of file HeadUpDisplay.m.

                            :(NSDictionary *)info
{
    int                 x, y;
    NSSize              siz;
    BOOL                draw_surround;
    GLfloat             alpha = overallAlpha;
    GLfloat             iv = OOClamp_n1_1_f([PLAYER dialCustomFloat:[info oo_stringForKey:CUSTOM_DIAL_KEY]]);
 
    struct CachedInfo   cached;
    
    [(NSValue *)[sCurrentDrawItem objectAtIndex:WIDGET_CACHE] getValue:&cached];
    
    x = useDefined(cached.x, 0) + [[UNIVERSE gameView] x_offset] * cached.x0;
    y = useDefined(cached.y, 0) + [[UNIVERSE gameView] y_offset] * cached.y0;
    siz.width = useDefined(cached.width, 50);
    siz.height = useDefined(cached.height, 8);
    alpha *= cached.alpha;
    draw_surround = [info oo_boolForKey:DRAW_SURROUND_KEY defaultValue:NO];
    
    if (draw_surround)
    {
        // draw custom surround
        SET_COLOR_SURROUND(green_color);
        hudDrawSurroundAt(x, y, z1, siz);
    }
    // draw custom indicator
    SET_COLOR(yellow_color);
    hudDrawIndicatorAt(x, y, z1, siz, iv);
}

References CachedInfo::alpha, CUSTOM_DIAL_KEY, green_color, CachedInfo::height, hudDrawIndicatorAt(), hudDrawSurroundAt(), PLAYER, SET_COLOR, SET_COLOR_SURROUND, useDefined(), CachedInfo::width, CachedInfo::x, x, CachedInfo::x0, CachedInfo::y, y, CachedInfo::y0, and yellow_color.

Here is the call graph for this function:

◆ drawCustomLight:

- (void) drawCustomLight: (NSDictionary *) info

implementation

Provided by category HeadUpDisplay(Private).

Definition at line 1942 of file HeadUpDisplay.m.

                        :(NSDictionary *)info
{
    int                 x, y;
    NSSize              siz;
    GLfloat             alpha = overallAlpha;
 
    struct CachedInfo   cached;
    
    [(NSValue *)[sCurrentDrawItem objectAtIndex:WIDGET_CACHE] getValue:&cached];
    
    x = useDefined(cached.x, 0) + [[UNIVERSE gameView] x_offset] * cached.x0;
    y = useDefined(cached.y, 0) + [[UNIVERSE gameView] y_offset] * cached.y0;
    siz.width = useDefined(cached.width, 8);
    siz.height = useDefined(cached.height, 8);
    alpha *= cached.alpha;
    
    GLfloat light_color[4] = { 0.25, 0.25, 0.25, 0.0};
    
    OOColor *color = [PLAYER dialCustomColor:[info oo_stringForKey:CUSTOM_DIAL_KEY]];
    [color getRed:&light_color[0]
            green:&light_color[1]
             blue:&light_color[2]
            alpha:&light_color[3]];
 
    GLColorWithOverallAlpha(light_color, alpha);
    OOGLBEGIN(GL_POLYGON);
    hudDrawStatusIconAt(x, y, z1, siz);
    OOGLEND();
    OOGL(glColor4f(0.25, 0.25, 0.25, alpha));
    OOGLBEGIN(GL_LINE_LOOP);
        hudDrawStatusIconAt(x, y, z1, siz);
    OOGLEND();
}

References CachedInfo::alpha, OOColor::getRed:green:blue:alpha:, CachedInfo::height, hudDrawStatusIconAt(), OOGL, OOGLBEGIN, OOGLEND, useDefined(), CachedInfo::width, CachedInfo::x, x, CachedInfo::x0, CachedInfo::y, y, and CachedInfo::y0.

Here is the call graph for this function:

◆ drawCustomText:

- (void) drawCustomText: (NSDictionary *) info

implementation

Provided by category HeadUpDisplay(Private).

Definition at line 1880 of file HeadUpDisplay.m.

                       :(NSDictionary *)info
{
    int                 x, y;
    NSSize              size;
    GLfloat             alpha = overallAlpha;
    NSString            *text = [PLAYER dialCustomString:[info oo_stringForKey:CUSTOM_DIAL_KEY]];
    struct CachedInfo   cached;
    
    [(NSValue *)[sCurrentDrawItem objectAtIndex:WIDGET_CACHE] getValue:&cached];
    
    x = useDefined(cached.x, 0) + [[UNIVERSE gameView] x_offset] * cached.x0;
    y = useDefined(cached.y, 0) + [[UNIVERSE gameView] y_offset] * cached.y0;
    alpha *= cached.alpha;
    
    SET_COLOR(yellow_color);
 
    size.width = useDefined(cached.width, 10.0f);
    size.height = useDefined(cached.height, 10.0f);
 
    if ([info oo_intForKey:@"align"] == 1)
    {
        OODrawStringAligned(text, x, y, z1, size, YES);
    }
    else
    {
        OODrawStringAligned(text, x, y, z1, size, NO);
    }
 
}

References CachedInfo::alpha, CachedInfo::height, OODrawStringAligned(), SET_COLOR, useDefined(), CachedInfo::width, CachedInfo::x, x, CachedInfo::x0, CachedInfo::y, y, CachedInfo::y0, and yellow_color.

Here is the call graph for this function:

◆ drawDials

- (void) drawDials

implementation

Provided by category HeadUpDisplay(Private).

Definition at line 878 of file HeadUpDisplay.m.

{   
    z1 = [[UNIVERSE gameView] display_z];
    // reset drawScanner flag.
    _compassUpdated = NO;
    
    // tight loop, we assume dialArray doesn't change in mid-draw.
    NSUInteger i, nDials = [dialArray count];
    for (i = 0; i < nDials; i++)
    {
        sCurrentDrawItem = [dialArray oo_arrayAtIndex:i];
        [self drawHUDItem:[sCurrentDrawItem oo_dictionaryAtIndex:WIDGET_INFO]];
    }
    
    if (EXPECT_NOT(!_compassUpdated && _compassActive && [self checkPlayerInSystemFlight])) // compass gone / broken / disabled ?
    {
        // trigger the targetChanged event with whom == null
        _compassActive = NO;
        [PLAYER doScriptEvent:OOJSID("compassTargetChanged") withArguments:[NSArray arrayWithObjects:[NSNull null], OOStringFromCompassMode([PLAYER compassMode]), nil]];
    }
    
}

References _compassUpdated, HeadUpDisplay(Private)::checkPlayerInSystemFlight, HeadUpDisplay(Private)::drawDials, drawHUDItem:, EXPECT_NOT, and sCurrentDrawItem.

Referenced by HeadUpDisplay(Private)::drawDials, and renderHUD.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ drawDirectionCue:

- (void) drawDirectionCue: (NSDictionary *) info

implementation

Provided by category HeadUpDisplay(Private).

Definition at line 2841 of file HeadUpDisplay.m.

                         :(NSDictionary *)info
{
    GLfloat             alpha = overallAlpha;
    struct CachedInfo   cached;
    
    [(NSValue *)[sCurrentDrawItem objectAtIndex:WIDGET_CACHE] getValue:&cached];
    
    alpha *= cached.alpha;
    
    if ([UNIVERSE displayGUI])  return;
    
    Entity      *target = [PLAYER primaryTarget];
    if (target == nil)  return;
    
    // draw the direction cue
    OOMatrix    rotMatrix;
    
    rotMatrix = [PLAYER rotationMatrix];
    
    if ([UNIVERSE viewDirection] != VIEW_GUI_DISPLAY)
    {
        const GLfloat innerSize = CROSSHAIR_SIZE;
        const GLfloat width = CROSSHAIR_SIZE * ONE_EIGHTH;
        const GLfloat outerSize = CROSSHAIR_SIZE * (1.0f + ONE_EIGHTH + ONE_EIGHTH);
        const float visMin = 0.994521895368273f;    // cos(6 degrees)
        const float visMax = 0.984807753012208f;    // cos(10 degrees)
        
        // Transform the view
        Vector rpn = [PLAYER vectorTo:target];
        rpn = OOVectorMultiplyMatrix(rpn, rotMatrix);
        Vector drawPos = rpn;
        Vector forward = kZeroVector;
        
        switch ([UNIVERSE viewDirection])
        {
            case VIEW_FORWARD:
                forward = kBasisZVector;
                break;
            case VIEW_AFT:
                drawPos.x = - drawPos.x;
                forward = vector_flip(kBasisZVector);
                break;
            case VIEW_PORT:
                drawPos.x = drawPos.z;
                forward = vector_flip(kBasisXVector);
                break;
            case VIEW_STARBOARD:
                drawPos.x = -drawPos.z;
                forward = kBasisXVector;
                break;
            case VIEW_CUSTOM:
                return;
            
            default:
                break;
        }
        
        float cosAngle = dot_product(vector_normal(rpn), forward);
        float visibility = 1.0f - ((visMax - cosAngle) * (1.0f / (visMax - visMin)));
        alpha *= OOClamp_0_1_f(visibility);
        
        if (alpha > 0.0f)
        {
            NSUInteger cueColorIndex = [target isWormhole] ? OO_RETICLE_COLOR_WORMHOLE : OO_RETICLE_COLOR_TARGET;
            OOColor *directionCueColor = [_reticleColors objectAtIndex:cueColorIndex];
            GLfloat clearColorArray[4] =    {[directionCueColor redComponent],
                                            [directionCueColor greenComponent],
                                            [directionCueColor blueComponent],
                                            0.0f};
            GLfloat directionCueColorArray[4] = {[directionCueColor redComponent],
                                                [directionCueColor greenComponent],
                                                [directionCueColor blueComponent],
                                                [directionCueColor alphaComponent]};
            drawPos.z = 0.0f;   // flatten vector
            drawPos = vector_normal(drawPos);
            OOGLBEGIN(GL_LINE_STRIP);
                glColor4fv(clearColorArray);
                glVertex3f(drawPos.x * innerSize - drawPos.y * width, drawPos.y * innerSize + drawPos.x * width, z1);
                GLColorWithOverallAlpha(directionCueColorArray, alpha);
                glVertex3f(drawPos.x * outerSize, drawPos.y * outerSize, z1);
                glColor4fv(clearColorArray);
                glVertex3f(drawPos.x * innerSize + drawPos.y * width, drawPos.y * innerSize - drawPos.x * width, z1);
            OOGLEND();
        }
    }
}

References CachedInfo::alpha, OOColor::alphaComponent, OOColor::blueComponent, CROSSHAIR_SIZE, OOColor::greenComponent, Entity::isWormhole, kBasisXVector, kBasisZVector, kZeroVector, nil, ONE_EIGHTH, OO_RETICLE_COLOR_TARGET, OO_RETICLE_COLOR_WORMHOLE, OOGLBEGIN, OOGLEND, OOVectorMultiplyMatrix(), OOColor::redComponent, and UNIVERSE.

Referenced by HeadUpDisplay(Private)::drawTargetReticle:.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ drawEnergyGauge:

- (void) drawEnergyGauge: (NSDictionary *) info

implementation

Provided by category HeadUpDisplay(Private).

Definition at line 2155 of file HeadUpDisplay.m.

                        :(NSDictionary *)info
{
    int                 x, y;
    unsigned            i;
    NSSize              siz;
    BOOL                drawSurround, labelled, energyCritical = NO;
    GLfloat             alpha = overallAlpha;
    GLfloat             bankHeight, bankY;
    PlayerEntity *player = PLAYER;
 
    unsigned n_bars = [player dialMaxEnergy]/64.0;
    n_bars = [info oo_unsignedIntForKey:N_BARS_KEY defaultValue:n_bars];
    if (n_bars < 1)
    {
        n_bars = 1;
    }
    GLfloat             energy = [player dialEnergy] * n_bars;
    struct CachedInfo   cached;
    
    [(NSValue *)[sCurrentDrawItem objectAtIndex:WIDGET_CACHE] getValue:&cached];
    
    x = useDefined(cached.x, ENERGY_GAUGE_CENTRE_X) + [[UNIVERSE gameView] x_offset] * cached.x0;
    y = useDefined(cached.y, ENERGY_GAUGE_CENTRE_Y) + [[UNIVERSE gameView] y_offset] * cached.y0;
    siz.width = useDefined(cached.width, ENERGY_GAUGE_WIDTH);
    siz.height = useDefined(cached.height, ENERGY_GAUGE_HEIGHT);
    alpha *= cached.alpha;
    drawSurround = [info oo_boolForKey:DRAW_SURROUND_KEY defaultValue:ENERGY_GAUGE_DRAW_SURROUND];
    labelled = [info oo_boolForKey:LABELLED_KEY defaultValue:YES];
    if (n_bars > 8)  labelled = NO;
    
    if (drawSurround)
    {
        // draw energy surround
        SET_COLOR_SURROUND(yellow_color);
        hudDrawSurroundAt(x, y, z1, siz);
    }
    
    bankHeight = siz.height / n_bars;
    // draw energy banks    
    NSSize barSize = NSMakeSize(siz.width, bankHeight - 2.0);       // leave a gap between bars
    GLfloat midBank = bankHeight / 2.0f;
    bankY = y - (n_bars - 1) * midBank - 1.0;
    
    // avoid constant colour switching...
    if (labelled)
    {
        GLColorWithOverallAlpha(green_color, alpha);
        GLfloat labelStartX = x + 0.5f * barSize.width + 3.0f;
        NSSize labelSize = NSMakeSize(9.0, (bankHeight < 18.0)? bankHeight : 18.0);
        for (i = 0; i < n_bars; i++)
        {
            OODrawString([NSString stringWithFormat:@"E%x", n_bars - i], labelStartX, bankY - midBank, z1, labelSize);
            bankY += bankHeight;
        }
    }
    
    if (energyCritical)
    {
        SET_COLOR_LOW(red_color);
    }
    else
    {
        SET_COLOR_MEDIUM(yellow_color);
    }
    bankY = y - (n_bars - 1) * midBank;
    for (i = 0; i < n_bars; i++)
    {
        if (energy > 1.0)
        {
            hudDrawBarAt(x, bankY, z1, barSize, 1.0);
        }
        else if (energy > 0.0)
        {
            hudDrawBarAt(x, bankY, z1, barSize, energy);
        }
        
        energy -= 1.0;
        bankY += bankHeight;
    }
}

References CachedInfo::alpha, PlayerEntity::dialEnergy, PlayerEntity::dialMaxEnergy, ENERGY_GAUGE_CENTRE_X, ENERGY_GAUGE_CENTRE_Y, ENERGY_GAUGE_HEIGHT, ENERGY_GAUGE_WIDTH, green_color, CachedInfo::height, hudDrawBarAt(), hudDrawSurroundAt(), OODrawString(), PLAYER, red_color, SET_COLOR_LOW, SET_COLOR_MEDIUM, SET_COLOR_SURROUND, useDefined(), CachedInfo::width, CachedInfo::x, x, CachedInfo::x0, CachedInfo::y, y, CachedInfo::y0, and yellow_color.

Here is the call graph for this function:

◆ drawForwardShieldBar:

- (void) drawForwardShieldBar: (NSDictionary *) info

implementation

Provided by category HeadUpDisplay(Private).

Definition at line 2237 of file HeadUpDisplay.m.

                             :(NSDictionary *)info
{
    int                 x, y;
    NSSize              siz;
    BOOL                draw_surround;
    GLfloat             alpha = overallAlpha;
    GLfloat             shield = [PLAYER dialForwardShield];
    struct CachedInfo   cached;
    
    [(NSValue *)[sCurrentDrawItem objectAtIndex:WIDGET_CACHE] getValue:&cached];
    
    x = useDefined(cached.x, FORWARD_SHIELD_BAR_CENTRE_X) + [[UNIVERSE gameView] x_offset] * cached.x0;
    y = useDefined(cached.y, FORWARD_SHIELD_BAR_CENTRE_Y) + [[UNIVERSE gameView] y_offset] * cached.y0;
    siz.width = useDefined(cached.width, FORWARD_SHIELD_BAR_WIDTH);
    siz.height = useDefined(cached.height, FORWARD_SHIELD_BAR_HEIGHT);
    alpha *= cached.alpha;
    draw_surround = [info oo_boolForKey:DRAW_SURROUND_KEY defaultValue:FORWARD_SHIELD_BAR_DRAW_SURROUND];
    
    if (draw_surround)
    {
        // draw forward_shield surround
        SET_COLOR_SURROUND(green_color);
        hudDrawSurroundAt(x, y, z1, siz);
    }
    // draw forward_shield bar
    if (shield < .25)
    {
        SET_COLOR_LOW(red_color);
    }
    else if (shield < .80)
    {
        SET_COLOR_MEDIUM(yellow_color);
    } 
    else
    {
        SET_COLOR_HIGH(green_color);
    }
    hudDrawBarAt(x, y, z1, siz, shield);
}

References CachedInfo::alpha, FORWARD_SHIELD_BAR_CENTRE_X, FORWARD_SHIELD_BAR_CENTRE_Y, FORWARD_SHIELD_BAR_HEIGHT, FORWARD_SHIELD_BAR_WIDTH, green_color, CachedInfo::height, hudDrawBarAt(), hudDrawSurroundAt(), red_color, SET_COLOR_HIGH, SET_COLOR_LOW, SET_COLOR_MEDIUM, SET_COLOR_SURROUND, useDefined(), CachedInfo::width, CachedInfo::x, x, CachedInfo::x0, CachedInfo::y, y, CachedInfo::y0, and yellow_color.

Here is the call graph for this function:

◆ drawFPSInfoCounter:

- (void) drawFPSInfoCounter: (NSDictionary *) info

implementation

Provided by category HeadUpDisplay(Private).

Definition at line 3089 of file HeadUpDisplay.m.

                           :(NSDictionary *)info
{
    if (![UNIVERSE displayFPS])  return;
    
    int                 x, y;
    NSSize              siz;
    struct CachedInfo   cached;
    GLfloat             textColor[4] = {0.0, 1.0, 0.0, 1.0};
    
    [(NSValue *)[sCurrentDrawItem objectAtIndex:WIDGET_CACHE] getValue:&cached];
    
    x = useDefined(cached.x, FPSINFO_DISPLAY_X) + [[UNIVERSE gameView] x_offset] * cached.x0;
    y = useDefined(cached.y, FPSINFO_DISPLAY_Y) + [[UNIVERSE gameView] y_offset] * cached.y0;
    siz.width = useDefined(cached.width, FPSINFO_DISPLAY_WIDTH);
    siz.height = useDefined(cached.height, FPSINFO_DISPLAY_HEIGHT);
    
    HPVector playerPos = [PLAYER position];
    NSString *positionInfo = [UNIVERSE expressPosition:playerPos inCoordinateSystem:@"pwm"];
    positionInfo = [NSString stringWithFormat:@"abs %.2f %.2f %.2f / %@", playerPos.x, playerPos.y, playerPos.z, positionInfo];
    
    // We would normally set a variable alpha value here, but in this case we don't.
    // We prefer the FPS counter to be always visible - Nikos 20100405
    GetRGBAArrayFromInfo(info, textColor);
    OOGL(glColor4f(textColor[0], textColor[1], textColor[2], 1.0f));
    OODrawString([PLAYER dial_fpsinfo], x, y, z1, siz);
    
#ifndef NDEBUG
    NSSize siz08 = NSMakeSize(0.8 * siz.width, 0.8 * siz.width);
    NSString *collDebugInfo = [NSString stringWithFormat:@"%@ - %@", [PLAYER dial_objinfo], [UNIVERSE collisionDescription]];
    OODrawString(collDebugInfo, x, y - siz.height, z1, siz);
    
    OODrawString(positionInfo, x, y - 1.8 * siz.height, z1, siz08);
    
    NSString *timeAccelerationFactorInfo = [NSString stringWithFormat:@"TAF: %@%.2f", DESC(@"multiplication-sign"), [UNIVERSE timeAccelerationFactor]];
    OODrawString(timeAccelerationFactorInfo, x, y - 3.2 * siz08.height, z1, siz08);
#endif
}

References FPSINFO_DISPLAY_HEIGHT, FPSINFO_DISPLAY_WIDTH, FPSINFO_DISPLAY_X, FPSINFO_DISPLAY_Y, GetRGBAArrayFromInfo(), CachedInfo::height, OODrawString(), OOGL, PLAYER, UNIVERSE, useDefined(), CachedInfo::width, CachedInfo::x, x, CachedInfo::x0, CachedInfo::y, y, and CachedInfo::y0.

Here is the call graph for this function:

◆ drawFuelBar:

- (void) drawFuelBar: (NSDictionary *) info

implementation

Provided by category HeadUpDisplay(Private).

Definition at line 2319 of file HeadUpDisplay.m.

                    :(NSDictionary *)info
{
    int                 x, y;
    NSSize              siz;
    BOOL                draw_surround;
    float               fu, hr;
    GLfloat             alpha = overallAlpha;
    struct CachedInfo   cached;
    
    [(NSValue *)[sCurrentDrawItem objectAtIndex:WIDGET_CACHE] getValue:&cached];
    
    x = useDefined(cached.x, FUEL_BAR_CENTRE_X) + [[UNIVERSE gameView] x_offset] * cached.x0;
    y = useDefined(cached.y, FUEL_BAR_CENTRE_Y) + [[UNIVERSE gameView] y_offset] * cached.y0;
    siz.width = useDefined(cached.width, FUEL_BAR_WIDTH);
    siz.height = useDefined(cached.height, FUEL_BAR_HEIGHT);
    alpha *= cached.alpha;
    draw_surround = [info oo_boolForKey:DRAW_SURROUND_KEY defaultValue:NO];
    
    if (draw_surround)
    {
        SET_COLOR_SURROUND(green_color);
        hudDrawSurroundAt(x, y, z1, siz);
    }
    
    fu = [PLAYER dialFuel];
    hr = [PLAYER dialHyperRange];
    
    // draw fuel bar
    SET_COLOR_MEDIUM(yellow_color);
    hudDrawBarAt(x, y, z1, siz, fu);
    
    // draw range indicator
    if (hr > 0.0f && hr <= 1.0f)
    {
        if ([PLAYER hasSufficientFuelForJump])
        {
            SET_COLOR_HIGH(green_color);
        }
        else
        {
            SET_COLOR_LOW(red_color);
        }
        hudDrawMarkerAt(x, y, z1, siz, hr);
    }
 
}

References CachedInfo::alpha, FUEL_BAR_CENTRE_X, FUEL_BAR_CENTRE_Y, FUEL_BAR_HEIGHT, FUEL_BAR_WIDTH, green_color, CachedInfo::height, hudDrawBarAt(), hudDrawMarkerAt(), hudDrawSurroundAt(), PLAYER, red_color, SET_COLOR_HIGH, SET_COLOR_LOW, SET_COLOR_MEDIUM, SET_COLOR_SURROUND, useDefined(), CachedInfo::width, CachedInfo::x, x, CachedInfo::x0, CachedInfo::y, y, CachedInfo::y0, and yellow_color.

Here is the call graph for this function:

◆ drawGreenSurround:

- (void) drawGreenSurround: (NSDictionary *) info

implementation

Provided by category HeadUpDisplay(Private).

Definition at line 3318 of file HeadUpDisplay.m.

3318 :(NSDictionary *)info

3319{

3320 [self drawSurroundInternal:info color:green_color];

3321}

References drawSurroundInternal:color:.

Here is the call graph for this function:

◆ drawHighlight

- (void) drawHighlight	(GLfloat)	x
	(GLfloat)	y
	(GLfloat)	z
	(NSSize)	siz
	(GLfloat)	alpha

implementation

Definition at line 3962 of file HeadUpDisplay.m.

{
    // Rounded corners, fading 'shadow' version
    OOGL(glColor4f(0.0f, 0.0f, 0.0f, alpha * 0.4f));    // dark translucent shadow
    
    OOGLBEGIN(GL_POLYGON);
        // thin 'halo' around the 'solid' highlight
        glVertex3f(x + 1.0f , y + siz.height + 2.5f, z);
        glVertex3f(x + siz.width + 3.0f, y + siz.height + 2.5f, z);
        glVertex3f(x + siz.width + 4.5f, y + siz.height + 1.0f, z);
        glVertex3f(x + siz.width + 4.5f, y + 3.0f, z);
        glVertex3f(x + siz.width + 3.0f, y + 1.5f, z);
        glVertex3f(x + 1.0f, y + 1.5f, z);
        glVertex3f(x - 0.5f, y + 3.0f, z);
        glVertex3f(x - 0.5f, y + siz.height + 1.0f, z);
    OOGLEND();
 
    
    OOGLBEGIN(GL_POLYGON);
        glVertex3f(x + 1.0f, y + siz.height + 2.0f, z);
        glVertex3f(x + siz.width + 3.0f, y + siz.height + 2.0f, z);
        glVertex3f(x + siz.width + 4.0f, y + siz.height + 1.0f, z);
        glVertex3f(x + siz.width + 4.0f, y + 3.0f, z);
        glVertex3f(x + siz.width + 3.0f, y + 2.0f, z);
        glVertex3f(x + 1.0f, y + 2.0f, z);
        glVertex3f(x, y + 3.0f, z);
        glVertex3f(x, y + siz.height + 1.0f, z);
    OOGLEND();
}

References OOGL, OOGLBEGIN, OOGLEND, x, and y.

Referenced by OODrawHilightedPlanetInfo, and OODrawHilightedString.

Here is the caller graph for this function:

◆ drawHUDItem:

- (void) drawHUDItem: (NSDictionary *) info

implementation

Provided by category HeadUpDisplay(Private).

Definition at line 1109 of file HeadUpDisplay.m.

                    :(NSDictionary *)info
{
    NSString    *equipment = [info oo_stringForKey:EQUIPMENT_REQUIRED_KEY];
    
    if (equipment != nil && ![PLAYER hasEquipmentItemProviding:equipment])
    {
        return;
    }
 
    // check alert condition
    NSUInteger alertMask = [info oo_unsignedIntForKey:ALERT_CONDITIONS_KEY defaultValue:15];
    // 1=docked, 2=green, 4=yellow, 8=red
    if (alertMask < 15)
    {
        OOAlertCondition alertCondition = [PLAYER alertCondition];
        if (~alertMask & (1 << alertCondition)) {
            return;
        }
    }
 
    BOOL viewOnly = [info oo_boolForKey:VIEWSCREEN_KEY defaultValue:NO];
 
    // 1=docked, 2=green, 4=yellow, 8=red
    if (viewOnly && [PLAYER guiScreen] != GUI_SCREEN_MAIN)
    {
        return;
    }
 
    if (EXPECT_NOT([self hasHidden:[sCurrentDrawItem objectAtIndex:WIDGET_SELECTOR_NAME]]))
    {
        return;
    }
 
    // use the selector value stored during init.
    [self performSelector:[(NSValue *)[sCurrentDrawItem objectAtIndex:WIDGET_SELECTOR] pointerValue] withObject:info];
    OOCheckOpenGLErrors(@"HeadUpDisplay after drawHUDItem %@", info);
    
    OOVerifyOpenGLState();
}

References EXPECT_NOT, nil, OOCheckOpenGLErrors(), OOVerifyOpenGLState, PLAYER, sCurrentDrawItem, and WIDGET_SELECTOR_NAME.

Referenced by HeadUpDisplay(Private)::drawDials.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ drawIconForEmptyPylonAtX:y:width:height:alpha:

- (void) drawIconForEmptyPylonAtX:	(int)	x
y:	(int)	y
width:	(GLfloat)	width
height:	(GLfloat)	height
alpha:	(GLfloat)	alpha

implementation

Definition at line 2631 of file HeadUpDisplay.m.

                                 :(int)x y:(int)y
                            width:(GLfloat)width height:(GLfloat)height alpha:(GLfloat)alpha
{
    OOPolygonSprite *sprite = IconForMissileRole(kDefaultMissileIconKey);
    
    // Draw gray outline.
    OOGLPushModelView();
    OOGLTranslateModelView(make_vector(x - width * 2.0f, y - height * 2.0f, z1));
    OOGLScaleModelView(make_vector(width, height, 1.0f));
    GLColorWithOverallAlpha(lightgray_color, alpha);
    [sprite drawOutline];
    OOGLPopModelView();
}

References GLColorWithOverallAlpha, IconForMissileRole, kDefaultMissileIconKey, lightgray_color, OOGLPopModelView(), OOGLPushModelView(), OOGLScaleModelView(), OOGLTranslateModelView(), x, y, and z1.

Referenced by HeadUpDisplay(Private)::drawMissileDisplay:.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ drawIconForMissile:selected:status:x:y:width:height:alpha:

- (void) drawIconForMissile:	(ShipEntity *)	missile
selected:	(BOOL)	selected
status:	(OOMissileStatus)	status
x:	(int)	x
y:	(int)	y
width:	(GLfloat)	width
height:	(GLfloat)	height
alpha:	(GLfloat)	alpha

implementation

Definition at line 2580 of file HeadUpDisplay.m.

                           :(ShipEntity *)missile
                   selected:(BOOL)selected
                     status:(OOMissileStatus)status
                          x:(int)x y:(int)y
                      width:(GLfloat)width height:(GLfloat)height alpha:(GLfloat)alpha
{
    OOPolygonSprite *sprite = IconForMissileRole([missile primaryRole]);
    
    if (selected)
    {
        // Draw yellow outline.
        OOGLPushModelView();
        OOGLTranslateModelView(make_vector(x - width * 2.0f, y - height * 2.0f, z1));
        OOGLScaleModelView(make_vector(width, height, 1.0f));
        GLColorWithOverallAlpha(yellow_color, alpha);
        [sprite drawOutline];
        OOGLPopModelView();
        
        // Draw black backing, so outline colour isn’t blended into missile colour.
        OOGLPushModelView();
        OOGLTranslateModelView(make_vector(x - width * 2.0f, y - height * 2.0f, z1));
        OOGLScaleModelView(make_vector(width, height, 1.0f));
        GLColorWithOverallAlpha(black_color, alpha);
        [sprite drawFilled];
        OOGLPopModelView();
        
        switch (status)
        {
            case MISSILE_STATUS_SAFE:
                GLColorWithOverallAlpha(green_color, alpha);  break;
            case MISSILE_STATUS_ARMED:
                GLColorWithOverallAlpha(yellow_color, alpha);    break;
            case MISSILE_STATUS_TARGET_LOCKED:
                GLColorWithOverallAlpha(red_color, alpha);      break;
        }
    }
    else
    {
        if ([missile primaryTarget] == nil)  GLColorWithOverallAlpha(green_color, alpha);
        else  GLColorWithOverallAlpha(red_color, alpha);
    }
    
    OOGLPushModelView();
    OOGLTranslateModelView(make_vector(x - width * 2.0f, y - height * 2.0f, z1));
    OOGLScaleModelView(make_vector(width, height, 1.0f));
    [sprite drawFilled];
    OOGLPopModelView();
}

References black_color, GLColorWithOverallAlpha, green_color, IconForMissileRole, MISSILE_STATUS_ARMED, MISSILE_STATUS_SAFE, MISSILE_STATUS_TARGET_LOCKED, nil, OOGLPopModelView(), OOGLPushModelView(), OOGLScaleModelView(), OOGLTranslateModelView(), red_color, x, y, yellow_color, and z1.

Referenced by HeadUpDisplay(Private)::drawMissileDisplay:.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ drawLegend:

- (void) drawLegend: (NSDictionary *) info

implementation

Provided by category HeadUpDisplay(Private).

Definition at line 1034 of file HeadUpDisplay.m.

                   :(NSDictionary *)info
{
    // check if equipment is required
    NSString *equipmentRequired = [info oo_stringForKey:EQUIPMENT_REQUIRED_KEY];
    if (equipmentRequired != nil && ![PLAYER hasEquipmentItemProviding:equipmentRequired])
    {
        return;
    }
 
    // check alert condition
    NSUInteger alertMask = [info oo_unsignedIntForKey:ALERT_CONDITIONS_KEY defaultValue:15];
    // 1=docked, 2=green, 4=yellow, 8=red
    if (alertMask < 15)
    {
        OOAlertCondition alertCondition = [PLAYER alertCondition];
        if (~alertMask & (1 << alertCondition)) {
            return;
        }
    }
 
    BOOL viewOnly = [info oo_boolForKey:VIEWSCREEN_KEY defaultValue:NO];
    // 1=docked, 2=green, 4=yellow, 8=red
    if (viewOnly && [PLAYER guiScreen] != GUI_SCREEN_MAIN)
    {
        return;
    }
 
    // check association with hidden dials
    if ([self hasHidden:[info oo_stringForKey:DIAL_REQUIRED_KEY defaultValue:nil]])
    {
        return;
    }
 
    OOTextureSprite             *legendSprite = nil;
    NSString                    *legendText = nil;
    float                       x, y;
    NSSize                      size;
    GLfloat                     alpha = overallAlpha;
    struct CachedInfo           cached;
    
    [(NSValue *)[sCurrentDrawItem objectAtIndex:WIDGET_CACHE] getValue:&cached];
    
    // if either x or y is missing, use 0 instead
    
    x = useDefined(cached.x, 0.0f) + [[UNIVERSE gameView] x_offset] * cached.x0;
    y = useDefined(cached.y, 0.0f) + [[UNIVERSE gameView] y_offset] * cached.y0;
    alpha *= cached.alpha;
    
    legendSprite = [info objectForKey:SPRITE_KEY];
    if (legendSprite != nil)
    {
        [legendSprite blitCentredToX:x Y:y Z:z1 alpha:alpha];
    }
    else
    {
        legendText = [info oo_stringForKey:TEXT_KEY];
        if (legendText != nil)
        {
            // randomly chosen default width & height
            size.width = useDefined(cached.width, 14.0f);
            size.height = useDefined(cached.height, 8.0f);
            SET_COLOR(green_color);
            if ([info oo_intForKey:@"align"] == 1)
            {
                OODrawStringAligned(legendText, x, y, z1, size, YES);
            }
            else
            {
                OODrawStringAligned(legendText, x, y, z1, size, NO);
            }
        }
    }
}

References CachedInfo::alpha, OOTextureSprite::blitCentredToX:Y:Z:alpha:, DIAL_REQUIRED_KEY, green_color, CachedInfo::height, nil, OODrawStringAligned(), PLAYER, SET_COLOR, useDefined(), CachedInfo::width, CachedInfo::x, x, CachedInfo::x0, CachedInfo::y, y, and CachedInfo::y0.

Referenced by HeadUpDisplay(Private)::drawLegends.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ drawLegends

- (void) drawLegends

implementation

Provided by category HeadUpDisplay(Private).

Definition at line 863 of file HeadUpDisplay.m.

{
    /* Since the order of legend drawing is significant, this loop must be kept
     * as an incrementing one for compatibility with previous Oolite versions.
     * CIM: 28/9/12 */
    z1 = [[UNIVERSE gameView] display_z];
    NSUInteger i, nLegends = [legendArray count];
    for (i = 0; i < nLegends; i++)
    {
        sCurrentDrawItem = [legendArray oo_arrayAtIndex:i];
        [self drawLegend:[sCurrentDrawItem oo_dictionaryAtIndex:WIDGET_INFO]];
    }
}

References drawLegend:, HeadUpDisplay(Private)::drawLegends, and sCurrentDrawItem.

Referenced by HeadUpDisplay(Private)::drawLegends, and renderHUD.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ drawMFDs

- (void) drawMFDs

implementation

Provided by category HeadUpDisplay(Private).

Definition at line 902 of file HeadUpDisplay.m.

{
    NSUInteger i, nMFDs = [mfdArray count];
    NSString *text = nil;
    for (i = 0; i < nMFDs; i++)
    {
        text = [PLAYER multiFunctionText:i];
        if (text != nil)
        {
            sCurrentDrawItem = [mfdArray oo_arrayAtIndex:i];
            [self drawMultiFunctionDisplay:[sCurrentDrawItem oo_dictionaryAtIndex:WIDGET_INFO] withText:text asIndex:i];
        }
    }
}

References HeadUpDisplay(Private)::drawMFDs, drawMultiFunctionDisplay:withText:asIndex:, nil, and sCurrentDrawItem.

Referenced by HeadUpDisplay(Private)::drawMFDs, and renderHUD.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ drawMissileDisplay:

- (void) drawMissileDisplay: (NSDictionary *) info

implementation

Provided by category HeadUpDisplay(Private).

Definition at line 2646 of file HeadUpDisplay.m.

                           :(NSDictionary *)info
{
    int                 x, y, sp;
    NSSize              siz;
    GLfloat             alpha = overallAlpha;
    struct CachedInfo   cached;
    
    [(NSValue *)[sCurrentDrawItem objectAtIndex:WIDGET_CACHE] getValue:&cached];
    
    x = useDefined(cached.x, MISSILES_DISPLAY_X) + [[UNIVERSE gameView] x_offset] * cached.x0;
    y = useDefined(cached.y, MISSILES_DISPLAY_Y) + [[UNIVERSE gameView] y_offset] * cached.y0;
    siz.width = useDefined(cached.width, MISSILE_ICON_WIDTH);
    siz.height = useDefined(cached.height, MISSILE_ICON_HEIGHT);
    alpha *= cached.alpha;
    sp = [info oo_unsignedIntForKey:SPACING_KEY defaultValue:MISSILES_DISPLAY_SPACING];
    
    BOOL weaponsOnline = [PLAYER weaponsOnline];
    if (!weaponsOnline)  alpha *= 0.2f; // darken missile display if weapons are offline
    
    if (![PLAYER dialIdentEngaged])
    {
        OOMissileStatus status = [PLAYER dialMissileStatus];
        NSUInteger i, n_mis = [PLAYER dialMaxMissiles];
        for (i = 0; i < n_mis; i++)
        {
            ShipEntity *missile = [PLAYER missileForPylon:i];
            if (missile)
            {
                [self drawIconForMissile:missile
                                selected:weaponsOnline && i == [PLAYER activeMissile]
                                  status:status
                                       x:x + (int)i * sp + 2 y:y
                                   width:siz.width * 0.25f height:siz.height * 0.25f
                                   alpha:alpha];
            }
            else
            {
                [self drawIconForEmptyPylonAtX:x + (int)i * sp + 2 y:y
                                    width:siz.width * 0.25f height:siz.height * 0.25f alpha:alpha];
            }
        }
    }
    else
    {
        x -= siz.width;
        y -= siz.height * 0.75;
        siz.width *= 0.80;
        sp *= 0.75;
        switch ([PLAYER dialMissileStatus])
        {
            case MISSILE_STATUS_SAFE:
                GLColorWithOverallAlpha(green_color, alpha);  break;
            case MISSILE_STATUS_ARMED:
                GLColorWithOverallAlpha(yellow_color, alpha);    break;
            case MISSILE_STATUS_TARGET_LOCKED:
                GLColorWithOverallAlpha(red_color, alpha);      break;
        }
        OOGLBEGIN(GL_QUADS);
            glVertex3i(x , y, z1);
            glVertex3i(x + siz.width, y, z1);
            glVertex3i(x + siz.width, y + siz.height, z1);
            glVertex3i(x , y + siz.height, z1);
        OOGLEND();
        GLColorWithOverallAlpha(green_color, alpha);
        OODrawString([PLAYER dialTargetName], x + sp, y - 1, z1, NSMakeSize(siz.width, siz.height));
    }
    
}

References CachedInfo::alpha, drawIconForEmptyPylonAtX:y:width:height:alpha:, drawIconForMissile:selected:status:x:y:width:height:alpha:, green_color, CachedInfo::height, MISSILE_ICON_HEIGHT, MISSILE_ICON_WIDTH, MISSILE_STATUS_ARMED, MISSILE_STATUS_SAFE, MISSILE_STATUS_TARGET_LOCKED, MISSILES_DISPLAY_X, MISSILES_DISPLAY_Y, OODrawString(), OOGLBEGIN, OOGLEND, PLAYER, red_color, useDefined(), CachedInfo::width, CachedInfo::x, x, CachedInfo::x0, CachedInfo::y, y, CachedInfo::y0, and yellow_color.

Here is the call graph for this function:

◆ drawMultiFunctionDisplay:withText:asIndex:

- (void) drawMultiFunctionDisplay:	(NSDictionary *)	info
withText:	(NSString *)	text
asIndex:	(NSUInteger)	index

implementation

Provided by category HeadUpDisplay(Private).

Definition at line 3342 of file HeadUpDisplay.m.

                                 :(NSDictionary *)info withText:(NSString *)text asIndex:(NSUInteger)index
{
    PlayerEntity        *player1 = PLAYER;
    struct CachedInfo   cached;
    NSInteger           i, x, y;
    NSSize              siz, tmpsiz;
    if ([player1 guiScreen] != GUI_SCREEN_MAIN) // don't draw on text screens
    {
        return;
    }
    GLfloat alpha = [info oo_nonNegativeFloatForKey:ALPHA_KEY defaultValue:1.0f] * overallAlpha;
    
    GLfloat mfd_color[4] =      {0.0, 1.0, 0.0, 0.9*alpha};
    OOColor *mfdcol = [OOColor colorWithDescription:[info objectForKey:COLOR_KEY]];
    if (mfdcol != nil) 
    {
        [mfdcol getRed:&mfd_color[0] green:&mfd_color[1] blue:&mfd_color[2] alpha:&mfd_color[3]];
    }
    if (index != [player1 activeMFD])
    {
        mfd_color[3] *= 0.75;
    }
    [self drawSurroundInternal:info color:mfd_color];
 
    [(NSValue *)[sCurrentDrawItem objectAtIndex:WIDGET_CACHE] getValue:&cached];
    x = cached.x + [[UNIVERSE gameView] x_offset] * cached.x0;
    y = cached.y + [[UNIVERSE gameView] y_offset] * cached.y0;
    
    siz.width = useDefined(cached.width / 15, MFD_TEXT_WIDTH);
    siz.height = useDefined(cached.height / 10, MFD_TEXT_HEIGHT);
 
    GLfloat x0 = (GLfloat)(x - cached.width/2);
    GLfloat y0 = (GLfloat)(y + cached.height/2);
    GLfloat x1 = (GLfloat)(x + cached.width/2);
    GLfloat y1 = (GLfloat)(y - cached.height/2);
    GLColorWithOverallAlpha(mfd_color, alpha*0.3);
    OOGLBEGIN(GL_QUADS);
        glVertex3f(x0-2,y0+2,z1);
        glVertex3f(x0-2,y1-2,z1);
        glVertex3f(x1+2,y1-2,z1);
        glVertex3f(x1+2,y0+2,z1);
    OOGLEND();
 
    NSString *line = nil;
    NSArray *lines = [text componentsSeparatedByString:@"\n"];
    // text at full opacity
    GLColorWithOverallAlpha(mfd_color, alpha);
    for (i = 0; i < 10 ; i++)
    {
        line = [lines oo_stringAtIndex:i defaultValue:nil];
        if (line != nil)
        {
            y0 -= siz.height;
            // all lines should be shorter than the size of the MFD
            GLfloat textwidth = OORectFromString(line, 0.0f, 0.0f, siz).size.width;
            if (textwidth <= cached.width)
            {
                OODrawString(line, x0, y0, z1, siz);
            }
            else
            {
                // compress it so it fits
                tmpsiz.height = siz.height;
                tmpsiz.width = siz.width * cached.width / textwidth;
                OODrawString(line, x0, y0, z1, tmpsiz);
            }
        }
        else
        {
            break;
        }
    }
}

References OOColor::colorWithDescription:, drawSurroundInternal:color:, OOColor::getRed:green:blue:alpha:, CachedInfo::height, MFD_TEXT_HEIGHT, MFD_TEXT_WIDTH, nil, OODrawString(), OOGLBEGIN, OOGLEND, OORectFromString(), PLAYER, useDefined(), CachedInfo::width, CachedInfo::x, x, CachedInfo::x0, CachedInfo::y, y, and CachedInfo::y0.

Referenced by HeadUpDisplay(Private)::drawMFDs.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ drawPitchBar:

- (void) drawPitchBar: (NSDictionary *) info

implementation

Provided by category HeadUpDisplay(Private).

Definition at line 2096 of file HeadUpDisplay.m.

                     :(NSDictionary *)info
{
    int                 x, y;
    NSSize              siz;
    BOOL                draw_surround;
    GLfloat             alpha = overallAlpha;
    struct CachedInfo   cached;
    
    [(NSValue *)[sCurrentDrawItem objectAtIndex:WIDGET_CACHE] getValue:&cached];
    
    x = useDefined(cached.x, PITCH_BAR_CENTRE_X) + [[UNIVERSE gameView] x_offset] * cached.x0;
    y = useDefined(cached.y, PITCH_BAR_CENTRE_Y) + [[UNIVERSE gameView] y_offset] * cached.y0;
    siz.width = useDefined(cached.width, PITCH_BAR_WIDTH);
    siz.height = useDefined(cached.height, PITCH_BAR_HEIGHT);
    alpha *= cached.alpha;
    draw_surround = [info oo_boolForKey:DRAW_SURROUND_KEY defaultValue:PITCH_BAR_DRAW_SURROUND];
    
    if (draw_surround)
    {
        // draw PITCH surround
        SET_COLOR_SURROUND(green_color);
        hudDrawSurroundAt(x, y, z1, siz);
    }
    // draw PITCH bar
    SET_COLOR(yellow_color);
    hudDrawIndicatorAt(x, y, z1, siz, [PLAYER dialPitch]);
}

References CachedInfo::alpha, green_color, CachedInfo::height, hudDrawIndicatorAt(), hudDrawSurroundAt(), PITCH_BAR_CENTRE_X, PITCH_BAR_CENTRE_Y, PITCH_BAR_HEIGHT, PITCH_BAR_WIDTH, PLAYER, SET_COLOR, SET_COLOR_SURROUND, useDefined(), CachedInfo::width, CachedInfo::x, x, CachedInfo::x0, CachedInfo::y, y, CachedInfo::y0, and yellow_color.

Here is the call graph for this function:

◆ drawPrimedEquipment:

- (void) drawPrimedEquipment: (NSDictionary *) info

implementation

Definition at line 2951 of file HeadUpDisplay.m.

                            :(NSDictionary *)info
{
    if ([PLAYER status] == STATUS_DOCKED)
    {
        // Can't activate equipment while docked
        return;
    }
    
    GLfloat             itemColor[4] = { 0.0f, 1.0f, 0.0f, 1.0f };
    struct CachedInfo   cached;
    
    NSUInteger lines = [info oo_intForKey:@"n_bars" defaultValue:1];
    NSInteger pec = (NSInteger)[PLAYER primedEquipmentCount];
 
    [(NSValue *)[sCurrentDrawItem objectAtIndex:WIDGET_CACHE] getValue:&cached];
    
    NSInteger x = useDefined(cached.x, PRIMED_DISPLAY_X) + [[UNIVERSE gameView] x_offset] * cached.x0;
    NSInteger y = useDefined(cached.y, PRIMED_DISPLAY_Y) + [[UNIVERSE gameView] y_offset] * cached.y0;
    
    NSSize size =
    {
        .width = useDefined(cached.width, PRIMED_DISPLAY_WIDTH),
        .height = useDefined(cached.height, PRIMED_DISPLAY_HEIGHT)
    };
 
    if (pec == 0)
    {
        // Don't display if no primed equipment fitted
        return;
    }
 
    GetRGBAArrayFromInfo(info, itemColor);
    itemColor[3] *= overallAlpha;
 
    if (lines == 1)
    {
        OOGL(glColor4f(itemColor[0], itemColor[1], itemColor[2], itemColor[3]));
        NSString *equipmentName = [PLAYER primedEquipmentName:0];
        OODrawString(OOExpandKey(@"equipment-primed-hud", equipmentName), x, y, z1, size);
    }
    else
    {
        NSInteger negative = (lines - 1) / 2;
        NSInteger positive = lines / 2;
        for (NSInteger i = -negative; i <= positive; i++)
        {
            if (i >= -(pec) / 2 && i <= (pec + 1) / 2)
            {
                // don't display loops if we have more equipment than lines
                // instead compact the display towards its centre
                GLfloat alphaScale = 1.0/((i<0)?(1.0-i):(1.0+i));
                OOGL(glColor4f(itemColor[0], itemColor[1], itemColor[2], itemColor[3]*alphaScale));
                OODrawString([PLAYER primedEquipmentName:i], x, y, z1, size);
            }
            y -= size.height;
        }   
    }
}

References GetRGBAArrayFromInfo(), CachedInfo::height, OODrawString(), OOExpandKey, OOGL, overallAlpha, PLAYER, PRIMED_DISPLAY_HEIGHT, PRIMED_DISPLAY_WIDTH, PRIMED_DISPLAY_X, PRIMED_DISPLAY_Y, useDefined(), CachedInfo::width, CachedInfo::x, x, CachedInfo::x0, CachedInfo::y, y, CachedInfo::y0, and z1.

Here is the call graph for this function:

◆ drawPrimedEquipmentText:

- (void) drawPrimedEquipmentText: (NSDictionary *) info

implementation

Provided by category HeadUpDisplay(Private).

◆ drawRollBar:

- (void) drawRollBar: (NSDictionary *) info

implementation

Provided by category HeadUpDisplay(Private).

Definition at line 2067 of file HeadUpDisplay.m.

                    :(NSDictionary *)info
{
    int                 x, y;
    NSSize              siz;
    BOOL                draw_surround;
    GLfloat             alpha = overallAlpha;
    struct CachedInfo   cached;
    
    [(NSValue *)[sCurrentDrawItem objectAtIndex:WIDGET_CACHE] getValue:&cached];
    
    x = useDefined(cached.x, ROLL_BAR_CENTRE_X) + [[UNIVERSE gameView] x_offset] * cached.x0;
    y = useDefined(cached.y, ROLL_BAR_CENTRE_Y) + [[UNIVERSE gameView] y_offset] * cached.y0;
    siz.width = useDefined(cached.width, ROLL_BAR_WIDTH);
    siz.height = useDefined(cached.height, ROLL_BAR_HEIGHT);
    alpha *= cached.alpha;
    draw_surround = [info oo_boolForKey:DRAW_SURROUND_KEY defaultValue:ROLL_BAR_DRAW_SURROUND];
    
    if (draw_surround)
    {
        // draw ROLL surround
        SET_COLOR_SURROUND(green_color);
        hudDrawSurroundAt(x, y, z1, siz);
    }
    // draw ROLL bar
    SET_COLOR(yellow_color);
    hudDrawIndicatorAt(x, y, z1, siz, [PLAYER dialRoll]);
}

References CachedInfo::alpha, green_color, CachedInfo::height, hudDrawIndicatorAt(), hudDrawSurroundAt(), PLAYER, ROLL_BAR_CENTRE_X, ROLL_BAR_CENTRE_Y, ROLL_BAR_HEIGHT, ROLL_BAR_WIDTH, SET_COLOR, SET_COLOR_SURROUND, useDefined(), CachedInfo::width, CachedInfo::x, x, CachedInfo::x0, CachedInfo::y, y, CachedInfo::y0, and yellow_color.

Here is the call graph for this function:

◆ drawScanner:

- (void) drawScanner: (NSDictionary *) info

implementation

Provided by category HeadUpDisplay(Private).

Definition at line 1180 of file HeadUpDisplay.m.

                    :(NSDictionary *)info
{
    int             i, x, y;
    NSSize          siz;
    GLfloat         scanner_color[4] = { 1.0, 0.0, 0.0, 1.0 };
    
    BOOL            emptyDial = ([info oo_floatForKey:ALPHA_KEY] == 0.0f);
        
    BOOL            isHostile = NO;
 
    BOOL            inColorBlindMode = [UNIVERSE colorblindMode] != OO_POSTFX_NONE;
    
    if (emptyDial)
    {
        // we can skip a lot of code.
        x = y = 0;
        scanner_color[3] = 0.0;         // nothing to see!
        siz = NSMakeSize(1.0, 1.0);     // avoid divide by 0s
    }
    else
    {
        struct CachedInfo   cached;
    
        [(NSValue *)[sCurrentDrawItem objectAtIndex:WIDGET_CACHE] getValue:&cached];
        
        x = useDefined(cached.x, SCANNER_CENTRE_X) + [[UNIVERSE gameView] x_offset] * cached.x0;
        y = useDefined(cached.y, SCANNER_CENTRE_Y) + [[UNIVERSE gameView] y_offset] * cached.y0;
        siz.width = useDefined(cached.width, SCANNER_WIDTH);
        siz.height = useDefined(cached.height, SCANNER_HEIGHT);
 
        GetRGBAArrayFromInfo(info, scanner_color);
        
        scanner_color[3] *= overallAlpha;
    }
    
    GLfloat         alpha = scanner_color[3];
    GLfloat         col[4] = { 1.0, 1.0, 1.0, alpha };  // temporary colour variable
    
    GLfloat         z_factor = siz.height / siz.width;  // approx 1/4
    GLfloat         y_factor = 1.0 - sqrt(z_factor);    // approx 1/2
    
    int             scanner_cx = x;
    int             scanner_cy = y;
    
    int             scannerFootprint = SCANNER_MAX_RANGE * 2.5 / siz.width;
    
    GLfloat         zoom = scanner_zoom;
    if (scanner_ultra_zoom)
        zoom = pow(2, zoom - 1.0);
    GLfloat         max_zoomed_range2 = SCANNER_SCALE * SCANNER_SCALE * 10000.0;
    if (!nonlinear_scanner)
    {
        max_zoomed_range2 /= zoom * zoom;
    }
    GLfloat         max_zoomed_range = sqrt(max_zoomed_range2);
    
    if (PLAYER == nil)  return;
    
    OOMatrix        rotMatrix = [PLAYER rotationMatrix];
    Vector          relativePosition;
    int             flash = ((int)([UNIVERSE getTime] * 4))&1;
    
    // use a non-mutable copy so this can't be changed under us.
    int             ent_count       = UNIVERSE->n_entities;
    Entity          **uni_entities  = UNIVERSE->sortedEntities; // grab the public sorted list
    Entity          *my_entities[ent_count];
    Entity          *scannedEntity = nil;
    
    for (i = 0; i < ent_count; i++)
    {
        my_entities[i] = [uni_entities[i] retain];  // retained
    }
    
    if (!emptyDial)
    {
        OOGL(glColor4fv(scanner_color));
        drawScannerGrid(x, y, z1, siz, [UNIVERSE viewDirection], lineWidth, zoom, nonlinear_scanner, minimalistic_scanner);
    }
    
    if ([self checkPlayerInFlight])
    {
        GLfloat upscale = zoom * 1.25 / scannerFootprint;
        GLfloat max_blip = 0.0;
        int drawClass;
        
        OOVerifyOpenGLState();
        
        // Debugging code for nonlinear scanner - draws three fake cascade weapons, which looks pretty and enables me
        // to debug the code without the mass slaughter of innocent civillians.
        //if (nonlinear_scanner)
        //{
        //  Vector p = OOVectorMultiplyMatrix(make_vector(10000.0, 0.0, 0.0), rotMatrix);
        //  GLDrawNonlinearCascadeWeapon( scanner_cx, scanner_cy, z1, siz, p, 5000, zoom, alpha );
        //  p = OOVectorMultiplyMatrix(make_vector(10000.0, 4500.0, 0.0), rotMatrix);
        //  GLDrawNonlinearCascadeWeapon( scanner_cx, scanner_cy, z1, siz, p, 2000, zoom, alpha );
        //  p = OOVectorMultiplyMatrix(make_vector(0.0, 0.0, 20000.0), rotMatrix);
        //  GLDrawNonlinearCascadeWeapon( scanner_cx, scanner_cy, z1, siz, p, 6000, zoom, alpha );
        //}
        for (i = 0; i < ent_count; i++)  // scanner lollypops
        {
            scannedEntity = my_entities[i];
            
            drawClass = [scannedEntity scanClass];
            
            // cloaked ships - and your own one - don't show up on the scanner.
            if (EXPECT_NOT(drawClass == CLASS_PLAYER || ([scannedEntity isShip] && [(ShipEntity *)scannedEntity isCloaked])))
            {
                drawClass = CLASS_NO_DRAW;
            }
            
            if (drawClass != CLASS_NO_DRAW)
            {
                GLfloat x1,y1,y2;
                float   ms_blip = 0.0;
                
                if (emptyDial)  continue;
                
                if (isnan(scannedEntity->zero_distance))
                    continue;
                
                // exit if it's too far away
                GLfloat act_dist = sqrt(scannedEntity->zero_distance);
                GLfloat lim_dist = act_dist - scannedEntity->collision_radius;
                
                // for efficiency, assume no scannable entity > 10km radius
                if (act_dist > max_zoomed_range + 10000.0)
                    break;
 
                if (lim_dist > max_zoomed_range)
                    continue;
                
                // has it sent a recent message
                //
                if ([scannedEntity isShip]) 
                    ms_blip = 2.0 * [(ShipEntity *)scannedEntity messageTime];
                if (ms_blip > max_blip)
                {
                    max_blip = ms_blip;
                    last_transmitter = [scannedEntity universalID];
                }
                ms_blip -= floor(ms_blip);
                
                relativePosition = [PLAYER vectorTo:scannedEntity];
                double fuzz = [PLAYER scannerFuzziness];
                if (fuzz > 0 && ![[UNIVERSE gameController] isGamePaused])
                {
                    relativePosition = vector_add(relativePosition,OOVectorRandomRadial(fuzz));
                }
 
                Vector rp = relativePosition;
                
                if (act_dist > max_zoomed_range)
                    scale_vector(&relativePosition, max_zoomed_range / act_dist);
                
                // rotate the view
                relativePosition = OOVectorMultiplyMatrix(relativePosition, rotMatrix);
                Vector rrp = relativePosition;
                // scale the view
                if (nonlinear_scanner)
                {
                    relativePosition = [HeadUpDisplay nonlinearScannerScale: relativePosition Zoom: zoom Scale: 0.5*siz.width];
                }
                else
                {
                    scale_vector(&relativePosition, upscale);
                }
                
                x1 = relativePosition.x;
                y1 = z_factor * relativePosition.z;
                y2 = y1 + y_factor * relativePosition.y;
                
                isHostile = NO;
                if ([scannedEntity isShip])
                {
                    ShipEntity *ship = (ShipEntity *)scannedEntity;
                    isHostile = (([ship hasHostileTarget])&&([ship primaryTarget] == PLAYER));
                    GLfloat *base_col = [ship scannerDisplayColorForShip:PLAYER :isHostile :flash
                                                                        :[ship scannerDisplayColor1] :[ship scannerDisplayColor2]
                                                                        :[ship scannerDisplayColorHostile1] :[ship scannerDisplayColorHostile2]
                        ];
                    col[0] = base_col[0];   col[1] = base_col[1];   col[2] = base_col[2];   col[3] = alpha * base_col[3];
                }
                else if ([scannedEntity isVisualEffect])
                {
                    OOVisualEffectEntity *vis = (OOVisualEffectEntity *)scannedEntity;
                    GLfloat* base_col = [vis scannerDisplayColorForShip:flash :[vis scannerDisplayColor1] :[vis scannerDisplayColor2]];
                    col[0] = base_col[0];   col[1] = base_col[1];   col[2] = base_col[2];   col[3] = alpha * base_col[3];
                }
 
                if ([scannedEntity isWormhole])
                {
                    col[0] = blue_color[0];   col[1] = (flash)? 1.0 : blue_color[1];    col[2] = blue_color[2];   col[3] = alpha * blue_color[3];
                }
                
                // position the scanner
                x1 += scanner_cx;   y1 += scanner_cy;   y2 += scanner_cy;
 
                if ([scannedEntity isShip])
                {
                    ShipEntity* ship = (ShipEntity*)scannedEntity;
                    if ((!nonlinear_scanner && ship->collision_radius * upscale > 4.5) ||
                        (nonlinear_scanner && nonlinearScannerFunc(act_dist, zoom, siz.width) - nonlinearScannerFunc(lim_dist, zoom, siz.width) > 4.5 ))
                    {
                        Vector bounds[6];
                        BoundingBox bb = ship->totalBoundingBox;
                        bounds[0] = ship->v_forward;   scale_vector(&bounds[0], bb.max.z);
                        bounds[1] = ship->v_forward;   scale_vector(&bounds[1], bb.min.z);
                        bounds[2] = ship->v_right;       scale_vector(&bounds[2], bb.max.x);
                        bounds[3] = ship->v_right;       scale_vector(&bounds[3], bb.min.x);
                        bounds[4] = ship->v_up;         scale_vector(&bounds[4], bb.max.y);
                        bounds[5] = ship->v_up;         scale_vector(&bounds[5], bb.min.y);
                        // rotate the view
                        int i;
                        for (i = 0; i < 6; i++)
                        {
                            bounds[i] = OOVectorMultiplyMatrix(vector_add(bounds[i], rp), rotMatrix);
                            if (nonlinear_scanner)
                            {
                                bounds[i] = [HeadUpDisplay nonlinearScannerScale:bounds[i] Zoom: zoom Scale: 0.5*siz.width];
                            }
                            else
                            {
                                scale_vector(&bounds[i], upscale);
                            }
                            bounds[i] = make_vector(bounds[i].x + scanner_cx, bounds[i].z * z_factor + bounds[i].y * y_factor + scanner_cy, z1 );
                        }
                        // draw the diamond
                        //
                        OOGLBEGIN(GL_QUADS);
                            glColor4f(col[0], col[1], col[2], 0.33333 * col[3]);
                            glVertex3f(bounds[0].x, bounds[0].y, bounds[0].z);    glVertex3f(bounds[4].x, bounds[4].y, bounds[4].z);
                            glVertex3f(bounds[1].x, bounds[1].y, bounds[1].z);    glVertex3f(bounds[5].x, bounds[5].y, bounds[5].z);
                            glVertex3f(bounds[2].x, bounds[2].y, bounds[2].z);    glVertex3f(bounds[4].x, bounds[4].y, bounds[4].z);
                            glVertex3f(bounds[3].x, bounds[3].y, bounds[3].z);    glVertex3f(bounds[5].x, bounds[5].y, bounds[5].z);
                            glVertex3f(bounds[2].x, bounds[2].y, bounds[2].z);    glVertex3f(bounds[0].x, bounds[0].y, bounds[0].z);
                            glVertex3f(bounds[3].x, bounds[3].y, bounds[3].z);    glVertex3f(bounds[1].x, bounds[1].y, bounds[1].z);
                        OOGLEND();
                    }
                }
                
                if (ms_blip > 0.0)
                {
                    DrawSpecialOval(x1 - 0.5, y2 + 1.5, z1, NSMakeSize(16.0 * (1.0 - ms_blip), 8.0 * (1.0 - ms_blip)), 30, col);
                }
                if ([scannedEntity isCascadeWeapon])
                {
                    if (nonlinear_scanner)
                    {
                        GLDrawNonlinearCascadeWeapon( scanner_cx, scanner_cy, z1, siz, rrp, scannedEntity->collision_radius, zoom, alpha );
                    }
                    else
                    {
                        GLfloat r1 = 2.5 + scannedEntity->collision_radius * upscale;
                        GLfloat l2 = r1 * r1 - relativePosition.y * relativePosition.y;
                        GLfloat r0 = (l2 > 0)? sqrt(l2): 0;
                        if (r0 > 0)
                        {
                            OOGL(glColor4f(1.0, 0.5, 1.0, alpha));
                            GLDrawOval(x1  - 0.5, y1 + 1.5, z1, NSMakeSize(r0, r0 * siz.height / siz.width), 20);
                        }
                        OOGL(glColor4f(0.5, 0.0, 1.0, 0.33333 * alpha));
                        GLDrawFilledOval(x1  - 0.5, y2 + 1.5, z1, NSMakeSize(r1, r1), 15);
                    }
                }
                else
                {
 
#if IDENTIFY_SCANNER_LOLLIPOPS
                    if ([scannedEntity isShip])
                    {
                        glColor4f(1.0, 1.0, 0.5, alpha);
                        OODrawString([(ShipEntity *)scannedEntity displayName], x1 + 2, y2 + 2, z1, NSMakeSize(8, 8));
                    }
#endif
                    glColor4fv(col);
                    if (inColorBlindMode && isHostile)
                    {
                        // in colorblind mode turn hostile blips into X shapes for easier recognition
                        OOGLBEGIN(GL_LINES);
                        glVertex3f(x1+2, y2+3, z1); glVertex3f(x1-3, y2, z1);   glVertex3f(x1+2, y2, z1);   glVertex3f(x1-3, y2+3, z1);
                        OOGLEND();
                    }
                    else
                    {
                        OOGLBEGIN(GL_QUADS);
                        glVertex3f(x1-3, y2, z1);   glVertex3f(x1+2, y2, z1);   glVertex3f(x1+2, y2+3, z1); glVertex3f(x1-3, y2+3, z1); 
                        OOGLEND();
                    }
                    OOGLBEGIN(GL_QUADS); // lollipop tail
                        col[3] *= 0.3333; // one third the alpha
                        glColor4fv(col);
                        glVertex3f(x1, y1, z1); glVertex3f(x1+2, y1, z1);   glVertex3f(x1+2, y2, z1);   glVertex3f(x1, y2, z1);
                    OOGLEND();
                }
            }
        }
        
    }
    
    for (i = 0; i < ent_count; i++)
    {
        [my_entities[i] release];   //  released
    }
    
    OOVerifyOpenGLState();
    
}

References blue_color, HeadUpDisplay(Private)::checkPlayerInFlight, Entity::collision_radius, drawScannerGrid(), DrawSpecialOval(), EXPECT_NOT, GetRGBAArrayFromInfo(), GLDrawFilledOval(), GLDrawNonlinearCascadeWeapon(), GLDrawOval(), ShipEntity::hasHostileTarget, CachedInfo::height, int(), ShipEntity::messageTime, nil, nonlinearScannerFunc(), nonlinearScannerScale:Zoom:Scale:, OO_POSTFX_NONE, OODrawString(), OOGL, OOGLBEGIN, OOGLEND, OOVectorMultiplyMatrix(), OOVectorRandomRadial(), OOVerifyOpenGLState, PLAYER, ShipEntity::primaryTarget, Entity::scanClass, SCANNER_CENTRE_X, SCANNER_CENTRE_Y, SCANNER_HEIGHT, SCANNER_MAX_RANGE, SCANNER_SCALE, SCANNER_WIDTH, OOVisualEffectEntity::scannerDisplayColor1, ShipEntity::scannerDisplayColor1, OOVisualEffectEntity::scannerDisplayColor2, ShipEntity::scannerDisplayColor2, ShipEntity::scannerDisplayColorHostile1, ShipEntity::scannerDisplayColorHostile2, ShipEntity::totalBoundingBox, Entity::universalID, UNIVERSE, useDefined(), ShipEntity::v_forward, ShipEntity::v_right, ShipEntity::v_up, CachedInfo::width, CachedInfo::x, x, CachedInfo::x0, CachedInfo::y, y, CachedInfo::y0, and Entity::zero_distance.

Here is the call graph for this function:

◆ drawScannerGrid

+ (static void) drawScannerGrid	(GLfloat)	x
	(GLfloat)	y
	(GLfloat)	z
	(NSSize)	siz
	(int)	v_dir
	(GLfloat)	thickness
	(GLfloat)	zoom
	(BOOL)	nonlinear
	(BOOL)	minimalistic

implementation

Definition at line 4242 of file HeadUpDisplay.m.

{
    OOSetOpenGLState(OPENGL_STATE_OVERLAY);
 
    MyOpenGLView* gameView = [UNIVERSE gameView];
 
    GLfloat w1, h1;
    GLfloat ww = 0.5 * siz.width;
    GLfloat hh = 0.5 * siz.height;
    
    GLfloat km_scan;
    GLfloat hdiv;
    GLfloat wdiv;
    BOOL drawdiv = NO, drawdiv1 = NO, drawdiv5 = NO;
    
    int i, ii;
    
    OOGL(GLScaledLineWidth(2.0 * thickness));
    GLDrawOval(x, y, z, siz, 4);
    OOGL(GLScaledLineWidth(thickness)); // reset (thickness = lineWidth)
    
    OOGLBEGIN(GL_LINES);
        if (!minimalistic)
        {
            glVertex3f(x, y - hh, z); glVertex3f(x, y + hh, z);
            glVertex3f(x - ww, y, z); glVertex3f(x + ww, y, z);
    
            if (nonlinear)
            {
                if (nonlinearScannerFunc(4000.0, zoom, hh)-nonlinearScannerFunc(3000.0, zoom ,hh) > 2) drawdiv1 = YES;
                if (nonlinearScannerFunc(10000.0, zoom, hh)-nonlinearScannerFunc(5000.0, zoom, hh) > 2) drawdiv5 = YES;
                wdiv = ww/(0.001*SCANNER_MAX_RANGE);
                for (i = 1; 1000.0*i < SCANNER_MAX_RANGE; i++)
                {
                    drawdiv = drawdiv1;
                    w1 = wdiv;
                    if (i % 10 == 0)
                    {
                        w1 = wdiv*4;
                        drawdiv = YES;
                        if (nonlinearScannerFunc((i+5)*1000,zoom,hh) - nonlinearScannerFunc(i*1000.0,zoom,hh)>2)
                        {
                            drawdiv5 = YES;
                        }
                        else
                        {
                            drawdiv5 = NO;
                        }
                    }
                    else if (i % 5 == 0)
                    {
                        w1 = wdiv*2;
                        drawdiv = drawdiv5;
                        if (nonlinearScannerFunc((i+1)*1000,zoom,hh) - nonlinearScannerFunc(i*1000.0,zoom,hh)>2)
                        {
                            drawdiv1 = YES;
                        }
                        else
                        {
                            drawdiv1 = NO;
                        }
                    }
                    if (drawdiv)
                    {
                        h1 = nonlinearScannerFunc(i*1000.0,zoom,hh);
                        glVertex3f(x - w1, y + h1, z);    glVertex3f(x + w1, y + h1, z);
                        glVertex3f(x - w1, y - h1, z);    glVertex3f(x + w1, y - h1, z);
                    }
                }
            }
            else
            {
                km_scan = 0.001 * SCANNER_MAX_RANGE / zoom;    // calculate kilometer divisions
                hdiv = 0.5 * siz.height / km_scan;
                wdiv = 0.25 * siz.width / km_scan;
                if (wdiv < 4.0)
                {
                    wdiv *= 2.0;
                    ii = 5;
                }
                else
                {
                    ii = 1;
                }
        
                for (i = ii; 2.0 * hdiv * i < siz.height; i += ii)
                {
                    h1 = i * hdiv;
                    w1 = wdiv;
                    if (i % 5 == 0)
                        w1 = w1 * 2.5;
                    if (i % 10 == 0)
                        w1 = w1 * 2.0;
                    if (w1 > 3.5)   // don't draw tiny marks
                    {
                        glVertex3f(x - w1, y + h1, z);    glVertex3f(x + w1, y + h1, z);
                        glVertex3f(x - w1, y - h1, z);    glVertex3f(x + w1, y - h1, z);
                    }
                }
            }
        }
 
        double tanfov = [gameView fov:YES];
        GLfloat aspect = [gameView viewSize].width / [gameView viewSize].height;
        if (aspect < 4.0/3.0)
        {
            tanfov *= 0.75 * aspect;
        }
        double cosfov = 1.0/sqrt(1+tanfov*tanfov);
        double sinfov = tanfov * cosfov;
 
        switch (v_dir)
        {
            case VIEW_BREAK_PATTERN:
            case VIEW_GUI_DISPLAY:
            case VIEW_FORWARD:
            case VIEW_NONE:
                glVertex3f(x, y, z); glVertex3f(x - ww * sinfov, y + hh * cosfov, z);
                glVertex3f(x, y, z); glVertex3f(x + ww * sinfov, y + hh * cosfov, z);
                break;
                
            case VIEW_AFT:
                glVertex3f(x, y, z); glVertex3f(x - ww * sinfov, y - hh * cosfov, z);
                glVertex3f(x, y, z); glVertex3f(x + ww * sinfov, y - hh * cosfov, z);
                break;
                
            case VIEW_PORT:
                glVertex3f(x, y, z); glVertex3f(x - ww * cosfov, y + hh * sinfov, z);
                glVertex3f(x, y, z); glVertex3f(x - ww * cosfov, y - hh * sinfov, z);
                break;
                
            case VIEW_STARBOARD:
                glVertex3f(x, y, z); glVertex3f(x + ww * cosfov, y + hh * sinfov, z);
                glVertex3f(x, y, z); glVertex3f(x + ww * cosfov, y - hh * sinfov, z);
                break;
        }
    OOGLEND();
    
    OOVerifyOpenGLState();
}

References MyOpenGLView::fov:, GLDrawOval(), GLScaledLineWidth(), nonlinearScannerFunc(), OOGL, OOGLBEGIN, OOGLEND, OOSetOpenGLState, OOVerifyOpenGLState, OPENGL_STATE_OVERLAY, SCANNER_MAX_RANGE, MyOpenGLView::viewSize, x, and y.

Here is the call graph for this function:

◆ drawScannerZoomIndicator:

- (void) drawScannerZoomIndicator: (NSDictionary *) info

implementation

Provided by category HeadUpDisplay(Private).

Definition at line 1544 of file HeadUpDisplay.m.

                                 :(NSDictionary *)info
{
    int                 x, y;
    NSSize              siz;
    GLfloat             alpha;
    GLfloat             zoom_color[4] = { 1.0f, 0.1f, 0.0f, 1.0f };
    struct CachedInfo   cached;
    
    [(NSValue *)[sCurrentDrawItem objectAtIndex:WIDGET_CACHE] getValue:&cached];
    
    x = useDefined(cached.x, ZOOM_INDICATOR_CENTRE_X) + [[UNIVERSE gameView] x_offset] * cached.x0;
    y = useDefined(cached.y, ZOOM_INDICATOR_CENTRE_Y) + [[UNIVERSE gameView] y_offset] * cached.y0;
    siz.width = useDefined(cached.width, ZOOM_INDICATOR_WIDTH);
    siz.height = useDefined(cached.height, ZOOM_INDICATOR_HEIGHT);
    
    GetRGBAArrayFromInfo(info, zoom_color);
    zoom_color[3] *= overallAlpha;
    alpha = zoom_color[3];
    
    GLfloat cx = x - 0.3 * siz.width;
    GLfloat cy = y - 0.75 * siz.height;
    
    int zl = scanner_zoom;
    if (zl < 1) zl = 1;
    if (zl > SCANNER_ZOOM_LEVELS) zl = SCANNER_ZOOM_LEVELS;
    if (zl == 1) zoom_color[3] *= 0.75;
    if (scanner_ultra_zoom)
        zl = pow(2, zl - 1);
    GLColorWithOverallAlpha(zoom_color, alpha);
    OOGL(glEnable(GL_TEXTURE_2D));
    [sFontTexture apply];
    
    OOGLBEGIN(GL_QUADS);
        if (zl / 10 > 0)
            drawCharacterQuad(48 + zl / 10, cx - 0.8 * siz.width, cy, z1, siz);
        drawCharacterQuad(48 + zl % 10, cx - 0.4 * siz.width, cy, z1, siz);
        drawCharacterQuad(58, cx, cy, z1, siz);
        drawCharacterQuad(49, cx + 0.3 * siz.width, cy, z1, siz);
    OOGLEND();
    
    [OOTexture applyNone];
    OOGL(glDisable(GL_TEXTURE_2D));
}

References OOTexture::apply, OOTexture::applyNone, GetRGBAArrayFromInfo(), CachedInfo::height, OOGL, OOGLBEGIN, OOGLEND, SCANNER_ZOOM_LEVELS, useDefined(), CachedInfo::width, CachedInfo::x, x, CachedInfo::x0, CachedInfo::y, y, CachedInfo::y0, ZOOM_INDICATOR_CENTRE_X, ZOOM_INDICATOR_CENTRE_Y, ZOOM_INDICATOR_HEIGHT, and ZOOM_INDICATOR_WIDTH.

Here is the call graph for this function:

◆ drawScoopStatus:

- (void) drawScoopStatus: (NSDictionary *) info

implementation

Provided by category HeadUpDisplay(Private).

Definition at line 3128 of file HeadUpDisplay.m.

                        :(NSDictionary *)info
{
    int                 i, x, y;
    NSSize              siz;
    GLfloat             alpha;
    struct CachedInfo   cached;
    
    [(NSValue *)[sCurrentDrawItem objectAtIndex:WIDGET_CACHE] getValue:&cached];
    
    x = useDefined(cached.x, SCOOPSTATUS_CENTRE_X) + [[UNIVERSE gameView] x_offset] * cached.x0;
    y = useDefined(cached.y, SCOOPSTATUS_CENTRE_Y) + [[UNIVERSE gameView] y_offset] * cached.y0;
    siz.width = useDefined(cached.width, SCOOPSTATUS_WIDTH);
    siz.height = useDefined(cached.height, SCOOPSTATUS_HEIGHT);
    // default alpha value different from all others, won't use cached.alpha
    alpha = [info oo_nonNegativeFloatForKey:ALPHA_KEY defaultValue:0.75f];
    
    const GLfloat* s0_color = red_color;
    GLfloat s1c[4] = { 0.0f, 0.0f, 0.0f, 0.0f };
    GLfloat s2c[4] = { 0.0f, 0.0f, 0.0f, 0.0f };
    GLfloat s3c[4] = { 0.0f, 0.0f, 0.0f, 0.0f };
    int scoop_status = [PLAYER dialFuelScoopStatus];
    GLfloat t = [UNIVERSE getTime];
    GLfloat a1 = alpha * 0.5f * (1.0f + sin(t * 8.0f));
    GLfloat a2 = alpha * 0.5f * (1.0f + sin(t * 8.0f - 1.0f));
    GLfloat a3 = alpha * 0.5f * (1.0f + sin(t * 8.0f - 2.0f));
    
    switch (scoop_status)
    {
        case SCOOP_STATUS_NOT_INSTALLED:
            return; // don't draw
            
        case SCOOP_STATUS_FULL_HOLD:
            s0_color = darkgreen_color;
            alpha *= 0.75;
            break;
            
        case SCOOP_STATUS_ACTIVE:
        case SCOOP_STATUS_OKAY:
            s0_color = green_color;
            break;
    }
    
    for (i = 0; i < 3; i++)
    {
        s1c[i] = s0_color[i];
        s2c[i] = s0_color[i];
        s3c[i] = s0_color[i];
    }
    if (scoop_status == SCOOP_STATUS_FULL_HOLD)
    {
        s3c[0] = red_color[0];
        s3c[1] = red_color[1];
        s3c[2] = red_color[2];
    }
    if (scoop_status == SCOOP_STATUS_ACTIVE)
    {
        s1c[3] = alpha * a1;
        s2c[3] = alpha * a2;
        s3c[3] = alpha * a3;
    }
    else
    {
        s1c[3] = alpha;
        s2c[3] = alpha;
        s3c[3] = alpha;
    }
    
    GLfloat w1 = siz.width / 8.0;
    GLfloat w2 = 2.0 * w1;
//  GLfloat w3 = 3.0 * w1;
    GLfloat w4 = 4.0 * w1;
    GLfloat h1 = siz.height / 8.0;
    GLfloat h2 = 2.0 * h1;
    GLfloat h3 = 3.0 * h1;
    GLfloat h4 = 4.0 * h1;
    
    OOGL(glDisable(GL_TEXTURE_2D));
    OOGLBEGIN(GL_QUADS);
    // section 1
        GLColorWithOverallAlpha(s1c, overallAlpha);
        glVertex3f(x, y + h1, z1);  glVertex3f(x - w2, y + h2, z1); glVertex3f(x, y + h3, z1);  glVertex3f(x + w2, y + h2, z1);
    // section 2
        GLColorWithOverallAlpha(s2c, overallAlpha);
        glVertex3f(x, y - h1, z1);  glVertex3f(x - w4, y + h1, z1); glVertex3f(x - w4, y + h2, z1); glVertex3f(x, y, z1);
        glVertex3f(x, y - h1, z1);  glVertex3f(x + w4, y + h1, z1); glVertex3f(x + w4, y + h2, z1); glVertex3f(x, y, z1);
    // section 3
        GLColorWithOverallAlpha(s3c, overallAlpha);
        glVertex3f(x, y - h4, z1);  glVertex3f(x - w2, y - h2, z1); glVertex3f(x - w2, y - h1, z1); glVertex3f(x, y - h2, z1);
        glVertex3f(x, y - h4, z1);  glVertex3f(x + w2, y - h2, z1); glVertex3f(x + w2, y - h1, z1); glVertex3f(x, y - h2, z1);
    OOGLEND();
}

References darkgreen_color, green_color, CachedInfo::height, OOGL, OOGLBEGIN, OOGLEND, red_color, SCOOP_STATUS_ACTIVE, SCOOP_STATUS_FULL_HOLD, SCOOP_STATUS_NOT_INSTALLED, SCOOP_STATUS_OKAY, SCOOPSTATUS_CENTRE_X, SCOOPSTATUS_CENTRE_Y, SCOOPSTATUS_HEIGHT, SCOOPSTATUS_WIDTH, useDefined(), CachedInfo::width, CachedInfo::x, x, CachedInfo::x0, CachedInfo::y, y, and CachedInfo::y0.

Here is the call graph for this function:

◆ drawSecondaryTargetReticle:

- (void) drawSecondaryTargetReticle: (NSDictionary *) info

implementation

Provided by category HeadUpDisplay(Private).

Definition at line 2733 of file HeadUpDisplay.m.

                                   :(NSDictionary *)info
{
    GLfloat alpha = [info oo_nonNegativeFloatForKey:ALPHA_KEY defaultValue:1.0f] * overallAlpha * 0.4;
    
    PlayerEntity *player = PLAYER;
    if ([player hasEquipmentItemProviding:@"EQ_TARGET_MEMORY"])
    {
        // needs target memory to be working in addition to any other equipment
        // this item may be bound to
        NSMutableArray *targetMemory = [player targetMemory];
        ShipEntity *primary = [player primaryTarget];
        for (unsigned i = 0; i < PLAYER_TARGET_MEMORY_SIZE; i++)
        {
            id sec_id = [targetMemory objectAtIndex:i];
            // isProxy = weakref ; not = NSNull (in this case...)
            // can't use isKindOfClass because that throws
            // NSInvalidArgumentException when called on a weakref
            // with a dropped object.
            // TODO: fix OOWeakReference so isKindOfClass works
            if (sec_id != nil && [sec_id isProxy])
            {
                ShipEntity *secondary = [(OOWeakReference *)sec_id weakRefUnderlyingObject];
                if (secondary != nil && secondary != primary)
                {
                    if ([secondary zeroDistance] <= SCANNER_MAX_RANGE2 && [secondary isInSpace])
                    {
                        hudDrawReticleOnTarget(secondary, PLAYER, z1, alpha, NO, nil, YES, NO, info, _reticleColors);    
                    }           
                }
            }
        }
    }
}

References hudDrawReticleOnTarget(), nil, PLAYER, PLAYER_TARGET_MEMORY_SIZE, ShipEntity::primaryTarget, SCANNER_MAX_RANGE2, PlayerEntity::targetMemory, and OOWeakReference::weakRefUnderlyingObject.

Referenced by HeadUpDisplay(Private)::drawTargetReticle:.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DrawSpecialOval

+ (static void) DrawSpecialOval	(GLfloat)	x
	(GLfloat)	y
	(GLfloat)	z
	(NSSize)	siz
	(GLfloat)	step
	(GLfloat *)	color4v

implementation

Definition at line 4384 of file HeadUpDisplay.m.

{
    GLfloat         ww = 0.5 * siz.width;
    GLfloat         hh = 0.5 * siz.height;
    GLfloat         theta;
    GLfloat         delta;
    GLfloat         s;
    
    delta = step * M_PI / 180.0f;
    
    OOGLBEGIN(GL_LINE_LOOP);
        for (theta = 0.0f; theta < (2.0f * M_PI); theta += delta)
        {
            s = sin(theta);
            glColor4f(color4v[0], color4v[1], color4v[2], fabs(s * color4v[3]));
            glVertex3f(x + ww * s, y + hh * cos(theta), z);
        }
    OOGLEND();
}

References M_PI, OOGLBEGIN, OOGLEND, x, and y.

◆ drawSpeedBar:

- (void) drawSpeedBar: (NSDictionary *) info

implementation

Provided by category HeadUpDisplay(Private).

Definition at line 2023 of file HeadUpDisplay.m.

                     :(NSDictionary *)info
{
    int                 x, y;
    NSSize              siz;
    BOOL                draw_surround;
    GLfloat             alpha = overallAlpha;
    GLfloat             ds = [PLAYER dialSpeed];
    struct CachedInfo   cached;
    
    [(NSValue *)[sCurrentDrawItem objectAtIndex:WIDGET_CACHE] getValue:&cached];
    
    x = useDefined(cached.x, SPEED_BAR_CENTRE_X) + [[UNIVERSE gameView] x_offset] * cached.x0;
    y = useDefined(cached.y, SPEED_BAR_CENTRE_Y) + [[UNIVERSE gameView] y_offset] * cached.y0;
    siz.width = useDefined(cached.width, SPEED_BAR_WIDTH);
    siz.height = useDefined(cached.height, SPEED_BAR_HEIGHT);
    alpha *= cached.alpha;
    
    draw_surround = [info oo_boolForKey:DRAW_SURROUND_KEY defaultValue:SPEED_BAR_DRAW_SURROUND];
    
    
    SET_COLOR_SURROUND(green_color);
    if (draw_surround)
    {
        // draw speed surround
        hudDrawSurroundAt(x, y, z1, siz);
    }
    // draw speed bar
    if (ds > .80)
    {
        SET_COLOR_HIGH(red_color);
    }
    else if (ds > .25)
    {
        SET_COLOR_MEDIUM(yellow_color);
    }
    else
    {
        SET_COLOR_LOW(green_color);
    }
 
    hudDrawBarAt(x, y, z1, siz, ds);
}

References CachedInfo::alpha, green_color, CachedInfo::height, hudDrawBarAt(), hudDrawSurroundAt(), red_color, SET_COLOR_HIGH, SET_COLOR_LOW, SET_COLOR_MEDIUM, SET_COLOR_SURROUND, SPEED_BAR_CENTRE_X, SPEED_BAR_CENTRE_Y, SPEED_BAR_HEIGHT, SPEED_BAR_WIDTH, useDefined(), CachedInfo::width, CachedInfo::x, x, CachedInfo::x0, CachedInfo::y, y, CachedInfo::y0, and yellow_color.

Here is the call graph for this function:

◆ drawStatusLight:

- (void) drawStatusLight: (NSDictionary *) info

implementation

Provided by category HeadUpDisplay(Private).

Definition at line 2785 of file HeadUpDisplay.m.

                        :(NSDictionary *)info
{
    int                 x, y;
    NSSize              siz;
    GLfloat             alpha = overallAlpha;
    BOOL                blueAlert = cloakIndicatorOnStatusLight && [PLAYER isCloaked];
    struct CachedInfo   cached;
    
    [(NSValue *)[sCurrentDrawItem objectAtIndex:WIDGET_CACHE] getValue:&cached];
    
    x = useDefined(cached.x, STATUS_LIGHT_CENTRE_X) + [[UNIVERSE gameView] x_offset] * cached.x0;
    y = useDefined(cached.y, STATUS_LIGHT_CENTRE_Y) + [[UNIVERSE gameView] y_offset] * cached.y0;
    siz.width = useDefined(cached.width, STATUS_LIGHT_HEIGHT);
    siz.height = useDefined(cached.height, STATUS_LIGHT_HEIGHT);
    alpha *= cached.alpha;
    
    GLfloat status_color[4] = { 0.25, 0.25, 0.25, 1.0};
    int alertCondition = [PLAYER alertCondition];
    GLfloat flash_alpha = 0.333 * (2.0f + sin((GLfloat)[UNIVERSE getTime] * 2.5f * alertCondition));
    
    switch(alertCondition)
    {
        case ALERT_CONDITION_RED:
            status_color[0] = red_color[0];
            status_color[1] = red_color[1];
            status_color[2] = blueAlert ? blue_color[2] : red_color[2];
            break;
            
        case ALERT_CONDITION_GREEN:
            status_color[0] = green_color[0];
            status_color[1] = green_color[1];
            status_color[2] = blueAlert ? blue_color[2] : green_color[2];
            break;
            
        case ALERT_CONDITION_YELLOW:
            status_color[0] = yellow_color[0];
            status_color[1] = yellow_color[1];
            status_color[2] = blueAlert ? blue_color[2] : yellow_color[2];
            break;
            
        default:
        case ALERT_CONDITION_DOCKED:
            break;
    }
    status_color[3] = flash_alpha;
    GLColorWithOverallAlpha(status_color, alpha);
    OOGLBEGIN(GL_POLYGON);
    hudDrawStatusIconAt(x, y, z1, siz);
    OOGLEND();
    OOGL(glColor4f(0.25, 0.25, 0.25, alpha));
    OOGLBEGIN(GL_LINE_LOOP);
        hudDrawStatusIconAt(x, y, z1, siz);
    OOGLEND();
}

References ALERT_CONDITION_DOCKED, ALERT_CONDITION_GREEN, ALERT_CONDITION_RED, ALERT_CONDITION_YELLOW, CachedInfo::alpha, blue_color, green_color, CachedInfo::height, hudDrawStatusIconAt(), OOGL, OOGLBEGIN, OOGLEND, red_color, STATUS_LIGHT_CENTRE_X, STATUS_LIGHT_CENTRE_Y, STATUS_LIGHT_HEIGHT, UNIVERSE, useDefined(), CachedInfo::width, CachedInfo::x, x, CachedInfo::x0, CachedInfo::y, y, CachedInfo::y0, and yellow_color.

Here is the call graph for this function:

◆ drawStickSensitivityIndicator:

- (void) drawStickSensitivityIndicator: (NSDictionary *) info

implementation

Provided by category HeadUpDisplay(Private).

Definition at line 3221 of file HeadUpDisplay.m.

                                      :(NSDictionary *)info
{
    GLfloat             x, y;
    NSSize              siz;
    GLfloat             alpha = overallAlpha;
    BOOL                mouse = [PLAYER isMouseControlOn];
    OOJoystickManager   *stickHandler = [OOJoystickManager sharedStickHandler];
    struct CachedInfo   cached;
    
    if (![stickHandler joystickCount])
    {
        return; // no need to draw if no joystick fitted
    }
 
    [(NSValue *)[sCurrentDrawItem objectAtIndex:WIDGET_CACHE] getValue:&cached];
    
    x = useDefined(cached.x, STATUS_LIGHT_CENTRE_X) + [[UNIVERSE gameView] x_offset] * cached.x0;
    y = useDefined(cached.y, STATUS_LIGHT_CENTRE_Y) + [[UNIVERSE gameView] y_offset] * cached.y0;
    siz.width = useDefined(cached.width, STATUS_LIGHT_HEIGHT);
    siz.height = useDefined(cached.height, STATUS_LIGHT_HEIGHT);
    alpha *= cached.alpha;
    
    GLfloat div = [stickHandler getSensitivity];
    
    GLColorWithOverallAlpha(black_color, alpha / 4);
    GLDrawFilledOval(x, y, z1, siz, 10);
    
    GLColorWithOverallAlpha((div < 1.0 || mouse) ? lightgray_color : green_color, alpha);
    OOGL(GLScaledLineWidth(_crosshairWidth * lineWidth));
    
    if (div >= 1.0)
    {
        if (!mouse)
        {
            NSSize siz8th = { siz.width / 8, siz.height / 8 };
            GLDrawFilledOval(x, y, z1, siz8th, 30);
            
            if (div == 1.0) // normal mode
                GLColorWithOverallAlpha(lightgray_color, alpha);
        }
        
        siz.width -= _crosshairWidth * lineWidth / 2;
        siz.height -= _crosshairWidth * lineWidth / 2;
        GLDrawOval(x, y, z1, siz, 10);
    }
    else if (div < 1.0) // insensitive mode (shouldn't happen)
        GLDrawFilledOval(x, y, z1, siz, 10);
 
    OOGL(GLScaledLineWidth(lineWidth)); // reset
}

References CachedInfo::alpha, black_color, OOJoystickManager::getSensitivity, GLDrawFilledOval(), GLDrawOval(), GLScaledLineWidth(), green_color, CachedInfo::height, lightgray_color, OOGL, OOJoystickManager::sharedStickHandler, STATUS_LIGHT_CENTRE_X, STATUS_LIGHT_CENTRE_Y, STATUS_LIGHT_HEIGHT, useDefined(), CachedInfo::width, CachedInfo::x, x, CachedInfo::x0, CachedInfo::y, y, and CachedInfo::y0.

Here is the call graph for this function:

◆ drawSurround:

- (void) drawSurround: (NSDictionary *) info

implementation

Provided by category HeadUpDisplay(Private).

Definition at line 3299 of file HeadUpDisplay.m.

                     :(NSDictionary *)info
{
    GLfloat itemColor[4] = { 0.0f, 1.0f, 0.0f, 1.0f };
    id      colorDesc = [info objectForKey:COLOR_KEY];
    if (colorDesc != nil)
    {
        OOColor *color = [OOColor colorWithDescription:colorDesc];
        if (color != nil)
        {
            itemColor[0] = [color redComponent];
            itemColor[1] = [color greenComponent];
            itemColor[2] = [color blueComponent];
        }
    }
 
    [self drawSurroundInternal:info color:itemColor];
}

References OOColor::blueComponent, OOColor::colorWithDescription:, drawSurroundInternal:color:, OOColor::greenComponent, nil, and OOColor::redComponent.

Here is the call graph for this function:

◆ drawSurroundInternal:color:

- (void) drawSurroundInternal:		(NSDictionary *)	info
color:		(const GLfloat[4])	color

implementation

Provided by category HeadUpDisplay(Private).

Definition at line 3273 of file HeadUpDisplay.m.

                             :(NSDictionary *)info color:(const GLfloat[4])color
{
    NSInteger           x, y;
    NSSize              siz;
    GLfloat             alpha = overallAlpha;
    struct CachedInfo   cached;
    
    [(NSValue *)[sCurrentDrawItem objectAtIndex:WIDGET_CACHE] getValue:&cached];
    
    if (cached.x == NOT_DEFINED || cached.y == NOT_DEFINED || cached.width == NOT_DEFINED || cached.height == NOT_DEFINED)
    {
        return;
    }
        
    x = cached.x + [[UNIVERSE gameView] x_offset] * cached.x0;
    y = cached.y + [[UNIVERSE gameView] y_offset] * cached.y0;
    siz.width = useDefined(cached.width, WEAPONSOFFLINETEXT_WIDTH);
    siz.height = useDefined(cached.height, WEAPONSOFFLINETEXT_HEIGHT);
    alpha *= cached.alpha;
    
    // draw the surround
    GLColorWithOverallAlpha(color, alpha);
    hudDrawSurroundAt(x, y, z1, siz);
}

References CachedInfo::alpha, CachedInfo::height, hudDrawSurroundAt(), NOT_DEFINED, useDefined(), WEAPONSOFFLINETEXT_HEIGHT, WEAPONSOFFLINETEXT_WIDTH, CachedInfo::width, CachedInfo::x, x, CachedInfo::x0, CachedInfo::y, y, and CachedInfo::y0.

Referenced by HeadUpDisplay(Private)::drawGreenSurround:, HeadUpDisplay(Private)::drawMultiFunctionDisplay:withText:asIndex:, HeadUpDisplay(Private)::drawSurround:, and HeadUpDisplay(Private)::drawYellowSurround:.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ drawTargetReticle:

- (void) drawTargetReticle: (NSDictionary *) info

implementation

Provided by category HeadUpDisplay(Private).

Definition at line 2716 of file HeadUpDisplay.m.

                          :(NSDictionary *)info
{
    GLfloat alpha = [info oo_nonNegativeFloatForKey:ALPHA_KEY defaultValue:1.0f] * overallAlpha;
    
    if ([PLAYER primaryTarget] != nil)
    {
        hudDrawReticleOnTarget([PLAYER primaryTarget], PLAYER, z1, alpha, reticleTargetSensitive, propertiesReticleTargetSensitive, NO, YES, info, _reticleColors);
        [self drawDirectionCue:info];
    }
    // extra feature if extra equipment installed
    if ([PLAYER hasEquipmentItemProviding:@"EQ_INTEGRATED_TARGETING_SYSTEM"])
    {
        [self drawSecondaryTargetReticle:info];
    }
}

References drawDirectionCue:, drawSecondaryTargetReticle:, hudDrawReticleOnTarget(), nil, and PLAYER.

Here is the call graph for this function:

◆ drawTrumbles:

- (void) drawTrumbles: (NSDictionary *) info

implementation

Provided by category HeadUpDisplay(Private).

Definition at line 3330 of file HeadUpDisplay.m.

                     :(NSDictionary *)info
{
    OOTrumble** trumbles = [PLAYER trumbleArray];
    NSUInteger i;
    for (i = [PLAYER trumbleCount]; i > 0; i--)
    {
        OOTrumble* trum = trumbles[i - 1];
        [trum drawTrumble: z1];
    }
}

References OOTrumble::drawTrumble:, and PLAYER.

Here is the call graph for this function:

◆ drawWaypoints:

- (void) drawWaypoints: (NSDictionary *) info

implementation

Provided by category HeadUpDisplay(Private).

Definition at line 2768 of file HeadUpDisplay.m.

                      :(NSDictionary *)info
{
    GLfloat alpha = [info oo_nonNegativeFloatForKey:ALPHA_KEY defaultValue:1.0f] * overallAlpha;
    GLfloat scale = [info oo_floatForKey:@"reticle_scale" defaultValue:ONE_SIXTYFOURTH];
 
    NSEnumerator *waypoints = [[UNIVERSE currentWaypoints] objectEnumerator];
    OOWaypointEntity *waypoint = nil;
    Entity *compass = [PLAYER compassTarget];
    
    while ((waypoint = [waypoints nextObject]))
    {
        hudDrawWaypoint(waypoint, PLAYER, z1, alpha, waypoint==compass, scale);
    }
 
}

References hudDrawWaypoint(), nil, and PLAYER.

Here is the call graph for this function:

◆ drawWeaponsOfflineText:

- (void) drawWeaponsOfflineText: (NSDictionary *) info

implementation

Provided by category HeadUpDisplay(Private).

Definition at line 3049 of file HeadUpDisplay.m.

                               :(NSDictionary *)info
{
    OOViewID                    viewID = [UNIVERSE viewDirection];
    GLfloat                     textColor[4] = {0.0f, 1.0f, 0.0f, 1.0f};
 
    if (viewID == VIEW_CUSTOM ||
        overallAlpha == 0.0f ||
        !([PLAYER status] == STATUS_IN_FLIGHT || [PLAYER status] == STATUS_WITCHSPACE_COUNTDOWN) ||
        [UNIVERSE displayGUI]
        )
    {
        // Don't draw weapons offline text
        return;
    }
 
    if (![PLAYER weaponsOnline])
    {
        int                 x, y;
        NSSize              siz;
        GLfloat             alpha = overallAlpha;
        struct CachedInfo   cached;
    
        [(NSValue *)[sCurrentDrawItem objectAtIndex:WIDGET_CACHE] getValue:&cached];
        
        x = useDefined(cached.x, WEAPONSOFFLINETEXT_DISPLAY_X) + [[UNIVERSE gameView] x_offset] * cached.x0;
        y = useDefined(cached.y, WEAPONSOFFLINETEXT_DISPLAY_Y) + [[UNIVERSE gameView] y_offset] * cached.y0;
        siz.width = useDefined(cached.width, WEAPONSOFFLINETEXT_WIDTH);
        siz.height = useDefined(cached.height, WEAPONSOFFLINETEXT_HEIGHT);
        alpha *= cached.alpha;
        
        GetRGBAArrayFromInfo(info, textColor);
        textColor[3] *= overallAlpha;
        
        OOGL(glColor4f(textColor[0], textColor[1], textColor[2], textColor[3]));
        // TODO: some caching required...
        OODrawString(DESC(@"weapons-systems-offline"), x, y, z1, siz);
    }
}

References CachedInfo::alpha, DESC, GetRGBAArrayFromInfo(), CachedInfo::height, OODrawString(), OOGL, PLAYER, UNIVERSE, useDefined(), WEAPONSOFFLINETEXT_DISPLAY_X, WEAPONSOFFLINETEXT_DISPLAY_Y, WEAPONSOFFLINETEXT_HEIGHT, WEAPONSOFFLINETEXT_WIDTH, CachedInfo::width, CachedInfo::x, x, CachedInfo::x0, CachedInfo::y, y, and CachedInfo::y0.

Here is the call graph for this function:

◆ drawWeaponTempBar:

- (void) drawWeaponTempBar: (NSDictionary *) info

implementation

Provided by category HeadUpDisplay(Private).

Definition at line 2453 of file HeadUpDisplay.m.

                          :(NSDictionary *)info
{
    int                 x, y;
    NSSize              siz;
    BOOL                draw_surround;
    GLfloat             temp = [PLAYER laserHeatLevel];
    GLfloat             alpha = overallAlpha;
    struct CachedInfo   cached;
    
    [(NSValue *)[sCurrentDrawItem objectAtIndex:WIDGET_CACHE] getValue:&cached];
    
    x = useDefined(cached.x, WEAPON_TEMP_BAR_CENTRE_X) + [[UNIVERSE gameView] x_offset] * cached.x0;
    y = useDefined(cached.y, WEAPON_TEMP_BAR_CENTRE_Y) + [[UNIVERSE gameView] y_offset] * cached.y0;
    siz.width = useDefined(cached.width, WEAPON_TEMP_BAR_WIDTH);
    siz.height = useDefined(cached.height, WEAPON_TEMP_BAR_HEIGHT);
    alpha *= cached.alpha;
    draw_surround = [info oo_boolForKey:DRAW_SURROUND_KEY defaultValue:NO];
    
    if (draw_surround)
    {
        SET_COLOR_SURROUND(green_color);
        hudDrawSurroundAt(x, y, z1, siz);
    }
    
    // draw weapon_temp bar (only need to call GLColor() once!)
    if (temp > .80)
        SET_COLOR_HIGH(red_color);
    else if (temp > .25)
        SET_COLOR_MEDIUM(yellow_color);
    else
        SET_COLOR_LOW(green_color);
    hudDrawBarAt(x, y, z1, siz, temp);
}

References CachedInfo::alpha, green_color, CachedInfo::height, hudDrawBarAt(), hudDrawSurroundAt(), red_color, SET_COLOR_HIGH, SET_COLOR_LOW, SET_COLOR_MEDIUM, SET_COLOR_SURROUND, useDefined(), WEAPON_TEMP_BAR_CENTRE_X, WEAPON_TEMP_BAR_CENTRE_Y, WEAPON_TEMP_BAR_HEIGHT, WEAPON_TEMP_BAR_WIDTH, CachedInfo::width, CachedInfo::x, x, CachedInfo::x0, CachedInfo::y, y, CachedInfo::y0, and yellow_color.

Here is the call graph for this function:

◆ drawWitchspaceDestination:

- (void) drawWitchspaceDestination: (NSDictionary *) info

implementation

Provided by category HeadUpDisplay(Private).

Definition at line 2367 of file HeadUpDisplay.m.

                                  :(NSDictionary *)info
{
    // A zero-distance jump counts as 0.1LY
    if ([PLAYER dialHyperRange] == 0.0f)
    {
        return;
    }
 
    int                 x, y;
    NSSize              siz;
    GLfloat             alpha = overallAlpha;
 
    struct CachedInfo   cached;
 
    [(NSValue *)[sCurrentDrawItem objectAtIndex:WIDGET_CACHE] getValue:&cached];
    
    x = useDefined(cached.x, WITCHDEST_CENTRE_X) + [[UNIVERSE gameView] x_offset] * cached.x0;
    y = useDefined(cached.y, WITCHDEST_CENTRE_Y) + [[UNIVERSE gameView] y_offset] * cached.y0;
    siz.width = useDefined(cached.width, WITCHDEST_WIDTH);
    siz.height = useDefined(cached.height, WITCHDEST_HEIGHT);
    alpha *= cached.alpha;
    NSString *dest = [UNIVERSE getSystemName:[PLAYER targetSystemID]];
    NSInteger concealment = [[[UNIVERSE systemManager] getPropertiesForSystem:[PLAYER targetSystemID] inGalaxy:[PLAYER galaxyNumber]] oo_intForKey:@"concealment" defaultValue:OO_SYSTEMCONCEALMENT_NONE];
    if (concealment >= OO_SYSTEMCONCEALMENT_NONAME) dest = DESC(@"status-unknown-system");
 
    SET_COLOR(green_color);
    
    if ([info oo_intForKey:@"align"] == 1)
    {
        OODrawStringAligned(dest, x, y, z1, siz, YES);
    }
    else
    {
        OODrawStringAligned(dest, x, y, z1, siz, NO);
    }
 
}

References CachedInfo::alpha, DESC, green_color, CachedInfo::height, OO_SYSTEMCONCEALMENT_NONAME, OODrawStringAligned(), PLAYER, SET_COLOR, useDefined(), CachedInfo::width, WITCHDEST_CENTRE_X, WITCHDEST_CENTRE_Y, WITCHDEST_HEIGHT, WITCHDEST_WIDTH, CachedInfo::x, x, CachedInfo::x0, CachedInfo::y, y, and CachedInfo::y0.

Here is the call graph for this function:

◆ drawYawBar:

- (void) drawYawBar: (NSDictionary *) info

implementation

Provided by category HeadUpDisplay(Private).

Definition at line 2125 of file HeadUpDisplay.m.

                   :(NSDictionary *)info
{
    int                 x, y;
    NSSize              siz;
    BOOL                draw_surround;
    GLfloat             alpha = overallAlpha;
    struct CachedInfo   cached;
    
    [(NSValue *)[sCurrentDrawItem objectAtIndex:WIDGET_CACHE] getValue:&cached];
    
    // No standard YAW definitions - using PITCH ones instead.
    x = useDefined(cached.x, PITCH_BAR_CENTRE_X) + [[UNIVERSE gameView] x_offset] * cached.x0;
    y = useDefined(cached.y, PITCH_BAR_CENTRE_Y) + [[UNIVERSE gameView] y_offset] * cached.y0;
    siz.width = useDefined(cached.width, PITCH_BAR_WIDTH);
    siz.height = useDefined(cached.height, PITCH_BAR_HEIGHT);
    alpha *= cached.alpha;
    draw_surround = [info oo_boolForKey:DRAW_SURROUND_KEY defaultValue:PITCH_BAR_DRAW_SURROUND];
    
    if (draw_surround)
    {
        // draw YAW surround
        SET_COLOR_SURROUND(green_color);
        hudDrawSurroundAt(x, y, z1, siz);
    }
    // draw YAW bar
    SET_COLOR(yellow_color);
    hudDrawIndicatorAt(x, y, z1, siz, [PLAYER dialYaw]);
}

References CachedInfo::alpha, green_color, CachedInfo::height, hudDrawIndicatorAt(), hudDrawSurroundAt(), PITCH_BAR_CENTRE_X, PITCH_BAR_CENTRE_Y, PITCH_BAR_HEIGHT, PITCH_BAR_WIDTH, PLAYER, SET_COLOR, SET_COLOR_SURROUND, useDefined(), CachedInfo::width, CachedInfo::x, x, CachedInfo::x0, CachedInfo::y, y, CachedInfo::y0, and yellow_color.

Here is the call graph for this function:

◆ drawYellowSurround:

- (void) drawYellowSurround: (NSDictionary *) info

implementation

Provided by category HeadUpDisplay(Private).

Definition at line 3324 of file HeadUpDisplay.m.

3324 :(NSDictionary *)info

3325{

3326 [self drawSurroundInternal:info color:yellow_color];

3327}

References drawSurroundInternal:color:.

Here is the call graph for this function:

◆ GLColorWithOverallAlpha

- (OOINLINE void) GLColorWithOverallAlpha		(const GLfloat *)	color
		(GLfloat)	alpha

implementation

Definition at line 214 of file HeadUpDisplay.m.

215{

216 // NO OOGL(), this is called within immediate mode blocks.

217 glColor4f(color[0], color[1], color[2], color[3] * alpha);

218}

References OOINLINE.

Referenced by drawIconForEmptyPylonAtX:y:width:height:alpha:, drawIconForMissile:selected:status:x:y:width:height:alpha:, hudDrawReticleOnTarget, and hudDrawWaypoint.

Here is the caller graph for this function:

◆ GLDrawNonlinearCascadeWeapon

+ (static void) GLDrawNonlinearCascadeWeapon	(GLfloat)	x
	(GLfloat)	y
	(GLfloat)	z
	(NSSize)	siz
	(Vector)	centre
	(GLfloat)	radius
	(GLfloat)	zoom
	(GLfloat)	alpha

implementation

Definition at line 4156 of file HeadUpDisplay.m.

{
    Vector spacepos, scannerpos;
    GLfloat theta, phi;
    GLfloat z_factor = siz.height / siz.width;  // approx 1/4
    GLfloat y_factor = 1.0 - sqrt(z_factor);    // approx 1/2
    OOGLVector *points = malloc(sizeof(OOGLVector)*25);
    int i, j;
    
    if (radius*radius > centre.y*centre.y)
    {
        GLfloat r0 = sqrt(radius*radius-centre.y*centre.y);
        OOGL(glColor4f(1.0, 0.5, 1.0, alpha));
        spacepos.y = 0;
        for (i = 0; i < 24; i++)
        {
            theta = i*2*M_PI/24;
            spacepos.x = centre.x + r0 * cos(theta);
            spacepos.z = centre.z + r0 * sin(theta);
            scannerpos = [HeadUpDisplay nonlinearScannerScale: spacepos Zoom: zoom Scale: 0.5*siz.width];
            points[i].x = x + scannerpos.x;
            points[i].y = y + scannerpos.z * z_factor + scannerpos.y * y_factor;
            points[i].z = z;
        }
        spacepos.x = centre.x + r0;
        spacepos.y = 0;
        spacepos.z = centre.z;
        scannerpos = [HeadUpDisplay nonlinearScannerScale: spacepos Zoom: zoom Scale: 0.5*siz.width];
        points[24].x = x + scannerpos.x;
        points[24].y = y + scannerpos.z * z_factor + scannerpos.y * y_factor;
        points[24].z = z;
        GLDrawPoints(points,25);
    }
    OOGL(glColor4f(0.5, 0.0, 1.0, 0.33333 * alpha));
    free(points);
    // Here, we draw a sphere distorted by the nonlinear function. We draw the sphere as a set of horizontal strips
    // The even indices of points are the points on the upper edge of the strip, while odd indices are points
    // on the bottom edge.
    points = malloc(sizeof(OOGLVector)*50);
    spacepos.x = centre.x;
    spacepos.y = centre.y + radius;
    spacepos.z = centre.z;
    scannerpos = [HeadUpDisplay nonlinearScannerScale: spacepos Zoom: zoom Scale: 0.5*siz.width];
    for (i = 0; i <= 24; i++)
    {
        points[2*i+1].x = x + scannerpos.x;
        points[2*i+1].y = y + scannerpos.y * y_factor + scannerpos.z * z_factor;
        points[2*i+1].z = z;
    }
    for (i = 1; i <= 24; i++)
    {
        theta = i*M_PI/24;
        for (j = 0; j <= 24; j++)
        {
            phi = j*M_PI/12;
            // copy point from bottom edge of previous strip into top edge position
            points[2*j] = points[2*j+1];
 
            spacepos.x = centre.x + radius * sin(theta) * cos(phi);
            spacepos.y = centre.y + radius * cos(theta);
            spacepos.z = centre.z + radius * sin(theta) * sin(phi);
            scannerpos = [HeadUpDisplay nonlinearScannerScale: spacepos Zoom: zoom Scale: 0.5*siz.width];
            points[2*j+1].x = x + scannerpos.x;
            points[2*j+1].y = y + scannerpos.y * y_factor + scannerpos.z * z_factor;
            points[2*j+1].z = z;
        }
        GLDrawQuadStrip(points, 50);
    }
    free(points);
    return;
}

References GLDrawPoints(), GLDrawQuadStrip(), M_PI, nonlinearScannerScale:Zoom:Scale:, OOGL, OOGLVector::x, x, OOGLVector::y, y, and OOGLVector::z.

Here is the call graph for this function:

◆ hasHidden:

- (BOOL) hasHidden: (NSString *) selectorName

Definition at line 645 of file HeadUpDisplay.m.

                  :(NSString *)selectorName
{
    if (selectorName == nil)
    {
        return NO;
    }
    return [_hiddenSelectors containsObject:selectorName];
}

References nil.

◆ hudDrawBarAt

+ (static void) hudDrawBarAt	(GLfloat)	x
	(GLfloat)	y
	(GLfloat)	z
	(NSSize)	siz
	(GLfloat)	amount

implementation

Definition at line 3472 of file HeadUpDisplay.m.

{
    GLfloat dial_ox =   x - siz.width/2;
    GLfloat dial_oy =   y - siz.height/2;
    if (fabs(siz.width) > fabs(siz.height))
    {
        GLfloat position =  dial_ox + amount * siz.width;
        
        OOGLBEGIN(GL_QUADS);
            glVertex3f(dial_ox, dial_oy, z);
            glVertex3f(position, dial_oy, z);
            glVertex3f(position, dial_oy+siz.height, z);
            glVertex3f(dial_ox, dial_oy+siz.height, z);
        OOGLEND();
    }
    else
    {
        GLfloat position =  dial_oy + amount * siz.height;
        
        OOGLBEGIN(GL_QUADS);
            glVertex3f(dial_ox, dial_oy, z);
            glVertex3f(dial_ox, position, z);
            glVertex3f(dial_ox+siz.width, position, z);
            glVertex3f(dial_ox+siz.width, dial_oy, z);
        OOGLEND();
    }
}

References OOGLBEGIN, OOGLEND, x, and y.

◆ hudDrawIndicatorAt

+ (static void) hudDrawIndicatorAt	(GLfloat)	x
	(GLfloat)	y
	(GLfloat)	z
	(NSSize)	siz
	(GLfloat)	amount

implementation

Definition at line 3418 of file HeadUpDisplay.m.

{
    if (siz.width > siz.height)
    {
        GLfloat dial_oy =   y - siz.height/2;
        GLfloat position =  x + amount * siz.width / 2;
        OOGLBEGIN(GL_QUADS);
            glVertex3f(position, dial_oy, z);
            glVertex3f(position+2, y, z);
            glVertex3f(position, dial_oy+siz.height, z);
            glVertex3f(position-2, y, z);
        OOGLEND();
    }
    else
    {
        GLfloat dial_ox =   x - siz.width/2;
        GLfloat position =  y + amount * siz.height / 2;
        OOGLBEGIN(GL_QUADS);
            glVertex3f(dial_ox, position, z);
            glVertex3f(x, position+2, z);
            glVertex3f(dial_ox + siz.width, position, z);
            glVertex3f(x, position-2, z);
        OOGLEND();
    }
}

References OOGLBEGIN, OOGLEND, x, and y.

◆ hudDrawMarkerAt

+ (static void) hudDrawMarkerAt	(GLfloat)	x
	(GLfloat)	y
	(GLfloat)	z
	(NSSize)	siz
	(GLfloat)	amount

implementation

Definition at line 3445 of file HeadUpDisplay.m.

{
    if (siz.width > siz.height)
    {
        GLfloat dial_oy =   y - siz.height/2;
        GLfloat position =  x + amount * siz.width - siz.width/2;
        OOGLBEGIN(GL_QUADS);
            glVertex3f(position+1, dial_oy+1, z);
            glVertex3f(position+1, dial_oy+siz.height-1, z);
            glVertex3f(position-1, dial_oy+siz.height-1, z);
            glVertex3f(position-1, dial_oy+1, z);
        OOGLEND();
    }
    else
    {
        GLfloat dial_ox =   x - siz.width/2;
        GLfloat position =  y + amount * siz.height - siz.height/2;
        OOGLBEGIN(GL_QUADS);
            glVertex3f(dial_ox+1, position+1, z);
            glVertex3f(dial_ox + siz.width-1, position+1, z);
            glVertex3f(dial_ox + siz.width-1, position-1, z);
            glVertex3f(dial_ox+1, position-1, z);
        OOGLEND();
    }
}

References OOGLBEGIN, OOGLEND, x, and y.

◆ hudDrawReticleOnTarget

+ (static void) hudDrawReticleOnTarget	(Entity *)	target
	(PlayerEntity *)	player1
	(GLfloat)	z1
	(GLfloat)	alpha
	(BOOL)	reticleTargetSensitive
	(NSMutableDictionary *)	propertiesReticleTargetSensitive
	(BOOL)	colourFromScannerColour
	(BOOL)	showText
	(NSDictionary *)	info
	(NSMutableArray *)	reticleColors

implementation

Definition at line 3533 of file HeadUpDisplay.m.

{
    if (target == nil || player1 == nil)  
    {
        return;
    }
    if ([player1 guiScreen] != GUI_SCREEN_MAIN) // don't draw on text screens
    {
        return;
    }
 
    ShipEntity      *target_ship = nil;
    NSString        *legal_desc = nil;
    
    GLfloat         scale = [info oo_floatForKey:@"reticle_scale" defaultValue:ONE_SIXTYFOURTH];
    
 
    if ([target isShip])
    {
        target_ship = (ShipEntity *)target;
        legal_desc = [target_ship scanDescription];
    }
 
    if ([target_ship isCloaked])  return;
    
    
    Vector          p1;
    
    // by definition close enough that single precision is fine
    p1 = HPVectorToVector(HPvector_subtract([target position], [player1 viewpointPosition]));
    
    GLfloat         rdist = magnitude(p1);
    GLfloat         rsize = [target collisionRadius] / (2 * [[UNIVERSE gameView] fov:YES]); // FIXME integrate 2 into fov to remove magic number
    
    if (rsize < rdist * scale)
        rsize = rdist * scale;
    
    GLfloat         rs0 = rsize;
    GLfloat         rs2 = rsize * 0.50;
    
    OOGLPushModelView();
    hudRotateViewpointForVirtualDepth(player1,p1);
 
    // draw the reticle
    float range = sqrt(target->zero_distance) - target->collision_radius;
    
    int flash = (int)([UNIVERSE getTime] * 4);
    flash &= 1;
 
    // Draw reticle cyan for Wormholes
    if ([target isWormhole])
    {
        OOColor *wormholeReticleColor = [reticleColors objectAtIndex:OO_RETICLE_COLOR_WORMHOLE];
        GLfloat wormholeReticleColorArray[4] = {[wormholeReticleColor redComponent],
                                                [wormholeReticleColor greenComponent],
                                                [wormholeReticleColor blueComponent],
                                                [wormholeReticleColor alphaComponent]};
        GLColorWithOverallAlpha(wormholeReticleColorArray, alpha);
    }
    else
    {
        // Reticle sensitivity accuracy calculation
        BOOL            isTargeted = NO;
        GLfloat         probabilityAccuracy;
        
        if (propertiesReticleTargetSensitive != nil)
        {
            // Only if target is within player's weapon range, we mind for reticle accuracy
            if (range < [player1 weaponRange])
            {
                // After MAX_ACCURACY_RANGE km start decreasing high accuracy probability by ACCURACY_PROBABILITY_DECREASE_FACTOR%
                if (range > MAX_ACCURACY_RANGE)   
                {
                    // Every one second re-evaluate accuracy
                    if ([UNIVERSE getTime] > [propertiesReticleTargetSensitive oo_doubleForKey:@"timeLastAccuracyProbabilityCalculation"] + 1) 
                    {
                        probabilityAccuracy = 1-(range-MAX_ACCURACY_RANGE)*ACCURACY_PROBABILITY_DECREASE_FACTOR; 
                        // Make sure probability does not go below a minimum
                        probabilityAccuracy = probabilityAccuracy < MIN_PROBABILITY_ACCURACY ? MIN_PROBABILITY_ACCURACY : probabilityAccuracy;
                        [propertiesReticleTargetSensitive setObject:[NSNumber numberWithBool:((randf() < probabilityAccuracy) ? YES : NO)] forKey:@"isAccurate"];
            
                        // Store the time the last accuracy probability has been performed
                        [propertiesReticleTargetSensitive setObject:[NSNumber numberWithDouble:[UNIVERSE getTime]] forKey:@"timeLastAccuracyProbabilityCalculation"];
                    }           
                    if ([propertiesReticleTargetSensitive oo_boolForKey:@"isAccurate"])
                    {
                        // high accuracy reticle
                        isTargeted = ([UNIVERSE firstEntityTargetedByPlayerPrecisely] == target);
                    }
                    else
                    {
                        // low accuracy reticle
                        isTargeted = ([UNIVERSE firstEntityTargetedByPlayer] == target);
                    }
                }
                else
                {
                    // high accuracy reticle
                    isTargeted = ([UNIVERSE firstEntityTargetedByPlayerPrecisely] == target);
                }
            }
        }
        
        // If reticle is target sensitive, draw target box in red 
        // when target passes through laser hit-point(with decreasing accuracy) 
        // and is within hit-range.
        //
        // NOTE: The following condition also considers (indirectly) the player's weapon range.
        //       'isTargeted' is initialised to FALSE. Only if target is within the player's weapon range,
        //       it might change value. Therefore, it is not necessary to add '&& range < [player1 weaponRange]'
        //       to the following condition.
        if (colourFromScannerColour)
        {
            if ([target isShip])
            {
                ShipEntity *ship = (ShipEntity *)target;
                BOOL isHostile = (([ship hasHostileTarget])&&([ship primaryTarget] == PLAYER));
                GLColorWithOverallAlpha([ship scannerDisplayColorForShip:PLAYER :isHostile :flash :[ship scannerDisplayColor1] :[ship scannerDisplayColor2] :[ship scannerDisplayColorHostile1] :[ship scannerDisplayColorHostile2]],alpha);
            }
            else if ([target isVisualEffect])
            {
                OOVisualEffectEntity *vis = (OOVisualEffectEntity *)target;
                GLColorWithOverallAlpha([vis scannerDisplayColorForShip:flash :[vis scannerDisplayColor1] :[vis scannerDisplayColor2]],alpha);
            }
            else
            {
                GLColorWithOverallAlpha(green_color, alpha);
            }
        }
        else
        {
            OOColor *reticleDisplayColor = nil;
            if (reticleTargetSensitive && isTargeted)
            {
                reticleDisplayColor = [reticleColors objectAtIndex:OO_RETICLE_COLOR_TARGET_SENSITIVE];
                if (!reticleDisplayColor)  reticleDisplayColor = [OOColor redColor];
            }
            else
            {
                reticleDisplayColor = [reticleColors objectAtIndex:OO_RETICLE_COLOR_TARGET];
                if (!reticleDisplayColor)  reticleDisplayColor = [OOColor greenColor];
            }
            GLfloat reticleDisplayColorArray[4] = { [reticleDisplayColor redComponent],
                                                    [reticleDisplayColor greenComponent],
                                                    [reticleDisplayColor blueComponent],
                                                    [reticleDisplayColor alphaComponent] };
            GLColorWithOverallAlpha(reticleDisplayColorArray, alpha);
        }
    }
    OOGLBEGIN(GL_LINES);
        glVertex2f(rs0,rs2);    glVertex2f(rs0,rs0);
        glVertex2f(rs0,rs0);    glVertex2f(rs2,rs0);
        
        glVertex2f(rs0,-rs2);   glVertex2f(rs0,-rs0);
        glVertex2f(rs0,-rs0);   glVertex2f(rs2,-rs0);
        
        glVertex2f(-rs0,rs2);   glVertex2f(-rs0,rs0);
        glVertex2f(-rs0,rs0);   glVertex2f(-rs2,rs0);
        
        glVertex2f(-rs0,-rs2);  glVertex2f(-rs0,-rs0);
        glVertex2f(-rs0,-rs0);  glVertex2f(-rs2,-rs0);
    OOGLEND();
    
    if (showText)
    {
        // add text for reticle here
        range *= 0.001f;
        if (range < 0.001f) range = 0.0f;   // avoids the occasional -0.001 km distance.
        NSSize textsize = NSMakeSize(rdist * scale, rdist * scale);
        float line_height = rdist * scale;
        NSString*   infoline = [NSString stringWithFormat:@"%0.3f km", range];
        if (legal_desc != nil) infoline = [NSString stringWithFormat:@"%@ (%@)", infoline, legal_desc];
        // no need to set colour here
        OODrawString([player1 dialTargetName], rs0, 0.5 * rs2, 0, textsize);
        OODrawString(infoline, rs0, 0.5 * rs2 - line_height, 0, textsize);
    
        if ([target isWormhole])
        {
            // Note: No break statements in the following switch() since every case
            //       falls through to the next.  Cases arranged in reverse order.
            switch([(WormholeEntity *)target scanInfo])
            {
            case WH_SCANINFO_SHIP:
                // TOOD: Render anything on the HUD for this?
            case WH_SCANINFO_DESTINATION:
                // Rendered above in dialTargetName, so no need to do anything here
                // unless we want a separate line Destination: XXX ?
            case WH_SCANINFO_ARRIVAL_TIME:
            {
                NSString *wormholeETA = [NSString stringWithFormat:DESC(@"wormhole-ETA-@"), ClockToString([(WormholeEntity *)target estimatedArrivalTime], NO)];
                OODrawString(wormholeETA, rs0, 0.5 * rs2 - 3 * line_height, 0, textsize);
            }
            case WH_SCANINFO_COLLAPSE_TIME:
            {
                OOTimeDelta timeForCollapsing = [(WormholeEntity *)target expiryTime] - [player1 clockTimeAdjusted];
                int minutesToCollapse = floor (timeForCollapsing / 60.0);
                int secondsToCollapse = (int)timeForCollapsing % 60;
                
                NSString *wormholeExpiringIn = [NSString stringWithFormat:DESC(@"wormhole-collapsing-in-mm:ss"), minutesToCollapse, secondsToCollapse];
                OODrawString(wormholeExpiringIn, rs0, 0.5 * rs2 - 2 * line_height, 0, textsize);
            }
            case WH_SCANINFO_SCANNED:
            case WH_SCANINFO_NONE:
                break;
            }
        }
    }
    
    OOGLPopModelView();
}

References ACCURACY_PROBABILITY_DECREASE_FACTOR, OOColor::alphaComponent, OOColor::blueComponent, PlayerEntity::clockTimeAdjusted, Entity::collision_radius, Entity::collisionRadius, WormholeEntity::estimatedArrivalTime, WormholeEntity::expiryTime, GLColorWithOverallAlpha, green_color, OOColor::greenColor, OOColor::greenComponent, ShipEntity::hasHostileTarget, hudRotateViewpointForVirtualDepth(), int(), MAX_ACCURACY_RANGE, MIN_PROBABILITY_ACCURACY, nil, OODrawString(), OOGLBEGIN, OOGLEND, OOGLPopModelView(), OOGLPushModelView(), PLAYER, ShipEntity::primaryTarget, propertiesReticleTargetSensitive, OOColor::redColor, OOColor::redComponent, reticleTargetSensitive, ShipEntity::scanDescription, UNIVERSE, WH_SCANINFO_ARRIVAL_TIME, WH_SCANINFO_COLLAPSE_TIME, WH_SCANINFO_DESTINATION, WH_SCANINFO_NONE, WH_SCANINFO_SCANNED, WH_SCANINFO_SHIP, z1, and Entity::zero_distance.

Here is the call graph for this function:

◆ hudDrawStatusIconAt

+ (static void) hudDrawStatusIconAt	(int)	x
	(int)	y
	(int)	z
	(NSSize)	siz

implementation

Definition at line 3515 of file HeadUpDisplay.m.

{
    int ox = x - siz.width / 2.0;
    int oy = y - siz.height / 2.0;
    int w = siz.width / 4.0;
    int h = siz.height / 4.0; 
 
    glVertex3i(ox, oy + h, z);
    glVertex3i(ox, oy + 3 * h, z);
    glVertex3i(ox + w, oy + 4 * h, z);
    glVertex3i(ox + 3 * w, oy + 4 * h, z);
    glVertex3i(ox + 4 * w, oy + 3 * h, z);
    glVertex3i(ox + 4 * w, oy + h, z);
    glVertex3i(ox + 3 * w, oy, z);
    glVertex3i(ox + w, oy, z);
}

References x, and y.

◆ hudDrawSurroundAt

+ (static void) hudDrawSurroundAt	(GLfloat)	x
	(GLfloat)	y
	(GLfloat)	z
	(NSSize)	siz

implementation

Definition at line 3501 of file HeadUpDisplay.m.

{
    GLfloat dial_ox = x - siz.width/2;
    GLfloat dial_oy = y - siz.height/2;
    
    OOGLBEGIN(GL_LINE_LOOP);
        glVertex3f(dial_ox-2, dial_oy-2, z);
        glVertex3f(dial_ox+siz.width+2, dial_oy-2, z);
        glVertex3f(dial_ox+siz.width+2, dial_oy+siz.height+2, z);
        glVertex3f(dial_ox-2, dial_oy+siz.height+2, z);
    OOGLEND();
}

References OOGLBEGIN, OOGLEND, x, and y.

◆ hudDrawWaypoint

+ (static void) hudDrawWaypoint	(OOWaypointEntity *)	waypoint
	(PlayerEntity *)	player1
	(GLfloat)	z1
	(GLfloat)	alpha
	(BOOL)	selected
	(GLfloat)	scale

implementation

Definition at line 3747 of file HeadUpDisplay.m.

{
    if ([player1 guiScreen] != GUI_SCREEN_MAIN) // don't draw on text screens
    {
        return;
    }
    
 
    Vector  p1 = HPVectorToVector(HPvector_subtract([waypoint position], [player1 viewpointPosition]));
 
    OOGLPushModelView();
    hudRotateViewpointForVirtualDepth(player1,p1);
    
    // either close enough that single precision is fine or far enough
    // away that precision is irrelevant
    
    GLfloat rdist = magnitude(p1);
    GLfloat rsize = rdist * scale;
    
    GLfloat rs0 = rsize;
    GLfloat rs2 = rsize * 0.50;
 
    if (selected)
    {
        GLColorWithOverallAlpha(blue_color, alpha);
    }
    else
    {
        GLColorWithOverallAlpha(blue_color, alpha*0.25);
    }
 
    OOGLBEGIN(GL_LINES);
        glVertex2f(rs0,rs2);    glVertex2f(rs2,rs2);
        glVertex2f(rs2,rs0);    glVertex2f(rs2,rs2);
 
        glVertex2f(-rs0,rs2);   glVertex2f(-rs2,rs2);
        glVertex2f(-rs2,rs0);   glVertex2f(-rs2,rs2);
 
        glVertex2f(-rs0,-rs2);  glVertex2f(-rs2,-rs2);
        glVertex2f(-rs2,-rs0);  glVertex2f(-rs2,-rs2);
 
        glVertex2f(rs0,-rs2);   glVertex2f(rs2,-rs2);
        glVertex2f(rs2,-rs0);   glVertex2f(rs2,-rs2);
 
//      glVertex2f(0,-rs2); glVertex2f(0,rs2);
//      glVertex2f(rs2,0);  glVertex2f(-rs2,0);
    OOGLEND();
    
    if (selected)
    {
        GLfloat range = HPdistance([player1 position],[waypoint position]) * 0.001f;
        if (range < 0.001f) range = 0.0f;   // avoids the occasional -0.001 km distance.
        NSSize textsize = NSMakeSize(rdist * scale, rdist * scale);
        float line_height = rdist * scale;
        NSString*   infoline = [NSString stringWithFormat:@"%0.3f km", range];
        OODrawString(infoline, rs0 * 0.5, -rs2 - line_height, 0, textsize);
    }
 
    OOGLPopModelView();
}

References blue_color, GLColorWithOverallAlpha, hudRotateViewpointForVirtualDepth(), OODrawString(), OOGLBEGIN, OOGLEND, OOGLPopModelView(), OOGLPushModelView(), and z1.

Here is the call graph for this function:

◆ hudName

- (NSString *) hudName

References hudName, and scannerZoom.

Here is the call graph for this function:

◆ hudRotateViewpointForVirtualDepth

+ (static void) hudRotateViewpointForVirtualDepth		(PlayerEntity *)	player1
		(Vector)	p1

implementation

Definition at line 3808 of file HeadUpDisplay.m.

{
    Quaternion      back_q = [player1 orientation];
    back_q.w = -back_q.w;   // invert
    Vector          v1 = vector_up_from_quaternion(back_q);
    NSSize          viewSize = [[UNIVERSE gameView] viewSize];
    float           aspect = viewSize.width / viewSize.height;
 
    // The field of view transformation is really a scale operation on the view window.
    // We must unapply it through these transformations for them to be right.
    // We must also take into account the window aspect ratio.
    float ratio = 2 * [[UNIVERSE gameView] fov:YES]; // FIXME 2 is magic number; fov should integrate it
    if (3.0f * aspect >= 4.0f)
    {
        OOGLScaleModelView(make_vector(1/ratio, 1/ratio, 1.0f));
    }
    else
    {
        OOGLScaleModelView(make_vector((4.0f/3.0f)/(aspect*ratio), (4.0f/3.0f)/(aspect*ratio), 1.0f));
    }
 
    // deal with view directions
    Vector view_dir, view_up = kBasisYVector;
    switch ([UNIVERSE viewDirection])
    {
        default:
        case VIEW_FORWARD:
            view_dir.x = 0.0;   view_dir.y = 0.0;   view_dir.z = 1.0;
            break;
            
        case VIEW_AFT:
            view_dir.x = 0.0;   view_dir.y = 0.0;   view_dir.z = -1.0;
            quaternion_rotate_about_axis(&back_q, v1, M_PI);
            break;
            
        case VIEW_PORT:
            view_dir.x = -1.0;   view_dir.y = 0.0;   view_dir.z = 0.0;
            quaternion_rotate_about_axis(&back_q, v1, 0.5 * M_PI);
            break;
            
        case VIEW_STARBOARD:
            view_dir.x = 1.0;   view_dir.y = 0.0;   view_dir.z = 0.0;
            quaternion_rotate_about_axis(&back_q, v1, -0.5 * M_PI);
            break;
            
        case VIEW_CUSTOM:
            view_dir = [player1 customViewForwardVector];
            view_up = [player1 customViewUpVector];
            back_q = quaternion_multiply([player1 customViewQuaternion], back_q);
            break;
    }
    OOGLLookAt(view_dir, kZeroVector, view_up);
 
    // rotate the view
    OOGLMultModelView([player1 rotationMatrix]);
    // translate the view
    OOGLTranslateModelView(p1);
    // rotate to face player1
    OOGLMultModelView(OOMatrixForQuaternionRotation(back_q));
 
    // We come back now to the previous scale.
    OOGLScaleModelView(make_vector(ratio, ratio, 1.0f));
    // draw the waypoint
}

References PlayerEntity::customViewForwardVector, PlayerEntity::customViewUpVector, kBasisYVector, kZeroVector, M_PI, OOGLLookAt(), OOGLMultModelView(), OOGLScaleModelView(), OOGLTranslateModelView(), OOMatrixForQuaternionRotation(), Entity::orientation, quaternion_multiply(), quaternion_rotate_about_axis(), UNIVERSE, and vector_up_from_quaternion().

Here is the call graph for this function:

◆ IconForMissileRole

+ (static OOPolygonSprite *) IconForMissileRole (NSString *) role

implementation

Definition at line 2541 of file HeadUpDisplay.m.

{
    static NSMutableDictionary  *sIcons = nil;
    OOPolygonSprite             *result = nil;
    
    result = [sIcons objectForKey:role];
    if (result == nil)
    {
        NSString *key = role;
        NSArray *iconDef = [[UNIVERSE descriptions] oo_arrayForKey:key];
        if (iconDef != nil)  result = [[OOPolygonSprite alloc] initWithDataArray:iconDef outlineWidth:kOutlineWidth name:key];
        if (result == nil)   // No custom icon or bad data
        {
            /*  Backwards compatibility note:
                The old implementation used suffixes "MISSILE" and "MINE" (without
                the underscore), and didn't draw anything if neither was found. I
                believe any difference in practical behavour due to the change here
                will be positive.
                -- Ahruman 2009-10-09
            */
            if ([role hasSuffix:@"_MISSILE"])  key = kDefaultMissileIconKey;
            else  key = kDefaultMineIconKey;
            
            iconDef = [[UNIVERSE descriptions] oo_arrayForKey:key];
            result = [[OOPolygonSprite alloc] initWithDataArray:iconDef outlineWidth:kOutlineWidth name:key];
        }
        
        if (result != nil)
        {
            if (sIcons == nil)  sIcons = [[NSMutableDictionary alloc] init];
            [sIcons setObject:result forKey:role];
            [result release];   // Balance alloc
        }
    }
    
    return result;
}

References kDefaultMineIconKey, kDefaultMissileIconKey, and nil.

Referenced by drawIconForEmptyPylonAtX:y:width:height:alpha:, and drawIconForMissile:selected:status:x:y:width:height:alpha:.

Here is the caller graph for this function:

◆ InitTextEngine(void) [1/2]

+ (static void InitTextEngine(void))

implementation

References prefetchData.

Here is the call graph for this function:

◆ InitTextEngine(void) [2/2]

+ (static void InitTextEngine(void)) (void)

implementation

Definition at line 3874 of file HeadUpDisplay.m.

{
    NSDictionary            *fontSpec = nil;
    NSArray                 *widths = nil;
    NSString                *texName = nil;
    NSUInteger              i, count;
    
    fontSpec = [ResourceManager dictionaryFromFilesNamed:@"oolite-font.plist"
                                                inFolder:@"Config"
                                                andMerge:NO];
    
    texName = [fontSpec oo_stringForKey:@"texture" defaultValue:@"oolite-font.png"];
    sFontTexture = [OOTexture textureWithName:texName
                                     inFolder:@"Textures"
                                      options:kFontTextureOptions
                                   anisotropy:0.0f
                                      lodBias:-0.75f];
    [sFontTexture retain];
    
    sF6KernGovt = [fontSpec oo_floatForKey:@"f6KernGovernment" defaultValue:1.0];    
    sF6KernTL = [fontSpec oo_floatForKey:@"f6KernTechLevel" defaultValue:2.0];
 
    sEncodingCoverter = [[OOEncodingConverter alloc] initWithFontPList:fontSpec];
    widths = [fontSpec oo_arrayForKey:@"widths"];
    count = [widths count];
    if (count > 256)  count = 256;
    for (i = 0; i != count; ++i)
    {
        sGlyphWidths[i] = [widths oo_floatAtIndex:i] * GLYPH_SCALE_FACTOR;
    }
}

References count, ResourceManager::dictionaryFromFilesNamed:inFolder:andMerge:, GLYPH_SCALE_FACTOR, nil, OOTexture::retain, sEncodingCoverter, sF6KernGovt, sF6KernTL, sFontTexture, sGlyphWidths, and OOTexture::textureWithName:inFolder:options:anisotropy:lodBias:.

Here is the call graph for this function:

◆ initWithDictionary:

- (id) initWithDictionary: (NSDictionary *) hudinfo

Definition at line 221 of file HeadUpDisplay.m.

221 :(NSDictionary *)hudinfo

222{

223 return [self initWithDictionary:hudinfo inFile:nil];

224}

References initWithDictionary:inFile:.

Here is the call graph for this function:

◆ initWithDictionary:inFile:

- (id) initWithDictionary:		(NSDictionary *)	hudinfo
inFile:		(NSString *)	hudFileName

Definition at line 227 of file HeadUpDisplay.m.

                         :(NSDictionary *)hudinfo inFile:(NSString *)hudFileName
{
    unsigned        i;
    BOOL            isCompassToBeDrawn = NO;
    BOOL            areTrumblesToBeDrawn = NO;
    
    self = [super init];
    
    lineWidth = 1.0;
    
    if (sFontTexture == nil)  InitTextEngine();
    
    deferredHudName = nil;    // if not nil, it means that we have a deferred HUD which is to be drawn at first available opportunity
    hudName = [hudFileName copy];
    
    // init arrays
    dialArray = [[NSMutableArray alloc] initWithCapacity:16];   // alloc retains
    legendArray = [[NSMutableArray alloc] initWithCapacity:16]; // alloc retains
    mfdArray = [[NSMutableArray alloc] initWithCapacity:8]; // alloc retains
    
    _reticleColors = nil;
    
    // populate arrays
    NSArray *dials = [hudinfo oo_arrayForKey:DIALS_KEY];
    for (i = 0; i < [dials count]; i++)
    {
        NSDictionary    *dial_info = [dials oo_dictionaryAtIndex:i];
        if (!areTrumblesToBeDrawn && [[dial_info oo_stringForKey:SELECTOR_KEY] isEqualToString:@"drawTrumbles:"])  areTrumblesToBeDrawn = YES;
        if (!isCompassToBeDrawn && [[dial_info oo_stringForKey:SELECTOR_KEY] isEqualToString:@"drawCompass:"])  isCompassToBeDrawn = YES;
        if ([[dial_info oo_stringForKey:SELECTOR_KEY] isEqualToString:@"drawTargetReticle:"])
        {
            _reticleColors = [[NSMutableArray arrayWithObjects:[OOColor colorWithDescription:[dial_info oo_objectForKey:@"target_rgba" defaultValue:@"greenColor"]],
                                                [OOColor colorWithDescription:[dial_info oo_objectForKey:@"target_sensitive_rgba" defaultValue:@"redColor"]],
                                                [OOColor colorWithDescription:[dial_info oo_objectForKey:@"wormhole_rgba" defaultValue:@"cyanColor"]],
                                                nil] retain];
        }
        [self addDial:dial_info];
    }
    
    // reticle colors should be set at this point, but just be safe in case they are not
    if (!_reticleColors)
    {
        _reticleColors = [[NSMutableArray arrayWithObjects:[OOColor greenColor], [OOColor redColor], [OOColor cyanColor], nil] retain];
    }
    
    if (!areTrumblesToBeDrawn)  // naughty - a hud with no built-in drawTrumbles: - one must be added!
    {
        NSDictionary    *trumble_dial_info = [NSDictionary dictionaryWithObjectsAndKeys: @"drawTrumbles:", SELECTOR_KEY, nil];
        [self addDial:trumble_dial_info];
    }
    
    _compassActive = isCompassToBeDrawn;
    
    _lastWeaponType = nil;
 
    NSArray *legends = [hudinfo oo_arrayForKey:LEGENDS_KEY];
    for (i = 0; i < [legends count]; i++)
    {
        [self addLegend:[legends oo_dictionaryAtIndex:i]];
    }
 
    NSArray *mfds = [hudinfo oo_arrayForKey:MFDS_KEY];
    for (i = 0; i < [mfds count]; i++)
    {
        [self addMFD:[mfds oo_dictionaryAtIndex:i]];
    }
 
    
    hudHidden = NO;
    
    _hiddenSelectors = [[NSMutableSet alloc] initWithCapacity:16];
 
    hudUpdating = NO;
    
    overallAlpha = [hudinfo oo_floatForKey:@"overall_alpha" defaultValue:DEFAULT_OVERALL_ALPHA];
    
    reticleTargetSensitive = [hudinfo oo_boolForKey:@"reticle_target_sensitive" defaultValue:NO];
    propertiesReticleTargetSensitive = [[NSMutableDictionary alloc] initWithObjectsAndKeys:
                                        [NSNumber numberWithBool:YES], @"isAccurate", 
                                        [NSNumber numberWithDouble:[UNIVERSE getTime]], @"timeLastAccuracyProbabilityCalculation", 
                                        nil];
    
    cloakIndicatorOnStatusLight = [hudinfo oo_boolForKey:@"cloak_indicator_on_status_light" defaultValue:YES];
 
    allowBigGui = [hudinfo oo_boolForKey:@"allow_big_gui" defaultValue:NO];
    
    last_transmitter = NO_TARGET;
    
    [crosshairDefinition release];
    
    NSString *crossfile = [[hudinfo oo_stringForKey:@"crosshair_file"] retain];
    if (crossfile == nil)
    {
        _crosshairOverrides = [[hudinfo oo_dictionaryForKey:@"crosshairs"] retain];
        crosshairDefinition = nil;
    }
    else
    {
        [self setCrosshairDefinition:crossfile];
    }
    [crossfile release];
    
    id crosshairColor = [hudinfo oo_objectForKey:@"crosshair_color" defaultValue:@"greenColor"];
    _crosshairColor = [[OOColor colorWithDescription:crosshairColor] retain];
    _crosshairScale = [hudinfo oo_floatForKey:@"crosshair_scale" defaultValue:32.0f];
    _crosshairWidth = [hudinfo oo_floatForKey:@"crosshair_width" defaultValue:1.5f];
    
    minimalistic_scanner = [hudinfo oo_boolForKey:@"scanner_minimalistic" defaultValue:NO];
    
    nonlinear_scanner = [hudinfo oo_boolForKey:@"scanner_non_linear" defaultValue:NO];
    scanner_ultra_zoom = [hudinfo oo_boolForKey:@"scanner_ultra_zoom" defaultValue:NO];
    
    return self;
}

References _compassActive, _crosshairColor, _crosshairOverrides, _crosshairScale, _crosshairWidth, _hiddenSelectors, _lastWeaponType, _reticleColors, addDial:, addLegend:, addMFD:, allowBigGui, cloakIndicatorOnStatusLight, OOColor::colorWithDescription:, crosshairDefinition, OOColor::cyanColor, deferredHudName, dialArray, OOColor::greenColor, hudHidden, hudName, hudUpdating, last_transmitter, legendArray, lineWidth, mfdArray, minimalistic_scanner, nil, NO_TARGET, nonlinear_scanner, overallAlpha, propertiesReticleTargetSensitive, OOColor::redColor, reticleTargetSensitive, scanner_ultra_zoom, SELECTOR_KEY, setCrosshairDefinition:, and sFontTexture.

Referenced by initWithDictionary:.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ isCompassActive

- (BOOL) isCompassActive

Definition at line 674 of file HeadUpDisplay.m.

675{

676 return _compassActive;

677}

References _compassActive, and isCompassActive.

Referenced by allowBigGui, isCompassActive, and PlayerEntity::switchHudTo:.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ isHidden

- (BOOL) isHidden

Definition at line 627 of file HeadUpDisplay.m.

628{

629 return hudHidden;

630}

References hudHidden, and isHidden.

Referenced by OODebugController::hideShowHUD:, isHidden, PlayerEntity(OOControlsPrivate)::pollApplicationControls, propertiesReticleTargetSensitive, PlayerEntity::switchHudTo:, and OODebugController::validateMenuItem:.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ isUpdating

- (BOOL) isUpdating

Definition at line 686 of file HeadUpDisplay.m.

687{

688 return hudUpdating;

689}

References hudUpdating, and isUpdating.

Referenced by allowBigGui, and isUpdating.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ lineWidth

- (GLfloat) lineWidth

References lineWidth, minimalisticScanner, nonlinearScanner, and scannerUltraZoom.

Here is the call graph for this function:

◆ mfdCount

- (NSUInteger) mfdCount

Definition at line 803 of file HeadUpDisplay.m.

804{

805 return [mfdArray count];

806}

References mfdCount.

Referenced by crosshairDefinition, mfdCount, PlayerEntity::selectPreviousMultiFunctionDisplay, and PlayerEntity::switchHudTo:.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ minimalisticScanner

- (BOOL) minimalisticScanner

Definition at line 1489 of file HeadUpDisplay.m.

1490{

1491 return minimalistic_scanner;

1492}

References minimalistic_scanner, and minimalisticScanner.

Referenced by lineWidth, and minimalisticScanner.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ nonlinearScanner

- (BOOL) nonlinearScanner

Definition at line 1509 of file HeadUpDisplay.m.

1510{

1511 return nonlinear_scanner;

1512}

References nonlinear_scanner, and nonlinearScanner.

Referenced by lineWidth, and nonlinearScanner.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ nonlinearScannerFunc

+ (static GLfloat) nonlinearScannerFunc	(GLfloat)	distance
	(GLfloat)	zoom
	(GLfloat)	scale

implementation

Definition at line 4228 of file HeadUpDisplay.m.

{
    GLfloat x = fabs(distance / SCANNER_MAX_RANGE);
    if (x >= 1.0)
        return scale;
    if (zoom <= 1.0)
        return scale * x;
    GLfloat c = 1 / ( zoom - 1 );
    GLfloat b = c * ( c + 1 );
    GLfloat a = c + 1;
    return scale * ( a - b / ( x + c ) );
}

References SCANNER_MAX_RANGE, and x.

◆ nonlinearScannerScale:Zoom:Scale:

+ (Vector) nonlinearScannerScale:	(Vector)	V
Zoom:	(GLfloat)	zoom
Scale:	(double)	scale

Definition at line 1501 of file HeadUpDisplay.m.

                                : (Vector) V Zoom:(GLfloat)zoom Scale:(double) scale
{
    OOScalar mag = magnitude(V);
    Vector unit = vector_normal(V);
    return vector_multiply_scalar(unit, nonlinearScannerFunc(mag, zoom, scale));
}

References nonlinearScannerFunc().

Referenced by HeadUpDisplay(Private)::drawScanner:, and GLDrawNonlinearCascadeWeapon.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ OODrawHilightedPlanetInfo

- (void) OODrawHilightedPlanetInfo	(int)	gov
	(int)	eco
	(int)	tec
	(GLfloat)	x
	(GLfloat)	y
	(GLfloat)	z
	(NSSize)	siz

implementation

Definition at line 4125 of file HeadUpDisplay.m.

{
    float   color[4];
    int     tl = tec + 1;
    
    NSSize  hisize;
    
    // get the physical dimensions
    hisize.height = siz.height;
    hisize.width = 0.0f;
    
    // see OODrawPlanetInfo
    hisize.width += siz.width * sGlyphWidths[23 - eco];
    hisize.width += siz.width * sGlyphWidths[gov] - 1.0;
    if (tl > 9) hisize.width += siz.width * sGlyphWidths[49] - 2.0;
    hisize.width += siz.width * sGlyphWidths[48 + (tl % 10)];
    
    OOSetOpenGLState(OPENGL_STATE_OVERLAY);
    
    OOGL(glPushAttrib(GL_CURRENT_BIT)); // save the text colour
    OOGL(glGetFloatv(GL_CURRENT_COLOR, color)); // we need the original colour's alpha.
    
    drawHighlight(x, y - 2.0f, z, hisize, color[3]);
    
    OOGL(glPopAttrib());    //restore the colour
    
    OODrawPlanetInfo(gov, eco, tec, x, y, z, siz);
    
    OOVerifyOpenGLState();
}

References drawHighlight, OODrawPlanetInfo(), OOGL, OOSetOpenGLState, OOVerifyOpenGLState, OPENGL_STATE_OVERLAY, sGlyphWidths, x, and y.

Here is the call graph for this function:

◆ OODrawHilightedString

- (void) OODrawHilightedString	(NSString *)	text
	(GLfloat)	x
	(GLfloat)	y
	(GLfloat)	z
	(NSSize)	siz

implementation

Definition at line 4047 of file HeadUpDisplay.m.

{
    GLfloat color[4];
    
    // get the physical dimensions of the string
    NSSize strsize = OORectFromString(text, 0.0f, 0.0f, siz).size;
    strsize.width += 0.5f;
    
    OOSetOpenGLState(OPENGL_STATE_OVERLAY);
    
    OOGL(glPushAttrib(GL_CURRENT_BIT)); // save the text colour
    OOGL(glGetFloatv(GL_CURRENT_COLOR, color)); // we need the original colour's alpha.
    
    drawHighlight(x, y, z, strsize, color[3]);
    
    OOGL(glPopAttrib());    //restore the colour
    
    OODrawString(text, x, y, z, siz);
    
    OOVerifyOpenGLState();
}

References drawHighlight, OODrawString(), OOGL, OORectFromString(), OOSetOpenGLState, OOVerifyOpenGLState, OPENGL_STATE_OVERLAY, x, and y.

Here is the call graph for this function:

◆ OODrawPlanetInfo

- (void) OODrawPlanetInfo	(int)	gov
	(int)	eco
	(int)	tec
	(GLfloat)	x
	(GLfloat)	y
	(GLfloat)	z
	(NSSize)	siz

implementation

Definition at line 4070 of file HeadUpDisplay.m.

{
    GLfloat govcol[] = {    0.5, 0.0, 0.7,
                            0.7, 0.5, 0.3,
                            0.0, 1.0, 0.3,
                            1.0, 0.8, 0.1,
                            1.0, 0.0, 0.0,
                            0.1, 0.5, 1.0,
                            0.7, 0.7, 0.7,
                            0.7, 1.0, 1.0};
    
    GLfloat cx = x;
    int tl = tec + 1;
    GLfloat ce1 = 1.0f - 0.125f * eco;
    
    OOSetOpenGLState(OPENGL_STATE_OVERLAY);
    
    OOGL(glEnable(GL_TEXTURE_2D));
    [sFontTexture apply];
 
    OOGLBEGIN(GL_QUADS);
    {
        [[UNIVERSE gui] setGLColorFromSetting:[NSString stringWithFormat:kGuiChartEconomyUColor, (unsigned long)eco]
                                 defaultValue:[OOColor colorWithRed:ce1 green:1.0f blue:0.0f alpha:1.0f] 
                                        alpha:1.0];
 
        // see OODrawHilightedPlanetInfo
        cx += drawCharacterQuad(23 - eco, cx, y, z, siz); // characters 16..23 are economy symbols
        [[UNIVERSE gui] setGLColorFromSetting:[NSString stringWithFormat:kGuiChartGovernmentUColor, (unsigned long)gov]
                                 defaultValue:[OOColor colorWithRed:govcol[gov*3] green:govcol[1+(gov*3)] blue:govcol[2+(gov*3)] alpha:1.0f] 
                                        alpha:1.0];
 
        cx += drawCharacterQuad(gov, cx, y, z, siz) - sF6KernGovt;     // charcters 0..7 are government symbols
        [[UNIVERSE gui] setGLColorFromSetting:kGuiChartTechColor
                                 defaultValue:[OOColor colorWithRed:0.5 green:1.0f blue:1.0f alpha:1.0f] 
                                        alpha:1.0];
 
        if (tl > 9)
        {
            // display TL clamped between 1..16, this must be a '1'!
            cx += drawCharacterQuad(49, cx, y - 2, z, siz) - sF6KernTL;
        }
        cx += drawCharacterQuad(48 + (tl % 10), cx, y - 2.0f, z, siz);
    }
    OOGLEND();
    
    (void)cx;   // Suppress "value not used" analyzer issue.
    
    [OOTexture applyNone];
    OOGL(glDisable(GL_TEXTURE_2D));
    
    OOVerifyOpenGLState();
}

References OOTexture::apply, OOTexture::applyNone, OOColor::colorWithRed:green:blue:alpha:, drawCharacterQuad, OOGL, OOGLBEGIN, OOGLEND, OOSetOpenGLState, OOVerifyOpenGLState, OPENGL_STATE_OVERLAY, sF6KernGovt, sF6KernTL, x, and y.

Here is the call graph for this function:

◆ OODrawString

- (void) OODrawString	(NSString *)	text
	(GLfloat)	x
	(GLfloat)	y
	(GLfloat)	z
	(NSSize)	siz

implementation

Definition at line 3993 of file HeadUpDisplay.m.

3994{

3995 OODrawStringAligned(text,x,y,z,siz,NO);

3996}

References OODrawStringAligned(), x, and y.

Here is the call graph for this function:

◆ OODrawStringAligned

- (void) OODrawStringAligned	(NSString *)	text
	(GLfloat)	x
	(GLfloat)	y
	(GLfloat)	z
	(NSSize)	siz
	(BOOL)	rightAlign

implementation

Definition at line 3999 of file HeadUpDisplay.m.

{
    OOStartDrawingStrings();
    OODrawStringQuadsAligned(text,x,y,z,siz,rightAlign);
    OOStopDrawingStrings();
}

References OODrawStringQuadsAligned(), OOStartDrawingStrings(), OOStopDrawingStrings(), x, and y.

Here is the call graph for this function:

◆ OODrawStringQuadsAligned

- (void) OODrawStringQuadsAligned	(NSString *)	text
	(GLfloat)	x
	(GLfloat)	y
	(GLfloat)	z
	(NSSize)	siz
	(BOOL)	rightAlign

implementation

Definition at line 4015 of file HeadUpDisplay.m.

{
    GLfloat         cx = x;
    NSInteger       i, length;
    NSData          *data = nil;
    const uint8_t   *bytes = NULL;
    
    data = [sEncodingCoverter convertString:text];
    length = [data length];
    bytes = [data bytes];
 
    if (EXPECT_NOT(rightAlign))
    {
        cx -= OORectFromString(text, 0.0f, 0.0f, siz).size.width;
    }
 
    for (i = 0; i < length; i++)
    {
        cx += drawCharacterQuad(bytes[i], cx, y, z, siz);
    }
}

References OOEncodingConverter::convertString:, drawCharacterQuad, EXPECT_NOT, nil, OORectFromString(), x, and y.

Here is the call graph for this function:

◆ OOHUDResetTextEngine(void)

- (void OOHUDResetTextEngine(void)) (void)

implementation

Definition at line 3907 of file HeadUpDisplay.m.

3908{

3909 DESTROY(sFontTexture);

3910 DESTROY(sEncodingCoverter);

3911}

References DESTROY, sEncodingCoverter, and sFontTexture.

◆ OORectFromString

- (NSRect) OORectFromString	(NSString *)	text
	(GLfloat)	x
	(GLfloat)	y
	(NSSize)	siz

implementation

Definition at line 3936 of file HeadUpDisplay.m.

{
    GLfloat             w = 0;
    NSData              *data = nil;
    const uint8_t       *bytes = NULL;
    NSUInteger          i, length;
    
    data = [sEncodingCoverter convertString:text];
    bytes = [data bytes];
    length = [data length];
    
    for (i = 0; i < length; i++)
    {
        w += siz.width * sGlyphWidths[bytes[i]];
    }
    
    return NSMakeRect(x, y, w, siz.height);
}

References OOEncodingConverter::convertString:, nil, sGlyphWidths, x, and y.

Here is the call graph for this function:

◆ OOStartDrawingStrings

- (void) OOStartDrawingStrings

implementation

Definition at line 4006 of file HeadUpDisplay.m.

                             {
    OOSetOpenGLState(OPENGL_STATE_OVERLAY);
    
    OOGL(glEnable(GL_TEXTURE_2D));
    [sFontTexture apply];
    OOGLBEGIN(GL_QUADS);
 
}

References OOTexture::apply, OOGL, OOGLBEGIN, OOSetOpenGLState, and OPENGL_STATE_OVERLAY.

Here is the call graph for this function:

◆ OOStopDrawingStrings

- (void) OOStopDrawingStrings

implementation

Definition at line 4037 of file HeadUpDisplay.m.

                            {
    OOGLEND();
    
    [OOTexture applyNone];
    OOGL(glDisable(GL_TEXTURE_2D));
    
    OOVerifyOpenGLState();
}

References OOTexture::applyNone, OOGL, OOGLEND, and OOVerifyOpenGLState.

Here is the call graph for this function:

◆ OOStringWidthInEm

- (CGFloat) OOStringWidthInEm (NSString *) text

implementation

Definition at line 3956 of file HeadUpDisplay.m.

3957{

3958 return OORectFromString(text, 0, 0, NSMakeSize(1.0 / (GLYPH_SCALE_FACTOR * 8.0), 1.0)).size.width;

3959}

References GLYPH_SCALE_FACTOR, and OORectFromString().

Here is the call graph for this function:

◆ overallAlpha

- (GLfloat) overallAlpha

References overallAlpha.

◆ prefetchData

+ (static void) prefetchData		(NSDictionary *)	info
		(struct CachedInfo *)	data

implementation

Definition at line 1167 of file HeadUpDisplay.m.

{
    data->x = [info oo_floatForKey:X_KEY defaultValue:NOT_DEFINED];
    data->x0 = [info oo_floatForKey:X_ORIGIN_KEY defaultValue:0.0];
    data->y = [info oo_floatForKey:Y_KEY defaultValue:NOT_DEFINED];
    data->y0 = [info oo_floatForKey:Y_ORIGIN_KEY defaultValue:0.0];
    data->width = [info oo_floatForKey:WIDTH_KEY defaultValue:NOT_DEFINED];
    data->height = [info oo_floatForKey:HEIGHT_KEY defaultValue:NOT_DEFINED];
    data->alpha = [info oo_nonNegativeFloatForKey:ALPHA_KEY defaultValue:1.0f];    
}

References CachedInfo::alpha, CachedInfo::height, prefetchData, CachedInfo::width, CachedInfo::x, CachedInfo::x0, CachedInfo::y, and CachedInfo::y0.

Referenced by addDial:, addLegend:, addMFD:, InitTextEngine(void), and prefetchData.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ propertiesReticleTargetSensitive

- (NSMutableDictionary *) propertiesReticleTargetSensitive

References isHidden, and propertiesReticleTargetSensitive.

Here is the call graph for this function:

◆ refreshLastTransmitter

- (void) refreshLastTransmitter

Definition at line 1533 of file HeadUpDisplay.m.

{
    Entity* lt = [UNIVERSE entityForUniversalID:last_transmitter];
    if ((lt == nil)||(!(lt->isShip)))
        return;
    ShipEntity* st = (ShipEntity*)lt;
    if ([st messageTime] <= 0.0)
        [st setMessageTime:2.5];
}

References Entity::isShip, nil, refreshLastTransmitter, and ShipEntity::setMessageTime:.

Referenced by crosshairDefinition, and refreshLastTransmitter.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ renderHUD

- (void) renderHUD

Definition at line 835 of file HeadUpDisplay.m.

{
    hudUpdating = YES;
    
    OOVerifyOpenGLState();
    
    if (_crosshairWidth * lineWidth > 0)
    {
        OOGL(GLScaledLineWidth(_crosshairWidth * lineWidth));
        [self drawCrosshairs];
    }
    
    if (lineWidth > 0)
    {
        OOGL(GLScaledLineWidth(lineWidth));
        [self drawLegends];
    }
    
    [self drawDials];
    [self drawMFDs];
    OOCheckOpenGLErrors(@"After drawing HUD");
    
    OOVerifyOpenGLState();
    
    hudUpdating = NO;
}

References _crosshairWidth, drawCrosshairs, drawDials, drawLegends, drawMFDs, GLScaledLineWidth(), hudUpdating, lineWidth, OOCheckOpenGLErrors(), OOGL, OOVerifyOpenGLState, and renderHUD.

Referenced by crosshairDefinition, Universe::drawUniverse, and renderHUD.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ resetGui:withInfo:

- (void) resetGui:		(GuiDisplayGen*)	gui
withInfo:		(NSDictionary *)	gui_info

implementation

Provided by category HeadUpDisplay(Private).

Definition at line 363 of file HeadUpDisplay.m.

                 :(GuiDisplayGen*)gui withInfo:(NSDictionary *)gui_info
{
    [self resetGuiPosition:gui withInfo:gui_info];
    
    NSSize      siz =   [gui    size];
    int         rht =   [gui    rowHeight];
    NSString*   title = [gui    title];
    if ([gui_info objectForKey:WIDTH_KEY])
        siz.width = [gui_info oo_floatForKey:WIDTH_KEY];
    if ([gui_info objectForKey:HEIGHT_KEY])
        siz.height = [gui_info oo_floatForKey:HEIGHT_KEY];
    if ([gui_info objectForKey:ROW_HEIGHT_KEY])
        rht = [gui_info oo_floatForKey:ROW_HEIGHT_KEY];
    if ([gui_info objectForKey:TITLE_KEY])
        title = [gui_info oo_stringForKey:TITLE_KEY];
    [gui resizeTo:siz characterHeight:rht title:title];
    if ([gui_info objectForKey:BACKGROUND_RGBA_KEY])
        [gui setBackgroundColor:[OOColor colorFromString:[gui_info oo_stringForKey:BACKGROUND_RGBA_KEY]]];
    if ([gui_info objectForKey:ALPHA_KEY])
        [gui setMaxAlpha: OOClamp_0_max_f([gui_info oo_floatForKey:ALPHA_KEY],1.0f)];
    else
        [gui setMaxAlpha: 1.0f];
}

References ALPHA_KEY, BACKGROUND_RGBA_KEY, OOColor::colorFromString:, HEIGHT_KEY, resetGuiPosition:withInfo:, GuiDisplayGen::resizeTo:characterHeight:title:, ROW_HEIGHT_KEY, GuiDisplayGen::rowHeight, GuiDisplayGen::setBackgroundColor:, GuiDisplayGen::setMaxAlpha:, GuiDisplayGen::size, GuiDisplayGen::title, TITLE_KEY, and WIDTH_KEY.

Referenced by resetGuis:.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ resetGuiPosition:withInfo:

- (void) resetGuiPosition:		(GuiDisplayGen*)	gui
withInfo:		(NSDictionary *)	gui_info

implementation

Provided by category HeadUpDisplay(Private).

Definition at line 388 of file HeadUpDisplay.m.

                         :(GuiDisplayGen*)gui withInfo:(NSDictionary *)gui_info
{
    Vector pos = [gui drawPosition];
    if ([gui_info objectForKey:X_KEY])
        pos.x = [gui_info oo_floatForKey:X_KEY] +
            [[UNIVERSE gameView] x_offset] *
            [gui_info oo_floatForKey:X_ORIGIN_KEY defaultValue:0.0];
    if ([gui_info objectForKey:Y_KEY])
        pos.y = [gui_info oo_floatForKey:Y_KEY] + 
            [[UNIVERSE gameView] y_offset] *
            [gui_info oo_floatForKey:Y_ORIGIN_KEY defaultValue:0.0];
 
    [gui setDrawPosition:pos];
}

References GuiDisplayGen::drawPosition, GuiDisplayGen::setDrawPosition:, X_KEY, and Y_KEY.

Referenced by HeadUpDisplay(Private)::resetGui:withInfo:, and resetGuiPositions.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ resetGuiPositions

- (void) resetGuiPositions

Definition at line 404 of file HeadUpDisplay.m.

{
    NSDictionary *hudDict = [ResourceManager dictionaryFromFilesNamed:[self hudName] inFolder:@"Config" andMerge:YES];
 
    GuiDisplayGen*  gui = [UNIVERSE messageGUI];
    NSDictionary*   gui_info = [hudDict oo_dictionaryForKey:@"message_gui"];
    if (gui && gui_info)
    {
        [self resetGuiPosition:gui withInfo:gui_info];
    }
 
    gui = [UNIVERSE commLogGUI];
    gui_info = [hudDict oo_dictionaryForKey:@"comm_log_gui"];
    if (gui && gui_info)
    {
        [self resetGuiPosition:gui withInfo:gui_info];
    }
 
}

References ResourceManager::dictionaryFromFilesNamed:inFolder:andMerge:, hudName, resetGuiPosition:withInfo:, and resetGuiPositions.

Referenced by PlayerEntity::doGuiScreenResizeUpdates, and resetGuiPositions.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ resetGuis:

- (void) resetGuis: (NSDictionary *) info

Definition at line 425 of file HeadUpDisplay.m.

                  :(NSDictionary *)info
{
    // check for entries in hud.plist for message_gui and comm_log_gui
    // then resize and reposition them accordingly.
    
    GuiDisplayGen*  gui = [UNIVERSE messageGUI];
    NSDictionary*   gui_info = [info oo_dictionaryForKey:@"message_gui"];
    if (gui && [gui_info count] > 0)
    {
        /*
            If switching message guis, remember the last 2 message lines.
            Present GUI limitations make it impractical to transfer anything
            more...
            
            TODO: a more usable GUI code! - Kaks 2011.11.05
        */
        
        NSArray*    lastLines = [gui getLastLines]; // text, colour, fade time - text, colour, fade time
        BOOL        line1 = ![[lastLines oo_stringAtIndex:0] isEqualToString:@""];
        [self resetGui:gui withInfo:gui_info];
 
        BOOL permanent = [gui_info oo_boolForKey:@"permanent" defaultValue:NO];
        [UNIVERSE setPermanentMessageLog:permanent];
        
        BOOL automaticBg = [gui_info oo_boolForKey:@"background_automatic" defaultValue:YES];
        [UNIVERSE setAutoMessageLogBg:automaticBg];
        
        // set message gui text colors - one for standard messages, one for incoming comms
        // incoming comms message color must default to green for compatibility with older huds that
        // don't have this key
        [gui setTextColor:[OOColor colorWithDescription:[gui_info objectForKey:@"text_color"]]];
        OOColor *textCommsColor = [OOColor colorWithDescription:[gui_info objectForKey:@"text_comms_color"]];
        if (!textCommsColor)  textCommsColor = [OOColor greenColor];
        [gui setTextCommsColor:textCommsColor];
        
        if (line1)
        {
            [gui printLongText:[lastLines oo_stringAtIndex:0] align:GUI_ALIGN_CENTER
                         color:[OOColor colorFromString:[lastLines oo_stringAtIndex:1]] 
                      fadeTime:(permanent?0.0:[lastLines oo_floatAtIndex:2]) key:nil addToArray:nil];
        }
        if ([lastLines count] > 3 && (line1 || ![[lastLines oo_stringAtIndex:3] isEqualToString:@""]))
        {
            [gui printLongText:[lastLines oo_stringAtIndex:3] align:GUI_ALIGN_CENTER
                         color:[OOColor colorFromString:[lastLines oo_stringAtIndex:4]] 
                      fadeTime:(permanent?0.0:[lastLines oo_floatAtIndex:5]) key:nil addToArray:nil];
        }
    }
    
    if (gui_info != nil && [gui_info count] == 0)
    {
        // exists and it's empty. complete reset.
        [gui setCurrentRow:8];
        [gui setDrawPosition: make_vector(0.0, -40.0, 640.0)];
        [gui resizeTo:NSMakeSize(480, 160) characterHeight:19 title:nil];
        [gui setCharacterSize:NSMakeSize(16,20)];   // narrow characters
        [gui setTextColor:[OOColor yellowColor]];
        [gui setTextCommsColor:[OOColor greenColor]];
        [UNIVERSE setPermanentMessageLog:NO];
        [UNIVERSE setAutoMessageLogBg:YES];
    }
    
    [gui setAlpha: 1.0f];   // message_gui is always visible.
    
    // And now set up the comms log
    
    gui = [UNIVERSE commLogGUI];
    gui_info = [info oo_dictionaryForKey:@"comm_log_gui"];
    
    if (gui && [gui_info count] > 0)
    {
        [UNIVERSE setAutoCommLog:[gui_info oo_boolForKey:@"automatic" defaultValue:YES]];
        [UNIVERSE setPermanentCommLog:[gui_info oo_boolForKey:@"permanent" defaultValue:NO]];
        
        /*
            We need to repopulate the comms log after resetting it.
            
            At the moment the colour information is set on a per-line basis, rather than a per-text basis.
            A comms message can span multiple lines, and two consecutive messages can share the same colour,
            so trying to match the colour information from the GUI with each message won't work.
            
            Bottom line: colour information is lost on comms log gui reset.
            And yes, this is yet another reason for the following
            
            TODO: a more usable GUI code! - Kaks 2011.11.05
        */
        
        NSArray *cLog = [PLAYER commLog];
        NSUInteger i, commCount = [cLog count];
        
        [self resetGui:gui withInfo:gui_info];
        
        for (i = 0; i < commCount; i++)
        {
            [gui printLongText:[cLog oo_stringAtIndex:i] align:GUI_ALIGN_LEFT color:nil
                      fadeTime:0.0 key:nil addToArray:nil];
        }
    }
    
    if (gui_info != nil && [gui_info count] == 0)
    {
        // exists and it's empty. complete reset.
        [UNIVERSE setAutoCommLog:YES];
        [UNIVERSE setPermanentCommLog:NO];
        [gui setCurrentRow:9];
        [gui setDrawPosition: make_vector(0.0, 180.0, 640.0)];
        [gui resizeTo:NSMakeSize(360, 120) characterHeight:12 title:nil];
        [gui setBackgroundColor:[OOColor colorWithRed:0.0 green:0.05 blue:0.45 alpha:0.5]];
        [gui setTextColor:[OOColor whiteColor]];
        [gui printLongText:DESC(@"communications-log-string") align:GUI_ALIGN_CENTER color:[OOColor yellowColor] fadeTime:0 key:nil addToArray:nil];
    }
    
    if ([UNIVERSE permanentCommLog])
    {
        [gui stopFadeOuts];
        [gui setAlpha:1.0];
    }
    else
    {
        [gui setAlpha:0.0];
    }
}

References OOColor::colorFromString:, OOColor::colorWithDescription:, OOColor::colorWithRed:green:blue:alpha:, count, GuiDisplayGen::getLastLines, OOColor::greenColor, nil, GuiDisplayGen::printLongText:align:color:fadeTime:key:addToArray:, resetGui:withInfo:, GuiDisplayGen::resizeTo:characterHeight:title:, GuiDisplayGen::setAlpha:, GuiDisplayGen::setBackgroundColor:, GuiDisplayGen::setCharacterSize:, GuiDisplayGen::setCurrentRow:, GuiDisplayGen::setDrawPosition:, GuiDisplayGen::setTextColor:, GuiDisplayGen::setTextCommsColor:, GuiDisplayGen::stopFadeOuts, UNIVERSE, OOColor::whiteColor, and OOColor::yellowColor.

Referenced by PlayerEntity::deferredInit, and PlayerEntity::switchHudTo:.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reticleColorForIndex:

- (OOColor *) reticleColorForIndex: (NSUInteger) idx

Definition at line 565 of file HeadUpDisplay.m.

                                  :(NSUInteger)idx
{
    if (idx < [_reticleColors count])
    {
        return [_reticleColors objectAtIndex:idx];
    }
    return nil;
}

References _reticleColors, count, and nil.

Referenced by PlayerShipGetProperty().

Here is the caller graph for this function:

◆ reticleTargetSensitive

- (BOOL) reticleTargetSensitive

References reticleTargetSensitive.

◆ scannerUltraZoom

- (BOOL) scannerUltraZoom

Definition at line 1521 of file HeadUpDisplay.m.

1522{

1523 return scanner_ultra_zoom;

1524}

References scanner_ultra_zoom, and scannerUltraZoom.

Referenced by lineWidth, and scannerUltraZoom.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ scannerZoom

- (GLfloat) scannerZoom

Definition at line 586 of file HeadUpDisplay.m.

587{

588 return scanner_zoom;

589}

References scanner_zoom, and scannerZoom.

Referenced by PlayerEntity::commanderDataDictionary, PlayerEntity::doBookkeeping:, hudName, scannerZoom, and PlayerEntity::switchHudTo:.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setCompassActive:

- (void) setCompassActive: (BOOL) newValue

Definition at line 680 of file HeadUpDisplay.m.

680 :(BOOL)newValue

681{

682 _compassActive = !!newValue;

683}

References _compassActive.

Referenced by PlayerEntity(OOPrivate)::noteCompassLostTarget, and PlayerEntity::switchHudTo:.

Here is the caller graph for this function:

◆ SetCompassBlipColor

- (OOINLINE void) SetCompassBlipColor		(GLfloat)	relativeZ
		(GLfloat)	alpha

implementation

Definition at line 1687 of file HeadUpDisplay.m.

{
    if (relativeZ >= 0.0f)
    {
        OOGL(glColor4f(0.0f, 1.0f, 0.0f, alpha));
    }
    else
    {
        OOGL(glColor4f(1.0f, 0.0f, 0.0f, alpha));
    }
}

References OOGL, and OOINLINE.

◆ setCrosshairDefinition:

- (BOOL) setCrosshairDefinition: (NSString *) newDefinition

Definition at line 966 of file HeadUpDisplay.m.

                               :(NSString *)newDefinition
{
    // force crosshair redraw
    [_crosshairs release];
    _crosshairs = nil;
 
    [_crosshairOverrides release];
    _crosshairOverrides = [[ResourceManager dictionaryFromFilesNamed:newDefinition
                                                                                                                 inFolder:@"Config"
                                                                                                                 andMerge:YES] retain];
    if (_crosshairOverrides == nil || [_crosshairOverrides count] == 0)
    { // invalid file
        [_crosshairOverrides release];
        _crosshairOverrides = [[ResourceManager dictionaryFromFilesNamed:@"crosshairs.plist"
                                                                                                                     inFolder:@"Config"
                                                                                                                     andMerge:YES] retain];
        crosshairDefinition = @"crosshairs.plist";
        return NO;
    }
    crosshairDefinition = [newDefinition copy];
    return YES;
}

References _crosshairOverrides, _crosshairs, count, crosshairDefinition, ResourceManager::dictionaryFromFilesNamed:inFolder:andMerge:, and nil.

Referenced by initWithDictionary:inFile:.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setDeferredHudName:

- (void) setDeferredHudName: (NSString *) newDeferredHudName

Definition at line 692 of file HeadUpDisplay.m.

                           :(NSString *)newDeferredHudName
{
    [deferredHudName release];
    deferredHudName = [newDeferredHudName copy];
}

References deferredHudName.

Referenced by PlayerEntity::switchHudTo:.

Here is the caller graph for this function:

◆ setHidden:

- (void) setHidden: (BOOL) newValue

Definition at line 633 of file HeadUpDisplay.m.

633 :(BOOL)newValue

634{

635 hudHidden = !!newValue; // ensure YES or NO

636}

References hudHidden.

Referenced by PlayerShipSetProperty(), PlayerEntity(OOControlsPrivate)::pollApplicationControls, PlayerEntity::setUpShipFromDictionary:, and PlayerEntity::switchHudTo:.

Here is the caller graph for this function:

◆ setHiddenSelector:hidden:

- (void) setHiddenSelector:		(NSString *)	selectorName
hidden:		(BOOL)	hide

Definition at line 655 of file HeadUpDisplay.m.

                          :(NSString *)selectorName hidden:(BOOL)hide
{
    if (hide)
    {
        [_hiddenSelectors addObject:selectorName];
    }
    else
    {
        [_hiddenSelectors removeObject:selectorName];
    }
}

Referenced by PlayerShipHideHUDSelector(), and PlayerShipShowHUDSelector().

Here is the caller graph for this function:

◆ setHudName:

- (void) setHudName: (NSString *) newHudName

Definition at line 555 of file HeadUpDisplay.m.

                   :(NSString *)newHudName
{
    if (newHudName != nil)
    {
        [hudName release];
        hudName = [newHudName copy];
    }
}

References hudName, and nil.

◆ setLineWidth:

- (void) setLineWidth: (GLfloat) value

Definition at line 4405 of file HeadUpDisplay.m.

4405 :(GLfloat) value

4406{

4407 lineWidth = value;

4408}

References lineWidth.

Referenced by Universe::drawUniverse.

Here is the caller graph for this function:

◆ setMinimalisticScanner:

- (void) setMinimalisticScanner: (BOOL) newValue

Definition at line 1495 of file HeadUpDisplay.m.

1495 : (BOOL) newValue

1496{

1497 minimalistic_scanner = !!newValue;

1498}

References minimalistic_scanner.

Referenced by PlayerShipSetProperty().

Here is the caller graph for this function:

◆ setNonlinearScanner:

- (void) setNonlinearScanner: (BOOL) newValue

Definition at line 1515 of file HeadUpDisplay.m.

1515 : (BOOL) newValue

1516{

1517 nonlinear_scanner = !!newValue;

1518}

References nonlinear_scanner.

Referenced by PlayerShipSetProperty().

Here is the caller graph for this function:

◆ setOverallAlpha:

- (void) setOverallAlpha: (GLfloat) newAlphaValue

Definition at line 603 of file HeadUpDisplay.m.

603 :(GLfloat) newAlphaValue

604{

605 overallAlpha = OOClamp_0_1_f(newAlphaValue);

606}

References overallAlpha.

Referenced by Universe::drawUniverse.

Here is the caller graph for this function:

◆ setReticleColorForIndex:toColor:

- (BOOL) setReticleColorForIndex:		(NSUInteger)	idx
toColor:		(OOColor *)	newColor

Definition at line 575 of file HeadUpDisplay.m.

                                :(NSUInteger)idx toColor:(OOColor *)newColor
{
    if (newColor && idx < [_reticleColors count])
    {
        [_reticleColors replaceObjectAtIndex:idx withObject:newColor];
        return YES;
    }
    return NO;
}

References _reticleColors, and count.

Referenced by PlayerShipSetProperty().

Here is the caller graph for this function:

◆ setReticleTargetSensitive:

- (void) setReticleTargetSensitive: (BOOL) newReticleTargetSensitiveValue

Definition at line 615 of file HeadUpDisplay.m.

615 :(BOOL) newReticleTargetSensitiveValue

616{

617 reticleTargetSensitive = !!newReticleTargetSensitiveValue; // ensure YES or NO.

618}

References reticleTargetSensitive.

Referenced by PlayerShipSetProperty().

Here is the caller graph for this function:

◆ setScannerUltraZoom:

- (void) setScannerUltraZoom: (BOOL) newValue

Definition at line 1527 of file HeadUpDisplay.m.

1527 : (BOOL) newValue

1528{

1529 scanner_ultra_zoom = !!newValue;

1530}

References scanner_ultra_zoom.

Referenced by PlayerShipSetProperty().

Here is the caller graph for this function:

◆ setScannerZoom:

- (void) setScannerZoom: (GLfloat) value

Definition at line 592 of file HeadUpDisplay.m.

592 :(GLfloat)value

593{

594 scanner_zoom = value;

595}

References scanner_zoom.

Referenced by PlayerEntity::doBookkeeping:, PlayerEntity::enterDock:, PlayerEntity::leaveDock:, PlayerEntity::setCommanderDataFromDictionary:, and PlayerEntity::switchHudTo:.

Here is the caller graph for this function:

Member Data Documentation

◆ _compassActive

- (BOOL) _compassActive

private

Definition at line 281 of file HeadUpDisplay.h.

Referenced by initWithDictionary:inFile:, isCompassActive, and setCompassActive:.

◆ _crosshairColor

- (OOColor*) _crosshairColor

private

Definition at line 277 of file HeadUpDisplay.h.

Referenced by dealloc, and initWithDictionary:inFile:.

◆ _crosshairOverrides

- (NSDictionary*) _crosshairOverrides

private

Definition at line 276 of file HeadUpDisplay.h.

Referenced by dealloc, initWithDictionary:inFile:, and setCrosshairDefinition:.

◆ _crosshairs

- (OOCrosshairs*) _crosshairs

private

Definition at line 272 of file HeadUpDisplay.h.

Referenced by setCrosshairDefinition:.

◆ _crosshairScale

- (GLfloat) _crosshairScale

private

Definition at line 278 of file HeadUpDisplay.h.

Referenced by initWithDictionary:inFile:.

◆ _crosshairWidth

- (GLfloat) _crosshairWidth

private

Definition at line 279 of file HeadUpDisplay.h.

Referenced by initWithDictionary:inFile:, and renderHUD.

◆ _hiddenSelectors

- (NSMutableSet*) _hiddenSelectors

private

Definition at line 269 of file HeadUpDisplay.h.

Referenced by dealloc, and initWithDictionary:inFile:.

◆ _lastOverallAlpha

- (GLfloat) _lastOverallAlpha

private

Definition at line 274 of file HeadUpDisplay.h.

◆ _lastWeaponsOnline

- (BOOL) _lastWeaponsOnline

private

Definition at line 275 of file HeadUpDisplay.h.

◆ _lastWeaponType

- (OOWeaponType) _lastWeaponType

private

Definition at line 273 of file HeadUpDisplay.h.

Referenced by initWithDictionary:inFile:.

◆ _reticleColors

- (NSMutableArray*) _reticleColors

private

Definition at line 283 of file HeadUpDisplay.h.

Referenced by dealloc, initWithDictionary:inFile:, reticleColorForIndex:, and setReticleColorForIndex:toColor:.

◆ allowBigGui

- (BOOL) allowBigGui

private

Definition at line 639 of file HeadUpDisplay.m.

640{

641 return allowBigGui || hudHidden;

642}

Referenced by allowBigGui, initWithDictionary:inFile:, and PlayerEntity(OOControlsPrivate)::pollGuiArrowKeyControls:.

◆ cloakIndicatorOnStatusLight

- (BOOL) cloakIndicatorOnStatusLight

private

Definition at line 261 of file HeadUpDisplay.h.

Referenced by initWithDictionary:inFile:.

◆ crosshairDefinition

- (NSString *) crosshairDefinition

private

Definition at line 960 of file HeadUpDisplay.m.

961{

962 return crosshairDefinition;

963}

Referenced by crosshairDefinition, dealloc, initWithDictionary:inFile:, PlayerShipGetProperty(), and setCrosshairDefinition:.

◆ deferredHudName

- (NSString *) deferredHudName

private

Definition at line 699 of file HeadUpDisplay.m.

700{

701 return deferredHudName;

702}

Referenced by dealloc, deferredHudName, Universe::drawUniverse, initWithDictionary:inFile:, and setDeferredHudName:.

◆ dialArray

- (NSMutableArray*) dialArray

private

Definition at line 241 of file HeadUpDisplay.h.

Referenced by dealloc, and initWithDictionary:inFile:.

◆ hudHidden

- (BOOL) hudHidden

private

Definition at line 263 of file HeadUpDisplay.h.

Referenced by initWithDictionary:inFile:, isHidden, and setHidden:.

◆ hudName

- (NSString *) hudName

private

Definition at line 549 of file HeadUpDisplay.m.

550{

551 return hudName;

552}

Referenced by addDial:, dealloc, hudName, initWithDictionary:inFile:, PlayerShipGetProperty(), PlayerShipSetProperty(), resetGuiPositions, and setHudName:.

◆ hudUpdating

- (BOOL) hudUpdating

private

Definition at line 254 of file HeadUpDisplay.h.

Referenced by initWithDictionary:inFile:, isUpdating, and renderHUD.

◆ last_transmitter

- (int) last_transmitter

private

Definition at line 267 of file HeadUpDisplay.h.

Referenced by initWithDictionary:inFile:.

◆ legendArray

- (NSMutableArray*) legendArray

private

Definition at line 240 of file HeadUpDisplay.h.

Referenced by dealloc, and initWithDictionary:inFile:.

◆ lineWidth

- (GLfloat) lineWidth

private

Definition at line 4411 of file HeadUpDisplay.m.

4412{

4413 return lineWidth;

4414}

Referenced by initWithDictionary:inFile:, lineWidth, renderHUD, and setLineWidth:.

◆ mfdArray

- (NSMutableArray*) mfdArray

private

Definition at line 242 of file HeadUpDisplay.h.

Referenced by dealloc, and initWithDictionary:inFile:.

◆ minimalistic_scanner

- (BOOL) minimalistic_scanner

private

Definition at line 286 of file HeadUpDisplay.h.

Referenced by initWithDictionary:inFile:, minimalisticScanner, and setMinimalisticScanner:.

◆ nonlinear_scanner

- (BOOL) nonlinear_scanner

private

Definition at line 289 of file HeadUpDisplay.h.

Referenced by initWithDictionary:inFile:, nonlinearScanner, and setNonlinearScanner:.

◆ overallAlpha

- (GLfloat) overallAlpha

private

Definition at line 597 of file HeadUpDisplay.m.

598{

599 return overallAlpha;

600}

Referenced by drawPrimedEquipment:, Universe::drawUniverse, initWithDictionary:inFile:, overallAlpha, and setOverallAlpha:.

◆ propertiesReticleTargetSensitive

- (NSMutableDictionary *) propertiesReticleTargetSensitive

private

Definition at line 621 of file HeadUpDisplay.m.

622{

623 return propertiesReticleTargetSensitive;

624}

Referenced by dealloc, hudDrawReticleOnTarget, initWithDictionary:inFile:, and propertiesReticleTargetSensitive.

◆ reticleTargetSensitive

- (BOOL) reticleTargetSensitive

private

Definition at line 609 of file HeadUpDisplay.m.

610{

611 return reticleTargetSensitive;

612}

Referenced by hudDrawReticleOnTarget, initWithDictionary:inFile:, reticleTargetSensitive, and setReticleTargetSensitive:.

◆ scanner_ultra_zoom

- (BOOL) scanner_ultra_zoom

private

Definition at line 290 of file HeadUpDisplay.h.

Referenced by initWithDictionary:inFile:, scannerUltraZoom, and setScannerUltraZoom:.

◆ scanner_zoom

- (GLfloat) scanner_zoom

private

Definition at line 245 of file HeadUpDisplay.h.

Referenced by scannerZoom, and setScannerZoom:.

◆ z1

- (GLfloat) z1

private

Definition at line 248 of file HeadUpDisplay.h.

Referenced by drawIconForEmptyPylonAtX:y:width:height:alpha:, drawIconForMissile:selected:status:x:y:width:height:alpha:, drawPrimedEquipment:, hudDrawReticleOnTarget, and hudDrawWaypoint.

The documentation for this class was generated from the following files:

src/Core/HeadUpDisplay.h
src/Core/HeadUpDisplay.m

Instance Methods

Class Methods

Private Attributes

Detailed Description

Method Documentation

◆ addDial:

◆ addLegend:

◆ addMFD:

◆ allowBigGui

◆ checkPlayerInFlight

◆ checkPlayerInSystemFlight

◆ clearHiddenSelectors

◆ crosshairDefinition

◆ crosshairDefinitionForWeaponType:

◆ dealloc

◆ deferredHudName

◆ drawAegis:

◆ drawAftShieldBar:

◆ drawAltitudeBar:

◆ drawASCTarget:

◆ drawCabinTempBar:

◆ drawCharacterQuad

◆ drawClock:

◆ drawCompass:

◆ drawCompassBeaconBlipAt:Size:Alpha:

◆ drawCompassPlanetBlipAt:Size:Alpha:

◆ drawCompassStationBlipAt:Size:Alpha:

◆ drawCompassSunBlipAt:Size:Alpha:

◆ drawCompassTargetBlipAt:Size:Alpha:

◆ drawCrosshairs

◆ drawCustomBar:

◆ drawCustomImage:

◆ drawCustomIndicator:

◆ drawCustomLight:

◆ drawCustomText:

◆ drawDials

◆ drawDirectionCue:

◆ drawEnergyGauge:

◆ drawForwardShieldBar:

◆ drawFPSInfoCounter:

◆ drawFuelBar:

◆ drawGreenSurround:

◆ drawHighlight

◆ drawHUDItem:

◆ drawIconForEmptyPylonAtX:y:width:height:alpha:

◆ drawIconForMissile:selected:status:x:y:width:height:alpha:

◆ drawLegend:

◆ drawLegends

◆ drawMFDs

◆ drawMissileDisplay:

◆ drawMultiFunctionDisplay:withText:asIndex:

◆ drawPitchBar:

◆ drawPrimedEquipment:

◆ drawPrimedEquipmentText:

◆ drawRollBar:

◆ drawScanner:

◆ drawScannerGrid

◆ drawScannerZoomIndicator:

◆ drawScoopStatus:

◆ drawSecondaryTargetReticle:

◆ DrawSpecialOval

◆ drawSpeedBar:

◆ drawStatusLight:

◆ drawStickSensitivityIndicator:

◆ drawSurround:

◆ drawSurroundInternal:color:

◆ drawTargetReticle:

◆ drawTrumbles:

◆ drawWaypoints:

◆ drawWeaponsOfflineText:

◆ drawWeaponTempBar:

◆ drawWitchspaceDestination:

◆ drawYawBar:

◆ drawYellowSurround:

◆ GLColorWithOverallAlpha

◆ GLDrawNonlinearCascadeWeapon

◆ hasHidden:

◆ hudDrawBarAt

◆ hudDrawIndicatorAt

◆ hudDrawMarkerAt