#include <OOPlanetEntity.h>

Inheritance diagram for OOPlanetEntity:

Collaboration diagram for OOPlanetEntity:

Instance Methods
(id)	- initAsMainPlanetForSystem:

(id)	- initFromDictionary:withAtmosphere:andSeed:forSystem:

(instancetype)	- miniatureVersion

(double)	- rotationalVelocity

(void)	- setRotationalVelocity:

(BOOL)	- planetHasStation

(void)	- launchShuttle

(void)	- welcomeShuttle:

(BOOL)	- hasAtmosphere

(NSString *)	- textureFileName

(void)	- setTextureFileName:

(BOOL)	- setUpPlanetFromTexture:

(OOMaterial *)	- material

(OOMaterial *)	- atmosphereMaterial

(OOMaterial *)	- atmosphereShaderMaterial

(BOOL)	- isFinishedLoading

(Vector)	- airColorAsVector

(OOColor *)	- airColor

(void)	- setAirColor:

(Vector)	- illuminationColorAsVector

(OOColor *)	- illuminationColor

(void)	- setIlluminationColor:

(float)	- airColorMixRatio

(void)	- setAirColorMixRatio:

(float)	- airDensity

(void)	- setAirDensity:

(void)	- setTerminatorThresholdVector:

(Vector)	- terminatorThresholdVector

(void)	- setUpTypeParametersWithSourceInfo:targetInfo: `[implementation]`

(void)	- setUpTerrainParametersWithSourceInfo:targetInfo: `[implementation]`

(void)	- setUpLandParametersWithSourceInfo:targetInfo: `[implementation]`

(void)	- setUpAtmosphereParametersWithSourceInfo:targetInfo: `[implementation]`

(void)	- setUpColorParametersWithSourceInfo:targetInfo:isAtmosphere: `[implementation]`

(id)	- initAsMiniatureVersionOfPlanet: `[implementation]`

(void)	- dealloc `[implementation]`

(NSString *)	- descriptionComponents `[implementation]`

(void)	- setOrientation: `[implementation]`

(double)	- radius `[implementation]`

(OOStellarBodyType)	- planetType `[implementation]`

(void)	- update: `[implementation]`

(void)	- drawImmediate:translucent: `[implementation]`

(BOOL)	- checkCloseCollisionWith: `[implementation]`

(BOOL)	- isPlanet `[implementation]`

(BOOL)	- isVisible `[implementation]`

(void)	- resetGraphicsState `[implementation]`

(NSString *)	- name `[implementation]`

(void)	- setName: `[implementation]`

(BOOL)	- isVisibleToScripts `[implementation]`

(void)	- getJSClass:andPrototype: `[implementation]`

(NSString *)	- oo_jsClassName `[implementation]`

Instance Methods inherited from Entity
(NSUInteger)	- sessionID

(BOOL)	- isShip

(BOOL)	- isDock

(BOOL)	- isStation

(BOOL)	- isSubEntity

(BOOL)	- isPlayer

(BOOL)	- isSun

(BOOL)	- isSunlit

(BOOL)	- isStellarObject

(BOOL)	- isSky

(BOOL)	- isWormhole

(BOOL)	- isEffect

(BOOL)	- isVisualEffect

(BOOL)	- isWaypoint

(BOOL)	- validForAddToUniverse

(void)	- addToLinkedLists

(void)	- removeFromLinkedLists

(void)	- updateLinkedLists

(void)	- wasAddedToUniverse

(void)	- wasRemovedFromUniverse

(void)	- warnAboutHostiles

(CollisionRegion *)	- collisionRegion

(void)	- setCollisionRegion:

(void)	- setUniversalID:

(OOUniversalID)	- universalID

(BOOL)	- throwingSparks

(void)	- setThrowSparks:

(void)	- throwSparks

(void)	- setOwner:

(id)	- owner

(ShipEntity *)	- parentEntity

(ShipEntity *)	- rootShipEntity

(void)	- setPosition:

(void)	- setPositionX:y:z:

(HPVector)	- position

(Vector)	- cameraRelativePosition

(GLfloat)	- cameraRangeFront

(GLfloat)	- cameraRangeBack

(void)	- updateCameraRelativePosition

(Vector)	- vectorTo:

(HPVector)	- absolutePositionForSubentity

(HPVector)	- absolutePositionForSubentityOffset:

(double)	- zeroDistance

(double)	- camZeroDistance

(NSComparisonResult)	- compareZeroDistance:

(BoundingBox)	- boundingBox

(GLfloat)	- mass

(Quaternion)	- orientation

(Quaternion)	- normalOrientation

(void)	- setNormalOrientation:

(void)	- orientationChanged

(void)	- setVelocity:

(Vector)	- velocity

(double)	- speed

(GLfloat)	- distanceTravelled

(void)	- setDistanceTravelled:

(void)	- setStatus:

(OOEntityStatus)	- status

(void)	- setScanClass:

(OOScanClass)	- scanClass

(void)	- setEnergy:

(GLfloat)	- energy

(void)	- setMaxEnergy:

(GLfloat)	- maxEnergy

(void)	- applyRoll:andClimb:

(void)	- applyRoll:climb:andYaw:

(void)	- moveForward:

(OOMatrix)	- rotationMatrix

(OOMatrix)	- drawRotationMatrix

(OOMatrix)	- transformationMatrix

(OOMatrix)	- drawTransformationMatrix

(BOOL)	- canCollide

(GLfloat)	- collisionRadius

(GLfloat)	- frustumRadius

(void)	- setCollisionRadius:

(NSMutableArray *)	- collisionArray

(void)	- applyVelocity:

(void)	- takeEnergyDamage:from:becauseOf:weaponIdentifier:

(void)	- dumpState

(void)	- dumpSelfState

(NSUInteger)	- lastDrawCounter

(void)	- setLastDrawCounter:

(double)	- findCollisionRadius

(BOOL)	- isInSpace

(BOOL)	- isImmuneToBreakPatternHide

(GLfloat)	- universalTime

(GLfloat)	- spawnTime

(GLfloat)	- timeElapsedSinceSpawn

(void)	- setAtmosphereFogging:

(OOColor *)	- fogUniform

(NSString *)	- descriptionForObjDumpBasic

(NSString *)	- descriptionForObjDump

(NSSet *)	- allTextures

(id)	- init `[implementation]`

(BOOL)	- checkLinkedLists `[implementation]`

(id< OOWeakReferenceSupport >)	- superShaderBindingTarget `[implementation]`

(Vector)	- relativePosition `[implementation]`

(void)	- subEntityReallyDied: `[implementation]`

(BOOL)	- isBreakPattern

(void)	- inspect `[implementation]`

(BOOL)	- isECMBlast

(BOOL)	- isExhaust

(BOOL)	- isFlasher

(void)	- deleteJSSelf

(jsval)	- oo_jsValueInContext: `[implementation]`

(BOOL)	- isCascadeWeapon

(BOOL)	- isPlayerLikeShip

(GLfloat)	- clock `[implementation]`

(unsigned)	- pseudoFixedD100 `[implementation]`

(unsigned)	- pseudoFixedD256 `[implementation]`

(unsigned)	- systemGovernment `[implementation]`

(unsigned)	- systemEconomy `[implementation]`

(unsigned)	- systemTechLevel `[implementation]`

(unsigned)	- systemPopulation `[implementation]`

(unsigned)	- systemProductivity `[implementation]`

(BOOL)	- isShipWithSubEntityShip:

(void)	- drawSubEntityImmediate:translucent: `[implementation]`

Instance Methods inherited from OOWeakRefObject
(id)	- weakSelf

(id)	- weakRetain `[implementation]`

(void)	- weakRefDied: `[implementation]`

Instance Methods inherited from <OOWeakReferenceSupport>
(id)	- OO_RETURNS_RETAINED

Class Methods
(static Vector)	+ RandomHSBColor(void) `[implementation]`

(static Vector)	+ LighterHSBColor `[implementation]`

(static Vector)	+ HSBColorWithColor `[implementation]`

(static OOColor *)	+ ColorWithHSBColor `[implementation]`

Private Attributes
OOPlanetDrawable *	_planetDrawable

OOPlanetDrawable *	_atmosphereDrawable

OOPlanetDrawable *	_cloudsShaderDrawable

OOPlanetDrawable *	_atmosphereShaderDrawable

BOOL	_miniature

OOColor *	_airColor

OOColor *	_illuminationColor

float	_airColorMixRatio

float	_airDensity

double	_mesopause2

Vector	_rotationAxis

float	_rotationalVelocity

Quaternion	_atmosphereOrientation

float	_atmosphereRotationalVelocity

Vector	_terminatorThresholdVector

unsigned	_shuttlesOnGround

OOTimeDelta	_lastLaunchTime

OOTimeDelta	_shuttleLaunchInterval

NSDictionary *	_materialParameters

NSString *	_textureName

NSString *	_normSpecMapName

NSString *	_name

Additional Inherited Members
Public Attributes inherited from Entity
OOUniversalID	universalID

unsigned	isShip: 1

