HeadUpDisplay(Private) Category Reference

Instance Methods
(void)	- drawCrosshairs
(void)	- drawLegends
(void)	- drawDials
(void)	- drawMFDs
(void)	- drawLegend:
(void)	- drawHUDItem:
(void)	- drawScanner:
(void)	- drawScannerZoomIndicator:
(void)	- drawCompass:
(void)	- drawCompassPlanetBlipAt:Size:Alpha:
(void)	- drawCompassStationBlipAt:Size:Alpha:
(void)	- drawCompassSunBlipAt:Size:Alpha:
(void)	- drawCompassTargetBlipAt:Size:Alpha:
(void)	- drawCompassBeaconBlipAt:Size:Alpha:
(void)	- drawAegis:
(void)	- drawSpeedBar:
(void)	- drawRollBar:
(void)	- drawPitchBar:
(void)	- drawYawBar:
(void)	- drawEnergyGauge:
(void)	- drawForwardShieldBar:
(void)	- drawAftShieldBar:
(void)	- drawFuelBar:
(void)	- drawWitchspaceDestination:
(void)	- drawCabinTempBar:
(void)	- drawWeaponTempBar:
(void)	- drawAltitudeBar:
(void)	- drawMissileDisplay:
(void)	- drawTargetReticle:
(void)	- drawSecondaryTargetReticle:
(void)	- drawWaypoints:
(void)	- drawStatusLight:
(void)	- drawDirectionCue:
(void)	- drawClock:
(void)	- drawPrimedEquipmentText:
(void)	- drawASCTarget:
(void)	- drawWeaponsOfflineText:
(void)	- drawMultiFunctionDisplay:withText:asIndex:
(void)	- drawFPSInfoCounter:
(void)	- drawScoopStatus:
(void)	- drawStickSensitivityIndicator:
(void)	- drawCustomBar:
(void)	- drawCustomText:
(void)	- drawCustomIndicator:
(void)	- drawCustomLight:
(void)	- drawCustomImage:
(void)	- drawSurroundInternal:color:
(void)	- drawSurround:
(void)	- drawGreenSurround:
(void)	- drawYellowSurround:
(void)	- drawTrumbles:
(NSArray *)	- crosshairDefinitionForWeaponType:
(BOOL)	- checkPlayerInFlight
(BOOL)	- checkPlayerInSystemFlight
(void)	- resetGui:withInfo:
(void)	- resetGuiPosition:withInfo:

Detailed Description

Definition at line 118 of file HeadUpDisplay.m.

Method Documentation

checkPlayerInFlight

- (BOOL) checkPlayerInFlight

Extends class HeadUpDisplay.

Definition at line 214 of file HeadUpDisplay.m.

{
    return [PLAYER isInSpace] && [PLAYER status] != STATUS_DOCKING;
}

checkPlayerInSystemFlight

- (BOOL) checkPlayerInSystemFlight

Extends class HeadUpDisplay.

Definition at line 214 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];
}

crosshairDefinitionForWeaponType:

- (NSArray *) crosshairDefinitionForWeaponType:

(OOWeaponType)

weapon

Extends class HeadUpDisplay.

Definition at line 214 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;
}

drawAegis:

- (void) drawAegis:

(NSDictionary *)

info

Extends class HeadUpDisplay.

Definition at line 1687 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 OOGL.

drawAftShieldBar:

- (void) drawAftShieldBar:

(NSDictionary *)

info

Extends class HeadUpDisplay.

Definition at line 1687 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);
}

drawAltitudeBar:

- (void) drawAltitudeBar:

(NSDictionary *)

info

Extends class HeadUpDisplay.

Definition at line 1687 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);
    
}

drawASCTarget:

- (void) drawASCTarget:

(NSDictionary *)

info

Extends class HeadUpDisplay.

Definition at line 2541 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 kDefaultMineIconKey, kDefaultMissileIconKey, and nil.

drawCabinTempBar:

- (void) drawCabinTempBar:

(NSDictionary *)

info

Extends class HeadUpDisplay.

Definition at line 1687 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);
}

drawClock:

- (void) drawClock:

(NSDictionary *)

info