unsigned	isStation: 1

unsigned	isPlayer: 1

unsigned	isWormhole: 1

unsigned	isSubEntity: 1

unsigned	hasMoved: 1

unsigned	hasRotated: 1

unsigned	hasCollided: 1

unsigned	isSunlit: 1

unsigned	collisionTestFilter: 2

unsigned	throw_sparks: 1

unsigned	isImmuneToBreakPatternHide: 1

unsigned	isExplicitlyNotMainStation: 1

unsigned	isVisualEffect: 1

OOScanClass	scanClass

GLfloat	zero_distance

GLfloat	cam_zero_distance

GLfloat	no_draw_distance

GLfloat	collision_radius

HPVector	position

Vector	cameraRelativePosition

Quaternion	orientation

OOColor *	atmosphereFogging

int	zero_index

Entity *	x_previous

Entity *	x_next

Entity *	y_previous

Entity *	y_next

Entity *	z_previous

Entity *	z_next

Entity *	collision_chain

OOUniversalID	shadingEntityID

Entity *	collider

CollisionRegion *	collisionRegion

Protected Attributes inherited from Entity
HPVector	lastPosition

Quaternion	lastOrientation

GLfloat	distanceTravelled

OOMatrix	rotMatrix

Vector	velocity

GLfloat	energy

GLfloat	maxEnergy

BoundingBox	boundingBox

GLfloat	mass

NSMutableArray *	collidingEntities

OOTimeAbsolute	spawnTime

struct JSObject *	_jsSelf

NSUInteger	lastDrawCounter

Protected Attributes inherited from OOWeakRefObject
OOWeakReference *	weakSelf

Detailed Description

Definition at line 39 of file OOPlanetEntity.h.

Method Documentation

◆ airColor

- (OOColor *) airColor

Definition at line 289 of file OOPlanetEntity.m.

{
    return _airColor;
}

References OOColor::colorWithHue:saturation:brightness:alpha:.

Here is the call graph for this function:

◆ airColorAsVector

- (Vector) airColorAsVector

Definition at line 289 of file OOPlanetEntity.m.

{
    float r, g, b, a;
    [_airColor getRed:&r green:&g blue:&b alpha:&a];
    return make_vector(r, g, b); // don't care about a
}

◆ airColorMixRatio

- (float) airColorMixRatio

Definition at line 289 of file OOPlanetEntity.m.

{
    return _airColorMixRatio;
}

◆ airDensity

- (float) airDensity

Definition at line 289 of file OOPlanetEntity.m.

{
    return _airDensity;
}

◆ atmosphereMaterial

- (OOMaterial *) atmosphereMaterial

Definition at line 289 of file OOPlanetEntity.m.

{
    return [_atmosphereDrawable material];
}

◆ atmosphereShaderMaterial

- (OOMaterial *) atmosphereShaderMaterial

Definition at line 289 of file OOPlanetEntity.m.

{
    if(!_atmosphereShaderDrawable)  return nil;
    return [_atmosphereShaderDrawable material];
}

◆ checkCloseCollisionWith:

- (BOOL) checkCloseCollisionWith: (Entity *) other

implementation

Reimplemented from Entity.

Definition at line 289 of file OOPlanetEntity.m.

                                :(Entity *)other
{
    if (!other)
        return NO;
    if (other->isShip)
    {
        ShipEntity *ship = (ShipEntity *)other;
        if ([ship behaviour] == BEHAVIOUR_LAND_ON_PLANET)
        {
            return NO;
        }
    }
    
    return YES;
}

◆ ColorWithHSBColor

+ (static OOColor *) ColorWithHSBColor (Vector) c

implementation

Definition at line 289 of file OOPlanetEntity.m.

{
    return [OOColor colorWithHue:c.x saturation:c.y brightness:c.z alpha:1.0];
}

◆ dealloc

- (void) dealloc

implementation

Reimplemented from Entity.

Definition at line 289 of file OOPlanetEntity.m.

{
    DESTROY(_name);
    DESTROY(_planetDrawable);
    DESTROY(_atmosphereDrawable);
    DESTROY(_cloudsShaderDrawable);
    DESTROY(_atmosphereShaderDrawable);
    DESTROY(_airColor);
    DESTROY(_illuminationColor);
    DESTROY(_materialParameters);
    DESTROY(_textureName);
    DESTROY(_normSpecMapName);
    
    [[OOGraphicsResetManager sharedManager] unregisterClient:self];
 
    [super dealloc];
}

◆ descriptionComponents

- (NSString *) descriptionComponents

implementation

Reimplemented from Entity.

Definition at line 289 of file OOPlanetEntity.m.

{
    return [NSString stringWithFormat:@"position: %@ radius: %g m", HPVectorDescription([self position]), [self radius]];
}

◆ drawImmediate:translucent:

- (void) drawImmediate:	(bool)	immediate
translucent:	(bool)	translucent

implementation

Reimplemented from Entity.

Definition at line 289 of file OOPlanetEntity.m.

                      :(bool)immediate translucent:(bool)translucent
{
    BOOL canDrawShaderAtmosphere = _atmosphereShaderDrawable && [UNIVERSE detailLevel] >= DETAIL_LEVEL_SHADERS;
    
    if ([UNIVERSE breakPatternHide])   return; // DON'T DRAW
    if (_miniature && ![self isFinishedLoading])  return; // For responsiveness, don't block to draw as miniature.
 
    // too far away to be drawn
    if (magnitude(cameraRelativePosition) > [self radius]*3000) {
        return;
    }
    if (![UNIVERSE viewFrustumIntersectsSphereAt:cameraRelativePosition withRadius:([self radius] + ATMOSPHERE_DEPTH)])
    {
        // Don't draw
        return;
    }
    
    if ([UNIVERSE wireframeGraphics])  OOGLWireframeModeOn();
    
    if (!_miniature)
    {
        [_planetDrawable calculateLevelOfDetailForViewDistance:cam_zero_distance];
        [_atmosphereDrawable setLevelOfDetail:[_planetDrawable levelOfDetail]];
        if (canDrawShaderAtmosphere)
        {
            if (_cloudsShaderDrawable)  [_cloudsShaderDrawable setLevelOfDetail: [_planetDrawable levelOfDetail]];
            [_atmosphereShaderDrawable setLevelOfDetail:[_planetDrawable levelOfDetail]];
        }
    }
 
    // 500km squared
    //  if (magnitude2(cameraRelativePosition) > 250000000000.0) 
    /* Temporarily for 1.82 make this branch unconditional. There's an
     * odd change in appearance when crossing this boundary, which can
     * be quite noticeable. There don't appear to be close-range
     * problems with doing it this way all the time, though it's not
     * ideal. - CIM */
    {
        /* at this distance the atmosphere is too close to the planet
         * for a 24-bit depth buffer to reliably distinguish the two,
         * so cheat and draw the atmosphere on the opaque pass: it's
         * far enough away that painter's algorithm should do fine */
        [_planetDrawable renderOpaqueParts];
        if (_atmosphereDrawable != nil)
        {
            OOGLPushModelView();
            OOGLMultModelView(OOMatrixForQuaternionRotation(_atmosphereOrientation));
            if (canDrawShaderAtmosphere)
            {
                if(_cloudsShaderDrawable) [_cloudsShaderDrawable renderTranslucentPartsOnOpaquePass];
                [_atmosphereShaderDrawable renderTranslucentPartsOnOpaquePass];
            }
            else
            {
                [_atmosphereDrawable renderTranslucentPartsOnOpaquePass];
            }
            OOGLPopModelView();
        }
    }
#if OOLITE_HAVE_FIXED_THE_ABOVE_DESCRIBED_BUG_WHICH_WE_HAVENT
    else 
    {
        /* At close range we can do this properly and draw the
         * atmosphere on the transparent pass */
        if (translucent)
        {
            if (_atmosphereDrawable != nil)
            {
                OOGLPushModelView();
                OOGLMultModelView(OOMatrixForQuaternionRotation(_atmosphereOrientation));
                [_atmosphereDrawable renderTranslucentParts];
                if (canDrawShaderAtmosphere)  [_atmosphereShaderDrawable renderTranslucentParts];
                OOGLPopModelView();
            }
        }
        else
        {
            [_planetDrawable renderOpaqueParts];
        }
    }
#endif
    
    if ([UNIVERSE wireframeGraphics])  OOGLWireframeModeOff();
}

◆ getJSClass:andPrototype:

- (void) getJSClass:	(JSClass **)	outClass
andPrototype:	(JSObject **)	outPrototype

implementation

Reimplemented from Entity.

Provided by category OOPlanetEntity(OOJavaScriptExtensions).

Definition at line 201 of file OOJSPlanet.m.

                  :(JSClass **)outClass andPrototype:(JSObject **)outPrototype
{
    *outClass = &sPlanetClass;
    *outPrototype = sPlanetPrototype;
}

◆ hasAtmosphere

- (BOOL) hasAtmosphere

Definition at line 289 of file OOPlanetEntity.m.

{
    return _atmosphereDrawable != nil;
}

◆ HSBColorWithColor

+ (static Vector) HSBColorWithColor (OOColor *) color

implementation

Definition at line 282 of file OOPlanetEntity.m.

{
    OOHSBAComponents c = [color hsbaComponents];
    return (Vector){ c.h/360, c.s, c.b };
}

References OOHSBAComponents::b, OOHSBAComponents::h, OOColor::hsbaComponents, and OOHSBAComponents::s.

Here is the call graph for this function:

◆ illuminationColor

- (OOColor *) illuminationColor

Definition at line 289 of file OOPlanetEntity.m.

{
    return _illuminationColor;
}

◆ illuminationColorAsVector

- (Vector) illuminationColorAsVector

Definition at line 289 of file OOPlanetEntity.m.

{
    float r, g, b, a;
    [_illuminationColor getRed:&r green:&g blue:&b alpha:&a];
    return make_vector(r, g, b); // don't care about a
}

◆ initAsMainPlanetForSystem:

- (id) initAsMainPlanetForSystem: (OOSystemID) s

Definition at line 1 of file OOPlanetEntity.m.

                                :(OOSystemID)s
{
    NSMutableDictionary *planetInfo = [[UNIVERSE generateSystemData:s] mutableCopy];
    [planetInfo autorelease];
    
    [planetInfo oo_setBool:YES forKey:@"mainForLocalSystem"];
    if (s != [PLAYER systemID])
    {
        [planetInfo oo_setBool:YES forKey:@"isMiniature"];
    }
    return [self initFromDictionary:planetInfo withAtmosphere:[planetInfo oo_boolForKey:@"has_atmosphere" defaultValue:YES] andSeed:[[UNIVERSE systemManager] getRandomSeedForSystem:s inGalaxy:[PLAYER galaxyNumber]] forSystem:s];
}

◆ initAsMiniatureVersionOfPlanet:

- (id) initAsMiniatureVersionOfPlanet: (OOPlanetEntity *) planet

implementation

Definition at line 289 of file OOPlanetEntity.m.

                                     :(OOPlanetEntity *)planet
{
    // Nasty, nasty. I'd really prefer to have a separate entity class for this.
    if (planet == nil)
    {
        [self release];
        return nil;
    }
    
    self = [self init];
    if (self == nil)  return nil;
    
    scanClass = CLASS_NO_DRAW;
    [self setStatus:STATUS_COCKPIT_DISPLAY];
    
    collision_radius = planet->collision_radius * PLANET_MINIATURE_FACTOR;
    orientation = planet->orientation;
    _rotationAxis = planet->_rotationAxis;
    _atmosphereOrientation = planet->_atmosphereOrientation;
    _rotationalVelocity = 0.04;
    
    _terminatorThresholdVector = planet->_terminatorThresholdVector;
    
    _miniature = YES;
    
    _planetDrawable = [planet->_planetDrawable copy];
    [_planetDrawable setRadius:collision_radius];
    
    // FIXME: in old planet code, atmosphere (if textured) is set to 0.6 alpha.
    _atmosphereDrawable = [planet->_atmosphereDrawable copy];
    _cloudsShaderDrawable = [planet->_cloudsShaderDrawable copy];
    _atmosphereShaderDrawable = [planet->_atmosphereShaderDrawable copy];
    [_atmosphereDrawable setRadius:collision_radius + ATMOSPHERE_DEPTH * PLANET_MINIATURE_FACTOR * 2.0]; //not to scale: invisible otherwise
    if (_cloudsShaderDrawable)  [_cloudsShaderDrawable setRadius:collision_radius + ATMOSPHERE_DEPTH * PLANET_MINIATURE_FACTOR * 2.0]; //not to scale: invisible otherwise
    if (_atmosphereShaderDrawable)  [_atmosphereShaderDrawable setRadius:collision_radius + ATMOSPHERE_DEPTH * PLANET_MINIATURE_FACTOR * 2.0];
    
    [_planetDrawable setLevelOfDetail:0.8f];
    [_atmosphereDrawable setLevelOfDetail:0.8f];
    if (_cloudsShaderDrawable)  [_cloudsShaderDrawable setLevelOfDetail:0.8f];
    if (_atmosphereShaderDrawable)  [_atmosphereShaderDrawable setLevelOfDetail:0.8f];
    
    return self;
}

◆ initFromDictionary:withAtmosphere:andSeed:forSystem:

- (id) initFromDictionary:	(NSDictionary *)	dict
withAtmosphere:	(BOOL)	atmosphere
andSeed:	(Random_Seed)	seed
forSystem:	(OOSystemID)	systemID