Extends class HeadUpDisplay.

Definition at line 2541 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);
}

drawCompass:

- (void) drawCompass:

(NSDictionary *)

info

Extends class HeadUpDisplay.

Definition at line 1167 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 CachedInfo::alpha, CachedInfo::height, CachedInfo::width, CachedInfo::x, CachedInfo::x0, CachedInfo::y, and CachedInfo::y0.

drawCompassBeaconBlipAt:Size:Alpha:

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

Extends class HeadUpDisplay.

Definition at line 1687 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();
}

drawCompassPlanetBlipAt:Size:Alpha:

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

Extends class HeadUpDisplay.

Definition at line 1687 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);
    }
}

drawCompassStationBlipAt:Size:Alpha:

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

Extends class HeadUpDisplay.

Definition at line 1687 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();
}

drawCompassSunBlipAt:Size:Alpha:

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

Extends class HeadUpDisplay.

Definition at line 1687 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);
}

drawCompassTargetBlipAt:Size:Alpha:

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

Extends class HeadUpDisplay.

Definition at line 1687 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);
}

drawCrosshairs

- (void) drawCrosshairs

Extends class HeadUpDisplay.

Definition at line 214 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];
}

drawCustomBar:

- (void) drawCustomBar:

(NSDictionary *)

info

Extends class HeadUpDisplay.

Definition at line 1687 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);
}

drawCustomImage:

- (void) drawCustomImage:

(NSDictionary *)

info

Extends class HeadUpDisplay.

Definition at line 1687 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];
 
}

drawCustomIndicator:

- (void) drawCustomIndicator:

(NSDictionary *)

info

Extends class HeadUpDisplay.

Definition at line 1687 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);
}

drawCustomLight:

- (void) drawCustomLight:

(NSDictionary *)

info

Extends class HeadUpDisplay.

Definition at line 1687 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();
}

drawCustomText:

- (void) drawCustomText:

(NSDictionary *)

info

Extends class HeadUpDisplay.

Definition at line 1687 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);
    }
 
}

drawDials

- (void) drawDials

Extends class HeadUpDisplay.

Definition at line 214 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]];
    }
    
}

drawDirectionCue:

- (void) drawDirectionCue:

(NSDictionary *)

info

Extends class HeadUpDisplay.

Definition at line 2541 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();
        }
    }
}

drawEnergyGauge:

- (void) drawEnergyGauge:

(NSDictionary *)

info

Extends class HeadUpDisplay.

Definition at line 1687 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;
    }
}

drawForwardShieldBar:

- (void) drawForwardShieldBar:

(NSDictionary *)

info

Extends class HeadUpDisplay.

Definition at line 1687 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);
}

drawFPSInfoCounter:

- (void) drawFPSInfoCounter:

(NSDictionary *)

info

Extends class HeadUpDisplay.

Definition at line 2541 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
}

drawFuelBar:

- (void) drawFuelBar:

(NSDictionary *)

info

Extends class HeadUpDisplay.

Definition at line 1687 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);
    }
 
}

drawGreenSurround:

- (void) drawGreenSurround:

(NSDictionary *)

info

Extends class HeadUpDisplay.

Definition at line 2541 of file HeadUpDisplay.m.

                          :(NSDictionary *)info
{
    [self drawSurroundInternal:info color:green_color];
}

drawHUDItem:

- (void) drawHUDItem:

(NSDictionary *)

info

Extends class HeadUpDisplay.

Definition at line 214 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();
}

drawLegend:

- (void) drawLegend:

(NSDictionary *)

info

Extends class HeadUpDisplay.

Definition at line 214 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);
            }
        }
    }
}

drawLegends

- (void) drawLegends

Extends class HeadUpDisplay.

Definition at line 214 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]];
    }
}

drawMFDs

- (void) drawMFDs

Extends class HeadUpDisplay.

Definition at line 214 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];
        }
    }
}

drawMissileDisplay:

- (void) drawMissileDisplay:

(NSDictionary *)

info

Extends class HeadUpDisplay.

Definition at line 2541 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));
    }
    
}

drawMultiFunctionDisplay:withText:asIndex:

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

Extends class HeadUpDisplay.