Definition at line 87 of file OOPlanetEntity.m.

                         :(NSDictionary *)dict withAtmosphere:(BOOL)atmosphere andSeed:(Random_Seed)seed forSystem:(OOSystemID)systemID
{
    if (dict == nil)  dict = [NSDictionary dictionary];
    RANROTSeed savedRanrotSeed = RANROTGetFullSeed();
    
    self = [self init];
    if (self == nil)  return nil;
    
    scanClass = CLASS_NO_DRAW;
    
    NSMutableDictionary *planetInfo = [[UNIVERSE generateSystemData:systemID] mutableCopy];
    [planetInfo autorelease];
 
    [self setUpTypeParametersWithSourceInfo:dict targetInfo:planetInfo];
 
    [self setUpTerrainParametersWithSourceInfo:dict targetInfo:planetInfo];
 
 
    // Load random seed override.
    NSString *seedStr = [dict oo_stringForKey:@"seed"];
    if (seedStr != nil)
    {
        Random_Seed overrideSeed = RandomSeedFromString(seedStr);
        if (!is_nil_seed(overrideSeed))  seed = overrideSeed;
        else  OOLogERR(@"planet.fromDict", @"could not interpret \"%@\" as planet seed, using default.", seedStr);
    }
    
    // Generate various planet info.
    seed_for_planet_description(seed);
 
    _name = nil;
    [self setName:OOExpand([dict oo_stringForKey:KEY_PLANETNAME defaultValue:[planetInfo oo_stringForKey:KEY_PLANETNAME defaultValue:@"%H"]])];
    
    int radius_km = [dict oo_intForKey:KEY_RADIUS defaultValue:[planetInfo oo_intForKey:KEY_RADIUS]];
    collision_radius = radius_km * 10.0;    // Scale down by a factor of 100
    OOTechLevelID techLevel = [dict oo_intForKey:KEY_TECHLEVEL defaultValue:[planetInfo oo_intForKey:KEY_TECHLEVEL]];
    
    if (techLevel > 14)  techLevel = 14;
    _shuttlesOnGround = 1 + techLevel / 2;
    _shuttleLaunchInterval = 3600.0 / (double)_shuttlesOnGround;    // All are launched in one hour.
    _lastLaunchTime = [UNIVERSE getTime] + 30.0 - _shuttleLaunchInterval;   // launch 30s after player enters universe.
                                                                            // make delay > 0 to allow scripts adding a station nearby.
    
    int percent_land = [planetInfo oo_intForKey:@"percent_land" defaultValue:24 + (gen_rnd_number() % 48)];
    [planetInfo setObject:[NSNumber numberWithFloat:0.01 * percent_land] forKey:@"land_fraction"];
 
    int percent_ice = [planetInfo oo_intForKey:@"percent_ice" defaultValue:5];
    [planetInfo setObject:[NSNumber numberWithFloat:0.01 * percent_ice] forKey:@"polar_fraction"];
 
    
    RNG_Seed savedRndSeed = currentRandomSeed();
    
    _planetDrawable = [[OOPlanetDrawable alloc] init];
    
    _terminatorThresholdVector = [planetInfo oo_vectorForKey:@"terminator_threshold_vector" defaultValue:OO_TERMINATOR_THRESHOLD_VECTOR_DEFAULT];
    
    // Load material parameters, including atmosphere.
    RANROTSeed planetNoiseSeed = RANROTGetFullSeed();
    [planetInfo setObject:[NSValue valueWithBytes:&planetNoiseSeed objCType:@encode(RANROTSeed)] forKey:@"noise_map_seed"];
    [self setUpLandParametersWithSourceInfo:dict targetInfo:planetInfo];
    
    _airColor = nil;    // default to no air
    _airColorMixRatio = 0.5f;
    _airDensity = 0.75f;
    
    _illuminationColor = [[planetInfo objectForKey:@"illumination_color"] retain];
    
#if NEW_ATMOSPHERE
    if (atmosphere)
    {
        // shader atmosphere always has a radius of collision_radius + ATMOSPHERE_DEPTH. For texture atmosphere, we need to check
        // if a shader atmosphere is also used. If yes, set its radius to just cover the planet so that it doesn't conflict with 
        // the shader atmosphere at the planet edges. If no shader atmosphere is used, then set it to the standard radius
        double atmosphereRadius = [UNIVERSE detailLevel] >= DETAIL_LEVEL_SHADERS ? collision_radius : collision_radius + ATMOSPHERE_DEPTH;
        _atmosphereDrawable = [[OOPlanetDrawable atmosphereWithRadius:atmosphereRadius] retain];
        _cloudsShaderDrawable = [[OOPlanetDrawable atmosphereWithRadius:atmosphereRadius] retain];
        _atmosphereShaderDrawable = [[OOPlanetDrawable atmosphereWithRadius:collision_radius + ATMOSPHERE_DEPTH] retain];
        
        // convert the atmosphere settings to generic 'material parameters'
        percent_land = 100 - [dict oo_intForKey:@"percent_cloud" defaultValue:100 - (3 + (gen_rnd_number() & 31)+(gen_rnd_number() & 31))];
        [planetInfo setObject:[NSNumber numberWithFloat:0.01 * percent_land] forKey:@"cloud_fraction"];
        [self setUpAtmosphereParametersWithSourceInfo:dict targetInfo:planetInfo];
        // planetInfo now contains a valid air_color
        _airColor = [[planetInfo objectForKey:@"air_color"] retain];
        _airColorMixRatio = [planetInfo oo_floatForKey:@"air_color_mix_ratio"];
        
        _airDensity = OOClamp_0_1_f([planetInfo oo_floatForKey:@"air_density"]);
        // OOLog (@"planet.debug",@" translated air colour:%@ cloud colour:%@ polar cloud color:%@", [_airColor rgbaDescription],[(OOColor *)[planetInfo objectForKey:@"cloud_color"] rgbaDescription],[(OOColor *)[planetInfo objectForKey:@"polar_cloud_color"] rgbaDescription]);
 
        _materialParameters = [planetInfo dictionaryWithValuesForKeys:[NSArray arrayWithObjects:@"cloud_fraction", @"air_color", @"air_color_mix_ratio", @"air_density", @"cloud_color", @"polar_cloud_color", @"cloud_alpha", @"land_fraction", @"land_color", @"sea_color", @"polar_land_color", @"polar_sea_color", @"noise_map_seed", @"economy", @"polar_fraction", @"isMiniature", @"perlin_3d", @"terminator_threshold_vector", nil]];
    }
    else
#else
    // NEW_ATMOSPHERE is 0? still differentiate between normal planets and moons.
    if (atmosphere)
    {
        _atmosphereDrawable = [[OOPlanetDrawable atmosphereWithRadius:collision_radius + ATMOSPHERE_DEPTH] retain];
        _airColor = [[OOColor colorWithRed:0.8f green:0.8f blue:0.9f alpha:1.0f] retain];
    }
    if (YES) // create _materialParameters when NEW_ATMOSPHERE is set to 0
#endif
    {
        _materialParameters = [planetInfo dictionaryWithValuesForKeys:[NSArray arrayWithObjects:@"land_fraction", @"land_color", @"sea_color", @"polar_land_color", @"polar_sea_color", @"noise_map_seed", @"economy", @"polar_fraction",  @"isMiniature", @"perlin_3d", @"terminator_threshold_vector", @"illumination_color", nil]];
    }
    [_materialParameters retain];
    
    _mesopause2 = (atmosphere) ? (kMesosphere + collision_radius) * (kMesosphere + collision_radius) : 0.0;
    
    _normSpecMapName = [[dict oo_stringForKey:@"texture_normspec"] retain]; // must be set up before _textureName
    
    _textureName = [[dict oo_stringForKey:@"texture"] retain];
    [self setUpPlanetFromTexture:_textureName];
    [_planetDrawable setRadius:collision_radius];
        
    // Orientation should be handled by the code that calls this planetEntity. Starting with a default value anyway.
    orientation = (Quaternion){ M_SQRT1_2, M_SQRT1_2, 0, 0 };
    _atmosphereOrientation = kIdentityQuaternion;
    _rotationAxis = vector_up_from_quaternion(orientation);
    
    // set speed of rotation.
    if ([dict objectForKey:@"rotational_velocity"])
    {
        _rotationalVelocity = [dict oo_floatForKey:@"rotational_velocity" defaultValue:0.01f * randf()];    // 0.0 .. 0.01 avr 0.005
    }
    else
    {
        _rotationalVelocity = [planetInfo oo_floatForKey:@"rotation_speed" defaultValue:0.005f * randf()]; // 0.0 .. 0.005 avr 0.0025
        _rotationalVelocity *= [planetInfo oo_floatForKey:@"rotation_speed_factor" defaultValue:1.0f];
    }
 
    _atmosphereRotationalVelocity = [dict oo_floatForKey:@"atmosphere_rotational_velocity" defaultValue:0.01f * randf()];
 
    // set energy
    energy = collision_radius * 1000.0f;
    
    setRandomSeed(savedRndSeed);
    RANROTSetFullSeed(savedRanrotSeed);
    
    // rotate planet based on current time, needs to be done here - backported from PlanetEntity.
    int     deltaT = floor(fmod([PLAYER clockTimeAdjusted], 86400));
    quaternion_rotate_about_axis(&orientation, _rotationAxis, _rotationalVelocity * deltaT);
    quaternion_rotate_about_axis(&_atmosphereOrientation, kBasisYVector, _atmosphereRotationalVelocity * deltaT);
    
    
#ifdef OO_DUMP_PLANETINFO
#define CPROP(PROP) OOLog(@"planetinfo.record",@#PROP " = %@;",[(OOColor *)[planetInfo objectForKey:@#PROP] descriptionComponents]);
#define FPROP(PROP) OOLog(@"planetinfo.record",@#PROP " = %f;",[planetInfo oo_floatForKey:@"" #PROP]);
    CPROP(air_color);
    CPROP(illumination_color);
    FPROP(air_color_mix_ratio);
    FPROP(cloud_alpha);
    CPROP(cloud_color);
    FPROP(cloud_fraction);
    CPROP(land_color);
    FPROP(land_fraction);
    CPROP(polar_cloud_color);
    CPROP(polar_land_color);
    CPROP(polar_sea_color);
    CPROP(sea_color);
    OOLog(@"planetinfo.record",@"rotation_speed = %f",_rotationalVelocity);
#endif
 
    [self setStatus:STATUS_ACTIVE];
    
    [[OOGraphicsResetManager sharedManager] registerClient:self];
 
    return self;
}

References _materialParameters, _planetDrawable, ATMOSPHERE_DEPTH, OOPlanetDrawable::atmosphereWithRadius:, OOColor::colorWithRed:green:blue:alpha:, currentRandomSeed(), DETAIL_LEVEL_SHADERS, Entity::init, is_nil_seed(), kBasisYVector, kIdentityQuaternion, kMesosphere, M_SQRT1_2, nil, OOLog, OOLogERR, PLAYER, quaternion_rotate_about_axis(), RandomSeedFromString(), RANROTGetFullSeed(), RANROTSetFullSeed(), OOGraphicsResetManager::registerClient:, seed_for_planet_description(), setName:, OOPlanetDrawable::setRadius:, setRandomSeed(), Entity::setStatus:, setUpAtmosphereParametersWithSourceInfo:targetInfo:, setUpLandParametersWithSourceInfo:targetInfo:, setUpPlanetFromTexture:, setUpTerrainParametersWithSourceInfo:targetInfo:, setUpTypeParametersWithSourceInfo:targetInfo:, OOGraphicsResetManager::sharedManager, and vector_up_from_quaternion().

Here is the call graph for this function:

◆ isFinishedLoading

- (BOOL) isFinishedLoading

Definition at line 289 of file OOPlanetEntity.m.

{
    OOMaterial *material = [self material];
    if (material != nil && ![material isFinishedLoading])  return NO;
    material = [self atmosphereMaterial];
    if (material != nil && ![material isFinishedLoading])  return NO;
    material = [self atmosphereShaderMaterial];
    if (material != nil && ![material isFinishedLoading])  return NO;
    return YES;
}

◆ isPlanet

- (BOOL) isPlanet

implementation

Reimplemented from Entity.

Definition at line 289 of file OOPlanetEntity.m.

{
    return YES;
}

◆ isVisible

- (BOOL) isVisible

implementation

Reimplemented from Entity.

Definition at line 289 of file OOPlanetEntity.m.

{
    return YES;
}

◆ isVisibleToScripts

- (BOOL) isVisibleToScripts

implementation

Reimplemented from Entity.

Provided by category OOPlanetEntity(OOJavaScriptExtensions).

Definition at line 201 of file OOJSPlanet.m.

{
    OOStellarBodyType type = [self planetType];
    return type == STELLAR_TYPE_NORMAL_PLANET || type == STELLAR_TYPE_MOON;
}

◆ launchShuttle

- (void) launchShuttle

Definition at line 289 of file OOPlanetEntity.m.

{
    if (_shuttlesOnGround == 0)  
    {
        return;
    }
    if ([PLAYER status] == STATUS_START_GAME)
    {
        // don't launch if game not started
        return;
    }
    if (self != [UNIVERSE planet] && ![self planetHasStation])
    {
        // don't launch shuttles when no station is nearby.
        _shuttlesOnGround = 0;
        return;
    }
    
    Quaternion  q1;
    quaternion_set_random(&q1);
    float start_distance = collision_radius + 125.0f;
    HPVector launch_pos = HPvector_add(position, vectorToHPVector(vector_multiply_scalar(vector_forward_from_quaternion(q1), start_distance)));
    
    ShipEntity *shuttle_ship = [UNIVERSE newShipWithRole:@"shuttle"];   // retain count = 1
    if (shuttle_ship)
    {
        if ([[shuttle_ship crew] count] == 0)
        {
            [shuttle_ship setSingleCrewWithRole:@"trader"];
        }
        
        [shuttle_ship setPosition:launch_pos];
        [shuttle_ship setOrientation:q1];
        
        [shuttle_ship setScanClass: CLASS_NEUTRAL];
        [shuttle_ship setCargoFlag:CARGO_FLAG_FULL_PLENTIFUL];
        [shuttle_ship switchAITo:@"oolite-shuttleAI.js"];
        [UNIVERSE addEntity:shuttle_ship];  // STATUS_IN_FLIGHT, AI state GLOBAL
        _shuttlesOnGround--;
        _lastLaunchTime = [UNIVERSE getTime];
        
        [shuttle_ship release];
    }
}

◆ LighterHSBColor

+ (static Vector) LighterHSBColor (Vector) c

implementation

Definition at line 271 of file OOPlanetEntity.m.

{
    return (Vector)
    {
        c.x,
        c.y * 0.25f,
        1.0f - (c.z * 0.1f)
    };
}

◆ material

- (OOMaterial *) material

Definition at line 289 of file OOPlanetEntity.m.

{
    return [_planetDrawable material];
}

◆ miniatureVersion

- (instancetype) miniatureVersion

Definition at line 289 of file OOPlanetEntity.m.

{
    return [[[[self class] alloc] initAsMiniatureVersionOfPlanet:self] autorelease];
}

◆ name

- (NSString *) name

implementation

Reimplemented from <OOStellarBody>.

Definition at line 289 of file OOPlanetEntity.m.

{
    return _name;
}

◆ oo_jsClassName

- (NSString *) oo_jsClassName

implementation

Reimplemented from Entity.

Provided by category OOPlanetEntity(OOJavaScriptExtensions).

Definition at line 201 of file OOJSPlanet.m.

{
    switch ([self planetType])
    {
        case STELLAR_TYPE_NORMAL_PLANET:
            return @"Planet";
        case STELLAR_TYPE_MOON:
            return @"Moon";
        default:
            return @"Unknown";
    }
}

◆ planetHasStation

- (BOOL) planetHasStation

Definition at line 289 of file OOPlanetEntity.m.

{
    // find the nearest station...
    ShipEntity  *station =  nil;
    station = [UNIVERSE nearestShipMatchingPredicate:IsStationPredicate
                                           parameter:nil
                                    relativeToEntity:self];
    
    if (station && HPdistance([station position], position) < 4 * collision_radius) // there is a station in range.
    {
        return YES;
    }
    return NO;
}

◆ planetType

- (OOStellarBodyType) planetType

implementation

Reimplemented from <OOStellarBody>.

Definition at line 289 of file OOPlanetEntity.m.

{
    if (_miniature)  return STELLAR_TYPE_MINIATURE;
    if (_atmosphereDrawable != nil)  return STELLAR_TYPE_NORMAL_PLANET;
    return STELLAR_TYPE_MOON;
}

◆ radius

- (double) radius

implementation

Reimplemented from <OOStellarBody>.

Definition at line 289 of file OOPlanetEntity.m.

{
    return collision_radius;
}

◆ RandomHSBColor(void)

+ (static Vector RandomHSBColor(void)) (void)

implementation

Definition at line 260 of file OOPlanetEntity.m.

{
    return (Vector)
    {
        gen_rnd_number() / 256.0,
        gen_rnd_number() / 256.0,
        0.5 + gen_rnd_number() / 512.0
    };
}

References gen_rnd_number().

Here is the call graph for this function:

◆ resetGraphicsState

- (void) resetGraphicsState

implementation

Definition at line 289 of file OOPlanetEntity.m.

{
    // reset the texture if graphics mode changes
    [self setUpPlanetFromTexture:_textureName];
}

◆ rotationalVelocity

- (double) rotationalVelocity

Definition at line 289 of file OOPlanetEntity.m.

{
    return _rotationalVelocity;
}

◆ setAirColor:

- (void) setAirColor: (OOColor *) newColor

Definition at line 289 of file OOPlanetEntity.m.

                    :(OOColor *) newColor
{
    if (newColor)
    {
        [_airColor release];
        _airColor = [newColor retain];
    }
}

Referenced by OOPlanetEntity(OOJavaScriptExtensions)::getJSClass:andPrototype:.

Here is the caller graph for this function:

◆ setAirColorMixRatio:

- (void) setAirColorMixRatio: (float) newRatio

Definition at line 289 of file OOPlanetEntity.m.

                            :(float) newRatio
{
    _airColorMixRatio = OOClamp_0_1_f(newRatio);
}

Referenced by OOPlanetEntity(OOJavaScriptExtensions)::getJSClass:andPrototype:.

Here is the caller graph for this function:

◆ setAirDensity:

- (void) setAirDensity: (float) newDensity

Definition at line 289 of file OOPlanetEntity.m.

                      : (float)newDensity
{
    _airDensity = OOClamp_0_1_f(newDensity);
}

Referenced by OOPlanetEntity(OOJavaScriptExtensions)::getJSClass:andPrototype:.

Here is the caller graph for this function:

◆ setIlluminationColor:

- (void) setIlluminationColor: (OOColor *) newColor

Definition at line 289 of file OOPlanetEntity.m.

                             :(OOColor *) newColor
{
    if (newColor)
    {
        [_illuminationColor release];
        _illuminationColor = [newColor retain];
    }
}

Referenced by OOPlanetEntity(OOJavaScriptExtensions)::getJSClass:andPrototype:.

Here is the caller graph for this function:

◆ setName:

- (void) setName: (NSString *) name

implementation

Reimplemented from <OOStellarBody>.

Definition at line 289 of file OOPlanetEntity.m.

                :(NSString *)name
{
    [_name release];
    _name = [name retain];
}

Referenced by OOPlanetEntity(OOJavaScriptExtensions)::getJSClass:andPrototype:, and initFromDictionary:withAtmosphere:andSeed:forSystem:.

Here is the caller graph for this function:

◆ setOrientation:

- (void) setOrientation: (Quaternion) quat

implementation

Reimplemented from Entity.

Definition at line 289 of file OOPlanetEntity.m.

                       :(Quaternion) quat
{
    [super setOrientation: quat];
    _rotationAxis = vector_up_from_quaternion(quat);
}

Referenced by OOPlanetEntity(OOJavaScriptExtensions)::getJSClass:andPrototype:.

Here is the caller graph for this function:

◆ setRotationalVelocity:

- (void) setRotationalVelocity: (double) v

Definition at line 289 of file OOPlanetEntity.m.

                              :(double) v
{
    if ([self hasAtmosphere])
    {
        // FIXME: change atmosphere rotation speed proportionally
    }
    _rotationalVelocity = v;
}

Referenced by OOPlanetEntity(OOJavaScriptExtensions)::getJSClass:andPrototype:.

Here is the caller graph for this function:

◆ setTerminatorThresholdVector:

- (void) setTerminatorThresholdVector: (Vector) newTerminatorThresholdVector

Definition at line 289 of file OOPlanetEntity.m.

                                     :(Vector) newTerminatorThresholdVector
{
    _terminatorThresholdVector.x = newTerminatorThresholdVector.x;
    _terminatorThresholdVector.y = newTerminatorThresholdVector.y;
    _terminatorThresholdVector.z = newTerminatorThresholdVector.z;
}

Referenced by OOPlanetEntity(OOJavaScriptExtensions)::getJSClass:andPrototype:.

Here is the caller graph for this function:

◆ setTextureFileName:

- (void) setTextureFileName: (NSString *) textureName