Definition at line 2541 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;
        }
    }
}

drawPitchBar:

- (void) drawPitchBar:

(NSDictionary *)

info

Extends class HeadUpDisplay.

Definition at line 1687 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]);
}

drawPrimedEquipmentText:

- (void) drawPrimedEquipmentText:

(NSDictionary *)

info

drawRollBar:

- (void) drawRollBar:

(NSDictionary *)

info

Extends class HeadUpDisplay.

Definition at line 1687 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]);
}

drawScanner:

- (void) drawScanner:

(NSDictionary *)

info

Extends class HeadUpDisplay.

Definition at line 1167 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();
    
}

drawScannerZoomIndicator:

- (void) drawScannerZoomIndicator:

(NSDictionary *)

info

Extends class HeadUpDisplay.

Definition at line 1167 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));
}

drawScoopStatus:

- (void) drawScoopStatus:

(NSDictionary *)

info

Extends class HeadUpDisplay.

Definition at line 2541 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();
}

drawSecondaryTargetReticle:

- (void) drawSecondaryTargetReticle:

(NSDictionary *)

info

Extends class HeadUpDisplay.

Definition at line 2541 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);   
                    }           
                }
            }
        }
    }
}

drawSpeedBar:

- (void) drawSpeedBar:

(NSDictionary *)

info

Extends class HeadUpDisplay.

Definition at line 1687 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);
}

drawStatusLight:

- (void) drawStatusLight:

(NSDictionary *)

info

Extends class HeadUpDisplay.

Definition at line 2541 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();
}

drawStickSensitivityIndicator:

- (void) drawStickSensitivityIndicator:

(NSDictionary *)

info

Extends class HeadUpDisplay.

Definition at line 2541 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
}

drawSurround:

- (void) drawSurround:

(NSDictionary *)

info

Extends class HeadUpDisplay.

Definition at line 2541 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];
}

drawSurroundInternal:color:

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

Extends class HeadUpDisplay.

Definition at line 2541 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);
}

drawTargetReticle:

- (void) drawTargetReticle:

(NSDictionary *)

info

Extends class HeadUpDisplay.

Definition at line 2541 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];
    }
}

drawTrumbles:

- (void) drawTrumbles:

(NSDictionary *)

info

Extends class HeadUpDisplay.

Definition at line 2541 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];
    }
}

drawWaypoints:

- (void) drawWaypoints:

(NSDictionary *)

info

Extends class HeadUpDisplay.

Definition at line 2541 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];
 
    OOWaypointEntity *waypoint = nil;
    Entity *compass = [PLAYER compassTarget];
    
    foreach (waypoint, [[UNIVERSE currentWaypoints] allValues])
    {
        hudDrawWaypoint(waypoint, PLAYER, z1, alpha, waypoint==compass, scale);
    }
 
}

drawWeaponsOfflineText:

- (void) drawWeaponsOfflineText:

(NSDictionary *)

info

Extends class HeadUpDisplay.

Definition at line 2541 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;
        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);
        
        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);
    }
}

drawWeaponTempBar:

- (void) drawWeaponTempBar:

(NSDictionary *)

info

Extends class HeadUpDisplay.

Definition at line 1687 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);
}

drawWitchspaceDestination:

- (void) drawWitchspaceDestination:

(NSDictionary *)

info

Extends class HeadUpDisplay.

Definition at line 1687 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);
    }
 
}

drawYawBar:

- (void) drawYawBar:

(NSDictionary *)

info

Extends class HeadUpDisplay.

Definition at line 1687 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]);
}

drawYellowSurround:

- (void) drawYellowSurround:

(NSDictionary *)

info

Extends class HeadUpDisplay.

Definition at line 2541 of file HeadUpDisplay.m.

                           :(NSDictionary *)info
{
    [self drawSurroundInternal:info color:yellow_color];
}

resetGui:withInfo:

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

Extends class HeadUpDisplay.

Definition at line 214 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];
}

resetGuiPosition:withInfo:

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

Extends class HeadUpDisplay.

Definition at line 214 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];
}

---

The documentation for this category was generated from the following file:

• src/Core/HeadUpDisplay.m