Definition at line 289 of file OOPlanetEntity.m.

                           :(NSString *)textureName
{
    BOOL isMoon = _atmosphereDrawable == nil;
    
    OOTexture *diffuseMap = nil;
    OOTexture *normalMap = nil;
    NSDictionary *macros = nil;
    NSDictionary *materialDefaults = [ResourceManager materialDefaults];
    
#if OO_SHADERS
    OOGraphicsDetail detailLevel = [UNIVERSE detailLevel];
    BOOL shadersOn = detailLevel >= DETAIL_LEVEL_SHADERS;
#else
    const BOOL shadersOn = NO;
#endif
    
    if (textureName != nil)
    {
        NSDictionary *spec = [NSDictionary dictionaryWithObjectsAndKeys:textureName, @"name", @"yes", @"repeat_s", @"linear", @"min_filter", @"yes", @"cube_map", nil];
        diffuseMap = [OOTexture textureWithConfiguration:spec];
        if (diffuseMap == nil)  return;     // OOTexture will have logged a file-not-found warning.
        if (shadersOn)  
        {
            [diffuseMap ensureFinishedLoading]; // only know if it is a cube map if it's loaded
            if ([diffuseMap isCubeMap])
            {
                macros = [materialDefaults oo_dictionaryForKey:isMoon ? @"moon-customized-cubemap-macros" : @"planet-customized-cubemap-macros"];
            }
            else
            {
                macros = [materialDefaults oo_dictionaryForKey:isMoon ? @"moon-customized-macros" : @"planet-customized-macros"];
            }
        }
        else textureName = @"dynamic";
        
         // let's try giving some love to normalMap too
        if (_normSpecMapName)
        {
            NSDictionary *nspec = [NSDictionary dictionaryWithObjectsAndKeys:_normSpecMapName, @"name", @"yes", @"repeat_s", @"linear", @"min_filter", @"yes", @"cube_map", nil];
            normalMap = [OOTexture textureWithConfiguration:nspec];
            if (normalMap != nil) // OOTexture will have logged a file-not-found warning.
            {
                if (shadersOn)  
                {
                    [normalMap ensureFinishedLoading]; // only know if it is a cube map if it's loaded
                    if ([normalMap isCubeMap])
                    {
                        macros = [materialDefaults oo_dictionaryForKey:isMoon ? @"moon-customized-cubemap-normspec-macros" : @"planet-customized-cubemap-normspec-macros"];
                    }
                    else
                    {
                        macros = [materialDefaults oo_dictionaryForKey:isMoon ? @"moon-customized-normspec-macros" : @"planet-customized-normspec-macros"];
                    }
                }
            }
        }
    }
    else
    {
        [OOPlanetTextureGenerator generatePlanetTexture:&diffuseMap
                                       secondaryTexture:(detailLevel >= DETAIL_LEVEL_SHADERS) ? &normalMap : NULL
                                               withInfo:_materialParameters];
 
        if (shadersOn)
        {
            macros = [materialDefaults oo_dictionaryForKey:isMoon ? @"moon-dynamic-macros" : @"planet-dynamic-macros"];
        }
        textureName = @"dynamic";
    }
 
    /* Generate atmosphere texture */
    if (!isMoon)
    {
        OOLog(@"texture.planet.generate",@"Preparing atmosphere for planet %@",self);
        /* Generate a standalone atmosphere texture */
        OOTexture *atmosphere = nil;
        [OOStandaloneAtmosphereGenerator generateAtmosphereTexture:&atmosphere
                                                        withInfo:_materialParameters];
        
        OOLog(@"texture.planet.generate",@"Planet %@ has atmosphere %@",self,atmosphere);
        
        OOSingleTextureMaterial *dynamicMaterial = [[OOSingleTextureMaterial alloc] initWithName:@"dynamic" texture:atmosphere configuration:nil];
        [_atmosphereDrawable setMaterial:dynamicMaterial];
 
        if (shadersOn)
        {
            NSMutableDictionary *aConfig = [[[materialDefaults oo_dictionaryForKey:@"atmosphere-material"] mutableCopy] autorelease];
            [aConfig setObject:[NSArray arrayWithObjects:diffuseMap, normalMap, nil] forKey:@"_oo_texture_objects"];
            
            NSDictionary *amacros = [materialDefaults oo_dictionaryForKey:@"atmosphere-dynamic-macros"];
            
            OOMaterial *dynamicShaderMaterial = [OOShaderMaterial shaderMaterialWithName:@"dynamic"
                                                                    configuration:aConfig
                                                                    macros:amacros
                                                                    bindingTarget:self];
                                                                    
            if (dynamicShaderMaterial == nil)
            {
                DESTROY(_atmosphereShaderDrawable);
            }
            else
            {
                [_atmosphereShaderDrawable setMaterial:dynamicShaderMaterial];
            }
 
            NSMutableDictionary *cloudConfig = [[[materialDefaults oo_dictionaryForKey:@"clouds-dynamic-material"] mutableCopy] autorelease];
            [cloudConfig setObject:[NSArray arrayWithObjects: atmosphere, nil] forKey: @"_oo_texture_objects"];
            NSDictionary *cloudMacros = [materialDefaults oo_dictionaryForKey: @"clouds-dynamic-macros"];
 
            OOMaterial *cloudsMaterial = [OOShaderMaterial shaderMaterialWithName:@"dynamic"
                                        configuration: cloudConfig
                                        macros: cloudMacros
                                        bindingTarget: self];
            if (cloudsMaterial == nil)
            {
                DESTROY(_cloudsShaderDrawable);
            }
            else
            {
                [_cloudsShaderDrawable setMaterial: cloudsMaterial];
            }
        }
        
        [dynamicMaterial release];
    }
 
    OOMaterial *material = nil;
    
#if OO_SHADERS
    if (shadersOn)
    {
        NSMutableDictionary *config = [[[materialDefaults oo_dictionaryForKey:@"planet-material"] mutableCopy] autorelease];
        [config setObject:[NSArray arrayWithObjects:diffuseMap, normalMap, nil] forKey:@"_oo_texture_objects"];
        
        material = [OOShaderMaterial shaderMaterialWithName:textureName
                                              configuration:config
                                                     macros:macros
                                              bindingTarget:self];
    }
#endif
    if (material == nil)
    {
        material = [[OOSingleTextureMaterial alloc] initWithName:textureName texture:diffuseMap configuration:nil];
        [material autorelease];
    }
    [_planetDrawable setMaterial:material];
}

◆ setUpAtmosphereParametersWithSourceInfo:targetInfo:

- (void) setUpAtmosphereParametersWithSourceInfo:	(NSDictionary *)	sourceInfo
targetInfo:	(NSMutableDictionary *)	targetInfo

implementation

Provided by category OOPlanetEntity(Private).

Definition at line 289 of file OOPlanetEntity.m.

                                                :(NSDictionary *)sourceInfo targetInfo:(NSMutableDictionary *)targetInfo
{
    [self setUpColorParametersWithSourceInfo:sourceInfo targetInfo:targetInfo isAtmosphere:YES];
}

Referenced by initFromDictionary:withAtmosphere:andSeed:forSystem:.

Here is the caller graph for this function:

◆ setUpColorParametersWithSourceInfo:targetInfo:isAtmosphere:

- (void) setUpColorParametersWithSourceInfo:	(NSDictionary *)	sourceInfo
targetInfo:	(NSMutableDictionary *)	targetInfo
isAtmosphere:	(BOOL)	isAtmosphere

implementation

Provided by category OOPlanetEntity(Private).

Definition at line 289 of file OOPlanetEntity.m.

                                           :(NSDictionary *)sourceInfo targetInfo:(NSMutableDictionary *)targetInfo isAtmosphere:(BOOL)isAtmosphere
{
    // Stir the PRNG fourteen times for backwards compatibility.
    unsigned i;
    for (i = 0; i < 14; i++)
    {
        gen_rnd_number();
    }
    
    Vector  landHSB, seaHSB, landPolarHSB, seaPolarHSB, illumHSB;
    Vector  terminatorThreshold;
    OOColor *color;
    
    landHSB = RandomHSBColor();
    
    if (!isAtmosphere)
    {
        do
        {
            seaHSB = RandomHSBColor();
        }
        while (dot_product(landHSB, seaHSB) > .80f); // make sure land and sea colors differ significantly
        
        // saturation bias - avoids really grey oceans
        if (seaHSB.y < 0.22f) seaHSB.y = seaHSB.y * 0.3f + 0.2f;
        // brightness bias - avoids really bright landmasses
        if (landHSB.z > 0.66f) landHSB.z = 0.66f;
        
        // planetinfo.plist overrides
        color = [OOColor colorWithDescription:[sourceInfo objectForKey:@"land_color"]];
        if (color != nil) landHSB = HSBColorWithColor(color);
        else ScanVectorFromString([sourceInfo oo_stringForKey:@"land_hsb_color"], &landHSB);
        
        color = [OOColor colorWithDescription:[sourceInfo objectForKey:@"sea_color"]];
        if (color != nil) seaHSB = HSBColorWithColor(color);
        else ScanVectorFromString([sourceInfo oo_stringForKey:@"sea_hsb_color"], &seaHSB);
        
        color = [OOColor colorWithDescription:[sourceInfo objectForKey:@"illumination_color"]];
        if (color != nil) illumHSB = HSBColorWithColor(color);
        else
        {
            NSString *illumHSBColorString = [sourceInfo oo_stringForKey:@"illumination_hsb_color"];
            if (illumHSBColorString)  ScanVectorFromString(illumHSBColorString, &illumHSB);
            else illumHSB = HSBColorWithColor([OOColor colorWithRed:0.8f green:0.8f blue:0.4f alpha:1.0f]); 
        }
        
        // polar areas are brighter but have less colour (closer to white)
        color = [OOColor colorWithDescription:[sourceInfo objectForKey:@"polar_land_color"]];
        if (color != nil)
        {
            landPolarHSB = HSBColorWithColor(color);
        }
        else 
        {
            landPolarHSB = LighterHSBColor(landHSB);
        }
 
        color = [OOColor colorWithDescription:[sourceInfo objectForKey:@"polar_sea_color"]];
        if (color != nil)
        {
            seaPolarHSB = HSBColorWithColor(color);
        }
        else
        {
            seaPolarHSB = LighterHSBColor(seaHSB);
        }
        
        [targetInfo setObject:ColorWithHSBColor(landHSB) forKey:@"land_color"];
        [targetInfo setObject:ColorWithHSBColor(seaHSB) forKey:@"sea_color"];
        [targetInfo setObject:ColorWithHSBColor(landPolarHSB) forKey:@"polar_land_color"];
        [targetInfo setObject:ColorWithHSBColor(seaPolarHSB) forKey:@"polar_sea_color"];
        [targetInfo setObject:ColorWithHSBColor(illumHSB) forKey:@"illumination_color"];
    }
    else
    {
        landHSB = RandomHSBColor(); // NB: randomcolor is called twice to make the cloud colour similar to the old one.
 
        // add a cloud_color tinge to sky blue({0.66, 0.3, 1}).
        seaHSB = vector_add(landHSB,((Vector){1.333, 0.6, 2})); // 1 part cloud, 2 parts sky blue
        scale_vector(&seaHSB, 0.333);
                
        float cloudAlpha = OOClamp_0_1_f([sourceInfo oo_floatForKey:@"cloud_alpha" defaultValue:1.0f]);
        [targetInfo setObject:[NSNumber numberWithFloat:cloudAlpha] forKey:@"cloud_alpha"];
        
        // planetinfo overrides
        color = [OOColor colorWithDescription:[sourceInfo objectForKey:@"air_color"]];
        if (color != nil) seaHSB = HSBColorWithColor(color);
        
        color = [OOColor colorWithDescription:[sourceInfo objectForKey:@"cloud_color"]];
        if (color != nil) landHSB = HSBColorWithColor(color);
        
        // polar areas: brighter, less saturation
        landPolarHSB = vector_add(landHSB,LighterHSBColor(landHSB));
        scale_vector(&landPolarHSB, 0.5);
        
        color = [OOColor colorWithDescription:[sourceInfo objectForKey:@"polar_cloud_color"]];
        if (color != nil) landPolarHSB = HSBColorWithColor(color);
        
        [targetInfo setObject:ColorWithHSBColor(seaHSB) forKey:@"air_color"];
        [targetInfo setObject:ColorWithHSBColor(landHSB) forKey:@"cloud_color"];
        [targetInfo setObject:ColorWithHSBColor(landPolarHSB) forKey:@"polar_cloud_color"];
        [targetInfo setObject:[NSNumber numberWithFloat:[sourceInfo oo_floatForKey:@"air_color_mix_ratio"]] forKey:@"air_color_mix_ratio"];
    }
    terminatorThreshold = [sourceInfo oo_vectorForKey:@"terminator_threshold_vector" defaultValue:OO_TERMINATOR_THRESHOLD_VECTOR_DEFAULT];
    [targetInfo setObject:[NSString stringWithFormat:@"%f %f %f", terminatorThreshold.x, terminatorThreshold.y, terminatorThreshold.z] forKey:@"terminator_threshold_vector"];
}

◆ setUpLandParametersWithSourceInfo:targetInfo:

- (void) setUpLandParametersWithSourceInfo:	(NSDictionary *)	sourceInfo
targetInfo:	(NSMutableDictionary *)	targetInfo

implementation

Provided by category OOPlanetEntity(Private).

Definition at line 289 of file OOPlanetEntity.m.

                                          :(NSDictionary *)sourceInfo targetInfo:(NSMutableDictionary *)targetInfo
{
    [self setUpColorParametersWithSourceInfo:sourceInfo targetInfo:targetInfo isAtmosphere:NO];
}

Referenced by initFromDictionary:withAtmosphere:andSeed:forSystem:.

Here is the caller graph for this function:

◆ setUpPlanetFromTexture:

- (BOOL) setUpPlanetFromTexture: (NSString *) fileName

Definition at line 289 of file OOPlanetEntity.m.

                               :(NSString *)textureName
{
    [self setTextureFileName:textureName];
    return YES;
}

Referenced by OOPlanetEntity(OOJavaScriptExtensions)::getJSClass:andPrototype:, and initFromDictionary:withAtmosphere:andSeed:forSystem:.

Here is the caller graph for this function:

◆ setUpTerrainParametersWithSourceInfo:targetInfo:

- (void) setUpTerrainParametersWithSourceInfo:	(NSDictionary *)	sourceInfo
targetInfo:	(NSMutableDictionary *)	targetInfo

implementation

Provided by category OOPlanetEntity(Private).

Definition at line 289 of file OOPlanetEntity.m.

                                             :(NSDictionary *)sourceInfo targetInfo:(NSMutableDictionary *)targetInfo
{
    NSArray *keys = [NSArray arrayWithObjects:@"atmosphere_rotational_velocity",@"rotational_velocity",@"cloud_alpha",@"has_atmosphere",@"percent_cloud",@"percent_ice",@"percent_land",@"radius",@"seed",nil];
    NSString *key = nil;
    foreach (key, keys) {
        id sval = [sourceInfo objectForKey:key];
        if (sval != nil) {
            [targetInfo setObject:sval forKey:key];
        }
    }
 
}

Referenced by initFromDictionary:withAtmosphere:andSeed:forSystem:.

Here is the caller graph for this function:

◆ setUpTypeParametersWithSourceInfo:targetInfo:

- (void) setUpTypeParametersWithSourceInfo:	(NSDictionary *)	sourceInfo
targetInfo:	(NSMutableDictionary *)	targetInfo

implementation

Provided by category OOPlanetEntity(Private).

Definition at line 289 of file OOPlanetEntity.m.

                                          :(NSDictionary *)sourceInfo targetInfo:(NSMutableDictionary *)targetInfo
{
    [targetInfo oo_setBool:[sourceInfo oo_boolForKey:@"mainForLocalSystem"] forKey:@"mainForLocalSystem"];
    [targetInfo oo_setBool:[sourceInfo oo_boolForKey:@"isMiniature"] forKey:@"isMiniature"];
 
}

Referenced by initFromDictionary:withAtmosphere:andSeed:forSystem:.

Here is the caller graph for this function:

◆ terminatorThresholdVector

- (Vector) terminatorThresholdVector

Definition at line 289 of file OOPlanetEntity.m.

{
    return _terminatorThresholdVector;
}

◆ textureFileName

- (NSString *) textureFileName

Definition at line 289 of file OOPlanetEntity.m.

{
    return [_planetDrawable textureName];
}

◆ update:

- (void) update: (OOTimeDelta) delta_t

implementation

Reimplemented from Entity.

Definition at line 289 of file OOPlanetEntity.m.

               :(OOTimeDelta) delta_t
{
    [super update:delta_t];
    
    if (EXPECT(!_miniature))
    {
        BOOL canDrawShaderAtmosphere = _atmosphereShaderDrawable && [UNIVERSE detailLevel] >= DETAIL_LEVEL_SHADERS;
        if (EXPECT_NOT(_atmosphereDrawable && cam_zero_distance < _mesopause2))
        {
            NSAssert(_airColor != nil, @"Expected a non-nil air colour for normal planet. Exiting.");
            double      alt = (sqrt(cam_zero_distance) - collision_radius) / kMesosphere; // the viewpoint altitude
            double      trueAlt = (sqrt(zero_distance) - collision_radius) / kMesosphere; // the actual ship altitude
            // if at long distance external view, rotating the camera could potentially end up with it being
            // at negative altitude. Since we know we are already inside the atmosphere at this point, just make sure
            // that altitude is kept to a minimum positive value to avoid sudden black skies
            if (alt <= 0.0)  alt = 1e-4;
            if (EXPECT_NOT(alt > 0 && alt <= 1.0))  // ensure aleph is clamped between 0 and 1
            {
                double  aleph = 1.0 - alt;
                double  aleph2 = aleph * aleph;
                
                // night sky, reddish flash on entering the atmosphere, low light pollution otherwhise
                OOColor *mixColor = [OOColor colorWithRed:(EXPECT_NOT(alt > 0.98) ? 30.0f : 0.1f)
                                                    green:0.1f
                                                     blue:0.1f
                                                    alpha:aleph];
                                                              
                // occlusion rate: .9 is 18 degrees after the terminus, where twilight ends.
                // 1 is the terminus, 1.033 is 6 degrees before the terminus, where the sky begins to redden
                double rate = ([PLAYER occlusionLevel] - 0.97)/0.06; // from 0.97 to 1.03
 
                if (EXPECT(rate <= 1.0 && rate > 0.0))
                {
                    mixColor = [mixColor blendedColorWithFraction:rate ofColor:_airColor];
                    // TODO: properly calculated pink sky - needs to depend on sun's angular size,
                    // and its angular height on the horizon.
                    /*
                    rate -= 0.7;
                    if (rate >= 0.0) // pink sky!
                    {
                        rate = 0.5 - (fabs(rate - 0.15) / 0.3); // at most a 50% blend!
                        mixColor = [mixColor blendedColorWithFraction:rate ofColor:[OOColor colorWithRed:0.6
                                                                                                   green:0.1
                                                                                                    blue:0.0
                                                                                                   alpha:aleph]];
                    }
                    */
                }
                else
                {
                    if (PLAYER->isSunlit && _airColor != nil) mixColor = _airColor;
                }
                [UNIVERSE setSkyColorRed:[mixColor redComponent] * aleph2
                                   green:[mixColor greenComponent] * aleph2
                                    blue:[mixColor blueComponent] * aleph
                                   alpha:aleph];
                double atmosphereRadius = canDrawShaderAtmosphere ? collision_radius : collision_radius + (ATMOSPHERE_DEPTH * alt);
                [_atmosphereDrawable setRadius:atmosphereRadius];
                if (_cloudsShaderDrawable) [_cloudsShaderDrawable setRadius: atmosphereRadius];
                if (_atmosphereShaderDrawable)  [_atmosphereShaderDrawable setRadius:collision_radius + (ATMOSPHERE_DEPTH * alt)];
                // apply air resistance for the ship, not the camera. Although setSkyColorRed
                // has already set the air resistance to aleph, override it immediately
                [UNIVERSE setAirResistanceFactor:OOClamp_0_1_f(1.0 - trueAlt)];
            }
        }
        else
        {
            if (EXPECT_NOT([_atmosphereDrawable radius] < collision_radius + ATMOSPHERE_DEPTH))
            {
                [_atmosphereDrawable setRadius:collision_radius + ATMOSPHERE_DEPTH];
                if (_cloudsShaderDrawable) [_cloudsShaderDrawable setRadius: collision_radius * ATMOSPHERE_DEPTH];
                if (_atmosphereShaderDrawable)  [_atmosphereShaderDrawable setRadius:collision_radius + ATMOSPHERE_DEPTH];
            }
            if (canDrawShaderAtmosphere && [_atmosphereDrawable radius] != collision_radius)
            {
                // if shader atmo is in use, force texture atmo radius to just collision_radius for cosmetic purposes
                [_atmosphereDrawable setRadius:collision_radius];
                if (_cloudsShaderDrawable) [_cloudsShaderDrawable setRadius: collision_radius];
            }
            if ([PLAYER findNearestPlanet] == self) // ensure no problems in case of more than one planets
            {
                [UNIVERSE setAirResistanceFactor:0.0f]; // out of atmosphere - no air friction
            }
        }
        
        double time = [UNIVERSE getTime];
        
        if (_shuttlesOnGround > 0 && time > _lastLaunchTime + _shuttleLaunchInterval)  [self launchShuttle];
    }
    
    quaternion_rotate_about_axis(&orientation, _rotationAxis, _rotationalVelocity * delta_t);
    // atmosphere orientation is relative to the orientation of the planet
    quaternion_rotate_about_axis(&_atmosphereOrientation, kBasisYVector, _atmosphereRotationalVelocity * delta_t);
 
    [self orientationChanged];
    
    // FIXME: update atmosphere rotation
}

◆ welcomeShuttle:

- (void) welcomeShuttle: (ShipEntity *) shuttle

Definition at line 289 of file OOPlanetEntity.m.

                       :(ShipEntity *)shuttle
{
    _shuttlesOnGround++;
}

Member Data Documentation

◆ _airColor

- (OOColor*) _airColor

private

Definition at line 49 of file OOPlanetEntity.h.

◆ _airColorMixRatio

- (float) _airColorMixRatio

private

Definition at line 51 of file OOPlanetEntity.h.

◆ _airDensity

- (float) _airDensity

private

Definition at line 52 of file OOPlanetEntity.h.

◆ _atmosphereDrawable

- (OOPlanetDrawable*) _atmosphereDrawable

private

Definition at line 44 of file OOPlanetEntity.h.

◆ _atmosphereOrientation

- (Quaternion) _atmosphereOrientation

private

Definition at line 57 of file OOPlanetEntity.h.

◆ _atmosphereRotationalVelocity

- (float) _atmosphereRotationalVelocity

private

Definition at line 58 of file OOPlanetEntity.h.

◆ _atmosphereShaderDrawable

- (OOPlanetDrawable*) _atmosphereShaderDrawable

private

Definition at line 46 of file OOPlanetEntity.h.

◆ _cloudsShaderDrawable

- (OOPlanetDrawable*) _cloudsShaderDrawable

private

Definition at line 45 of file OOPlanetEntity.h.

◆ _illuminationColor

- (OOColor*) _illuminationColor

private

Definition at line 50 of file OOPlanetEntity.h.

◆ _lastLaunchTime

- (OOTimeDelta) _lastLaunchTime

private

Definition at line 63 of file OOPlanetEntity.h.

◆ _materialParameters

- (NSDictionary*) _materialParameters

private

Definition at line 66 of file OOPlanetEntity.h.

Referenced by initFromDictionary:withAtmosphere:andSeed:forSystem:.

◆ _mesopause2

- (double) _mesopause2

private

Definition at line 53 of file OOPlanetEntity.h.

◆ _miniature

- (BOOL) _miniature

private

Definition at line 48 of file OOPlanetEntity.h.

◆ _name

- (NSString*) _name

private

Definition at line 70 of file OOPlanetEntity.h.

◆ _normSpecMapName

- (NSString*) _normSpecMapName

private

Definition at line 68 of file OOPlanetEntity.h.

◆ _planetDrawable

- (OOPlanetDrawable*) _planetDrawable

private

Definition at line 43 of file OOPlanetEntity.h.

Referenced by initFromDictionary:withAtmosphere:andSeed:forSystem:.

◆ _rotationalVelocity

- (float) _rotationalVelocity

private

Definition at line 56 of file OOPlanetEntity.h.

◆ _rotationAxis

- (Vector) _rotationAxis

private

Definition at line 55 of file OOPlanetEntity.h.

◆ _shuttleLaunchInterval

- (OOTimeDelta) _shuttleLaunchInterval

private

Definition at line 64 of file OOPlanetEntity.h.

◆ _shuttlesOnGround

- (unsigned) _shuttlesOnGround

private

Definition at line 62 of file OOPlanetEntity.h.

◆ _terminatorThresholdVector

- (Vector) _terminatorThresholdVector

private

Definition at line 60 of file OOPlanetEntity.h.

◆ _textureName

- (NSString*) _textureName

private

Definition at line 67 of file OOPlanetEntity.h.

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

src/Core/Entities/OOPlanetEntity.h
src/Core/Entities/OOPlanetEntity.m

Instance Methods

Class Methods

Private Attributes

Additional Inherited Members

Detailed Description

Method Documentation

◆ airColor

◆ airColorAsVector

◆ airColorMixRatio

◆ airDensity

◆ atmosphereMaterial

◆ atmosphereShaderMaterial

◆ checkCloseCollisionWith:

◆ ColorWithHSBColor

◆ dealloc

◆ descriptionComponents

◆ drawImmediate:translucent:

◆ getJSClass:andPrototype:

◆ hasAtmosphere

◆ HSBColorWithColor

◆ illuminationColor

◆ illuminationColorAsVector

◆ initAsMainPlanetForSystem:

◆ initAsMiniatureVersionOfPlanet:

◆ initFromDictionary:withAtmosphere:andSeed:forSystem:

◆ isFinishedLoading

◆ isPlanet

◆ isVisible

◆ isVisibleToScripts

◆ launchShuttle

◆ LighterHSBColor

◆ material

◆ miniatureVersion

◆ name

◆ oo_jsClassName

◆ planetHasStation

◆ planetType

◆ radius

◆ RandomHSBColor(void)

◆ resetGraphicsState

◆ rotationalVelocity

◆ setAirColor:

◆ setAirColorMixRatio:

◆ setAirDensity:

◆ setIlluminationColor:

◆ setName:

◆ setOrientation:

◆ setRotationalVelocity:

◆ setTerminatorThresholdVector:

◆ setTextureFileName:

◆ setUpAtmosphereParametersWithSourceInfo:targetInfo:

◆ setUpColorParametersWithSourceInfo:targetInfo:isAtmosphere:

◆ setUpLandParametersWithSourceInfo:targetInfo:

◆ setUpPlanetFromTexture:

◆ setUpTerrainParametersWithSourceInfo:targetInfo:

◆ setUpTypeParametersWithSourceInfo:targetInfo:

◆ terminatorThresholdVector

◆ textureFileName

◆ update:

◆ welcomeShuttle:

Member Data Documentation

◆ _airColor

◆ _airColorMixRatio

◆ _airDensity

◆ _atmosphereDrawable

◆ _atmosphereOrientation

◆ _atmosphereRotationalVelocity

◆ _atmosphereShaderDrawable

◆ _cloudsShaderDrawable

◆ _illuminationColor

◆ _lastLaunchTime

◆ _materialParameters

◆ _mesopause2

◆ _miniature

◆ _name

◆ _normSpecMapName

◆ _planetDrawable

◆ _rotationalVelocity

◆ _rotationAxis

◆ _shuttleLaunchInterval