PlanetEntity Class Reference

#include <PlanetEntity.h>

Inheritance diagram for PlanetEntity:

Collaboration diagram for PlanetEntity:

Instance Methods
(id)	- initFromDictionary:withAtmosphere:andSeed:
(void)	- miniaturize
(BOOL)	- setUpPlanetFromTexture:
(int)	- planet_seed
(BOOL)	- isTextured
(BOOL)	- isExplicitlyTextured
(OOTexture *)	- texture
(NSString *)	- textureFileName
(double)	- polar_color_factor
(GLfloat *)	- amb_land
(GLfloat *)	- amb_polar_land
(GLfloat *)	- amb_sea
(GLfloat *)	- amb_polar_sea
(OOStellarBodyType)	- planetType
(void)	- setPlanetType:
(double)	- radius
(void)	- setRadius:
(double)	- rotationalVelocity
(void)	- setRotationalVelocity:
(BOOL)	- hasAtmosphere
(void)	- launchShuttle
(void)	- welcomeShuttle:
(void)	- drawUnconditionally
(PlanetEntity *)	- atmosphere
(id)	- init [implementation]
(id)	- initAsAtmosphereForPlanet:dictionary: [implementation]
(void)	- dealloc [implementation]
(NSString *)	- descriptionComponents [implementation]
(BOOL)	- canCollide [implementation]
(BOOL)	- checkCloseCollisionWith: [implementation]
(void)	- update: [implementation]
(void)	- setPosition: [implementation]
(void)	- setOrientation: [implementation]
(void)	- setUseTexturedModel: [implementation]
(void)	- drawImmediate:translucent: [implementation]
(void)	- setTextureColorForPlanet:inSystem: [implementation]
(double)	- sqrtZeroDistance [implementation]
(void)	- drawModelWithVertexArraysAndSubdivision: [implementation]
(void)	- initialiseBaseVertexArray [implementation]
(void)	- initialiseBaseTerrainArray: [implementation]
(void)	- paintVertex:vi: [implementation]
(void)	- scaleVertices [implementation]
(void)	- deleteDisplayLists [implementation]
(void)	- resetGraphicsState [implementation]
(void)	- loadTexture: [implementation]
(OOTexture *)	- planetTextureWithInfo: [implementation]
(OOTexture *)	- cloudTextureWithCloudColor:cloudImpress:cloudBias: [implementation]
(NSSet *)	- allTextures [implementation]
(BOOL)	- isPlanet [implementation]
(BOOL)	- isVisible [implementation]
(id)	- initMiniatureFromPlanet:withAlpha: [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)	- 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
(GLfloat)	- collisionRadius
(GLfloat)	- frustumRadius
(void)	- setCollisionRadius:
(NSMutableArray *)	- collisionArray
(void)	- applyVelocity:
(void)	- takeEnergyDamage:from:becauseOf:weaponIdentifier:
(void)	- dumpState
(void)	- dumpSelfState
(double)	- findCollisionRadius
(BOOL)	- isInSpace
(BOOL)	- isImmuneToBreakPatternHide
(GLfloat)	- universalTime
(GLfloat)	- spawnTime
(GLfloat)	- timeElapsedSinceSpawn
(void)	- setAtmosphereFogging:
(OOColor *)	- fogUniform
(NSString *)	- descriptionForObjDumpBasic
(NSString *)	- descriptionForObjDump
(BOOL)	- checkLinkedLists [implementation]
(id< OOWeakReferenceSupport >)	- superShaderBindingTarget [implementation]
(Vector)	- relativePosition [implementation]
(void)	- subEntityReallyDied: [implementation]
(BOOL)	- isBreakPattern
(void)	- inspect [implementation]
(BOOL)	- isECMBlast
(NSArray *)	- debugInspectorModules [implementation]
(NSString *)	- inspScanClassLine
(NSString *)	- inspStatusLine
(NSString *)	- inspRetainCountLine
(NSString *)	- inspPositionLine
(NSString *)	- inspVelocityLine
(NSString *)	- inspOrientationLine
(NSString *)	- inspEnergyLine
(NSString *)	- inspOwnerLine
(NSString *)	- inspTargetLine
(NSString *)	- inspDescription [implementation]
(NSString *)	- inspBasicIdentityLine [implementation]
(BOOL)	- isExhaust
(BOOL)	- isFlasher
(BOOL)	- isVisibleToScripts
(NSString *)	- oo_jsClassName
(void)	- getJSClass:andPrototype:
(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
Instance Methods inherited from <OOStellarBody>
(NSString *)	- name
(void)	- setName:

Class Methods
(static unsigned)	+ baseVertexIndexForEdge [implementation]

Private Attributes
OOStellarBodyType	planet_type
uint8_t	lastSubdivideLevel
BOOL	useTexturedModel
BOOL	isTextureImage
NSString *	_textureFileName
OOTexture *	_texture
int	planet_seed
double	polar_color_factor
double	rotational_velocity
GLfloat	amb_land [4]
GLfloat	amb_polar_land [4]
GLfloat	amb_sea [4]
GLfloat	amb_polar_sea [4]
PlanetEntity *	atmosphere
PlanetEntity *	root_planet
int	shuttles_on_ground
double	last_launch_time
double	shuttle_launch_interval
double	sqrt_zero_distance
GLuint	displayListNames [MAX_SUBDIVIDE]
GLuint	vertexCount
VertexData	vertexdata
Vector	rotationAxis

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
Protected Attributes inherited from OOWeakRefObject
OOWeakReference *	weakSelf

Detailed Description

Definition at line 55 of file PlanetEntity.h.

Method Documentation

allTextures

- (NSSet *) allTextures

implementation

Reimplemented from Entity.

Definition at line 1612 of file PlanetEntity.m.

{
    if (_texture != nil)  return [NSSet setWithObject:_texture];
    else  return nil;
}

References _texture, allTextures, and nil.

Referenced by allTextures.

Here is the call graph for this function:

Here is the caller graph for this function:

amb_land

- (GLfloat *) amb_land

References amb_polar_land.

amb_polar_land

- (GLfloat *) amb_polar_land

References amb_sea.

amb_polar_sea

- (GLfloat *) amb_polar_sea

References atmosphere, drawUnconditionally, hasAtmosphere, launchShuttle, PlanetEntity, planetType, radius, and rotationalVelocity.

Here is the call graph for this function:

amb_sea

- (GLfloat *) amb_sea

References amb_polar_sea.

atmosphere

- (PlanetEntity *) atmosphere

baseVertexIndexForEdge

+ (static unsigned) baseVertexIndexForEdge (GLushort) va (GLushort) vb (BOOL) textured

implementation

Definition at line 1317 of file PlanetEntity.m.

{
    if (va < vb)
    {
        GLushort temp = va;
        va = vb;
        vb = temp;
    }
    void *key = (void *)(((uintptr_t)va << 16) | vb);
    uintptr_t num = (uintptr_t)NSMapGet(sEdgeToVertex, key);
    if (num != 0)
    {
        // Overall cache hit rate is just over 83 %.
        return (unsigned)num - 1;
    }
    else
    {
        unsigned vindex = next_free_vertex++;
        NSCAssert(vindex < sizeof base_vertex_array / sizeof *base_vertex_array, @"Vertex array overflow in planet setup.");
        
        // calculate position of new vertex
        Vector pos = vector_add(base_vertex_array[va], base_vertex_array[vb]);
        pos = vector_normal(pos);   // guaranteed non-zero
        base_vertex_array[vindex] = pos;
        
        if (textured)
        {
            //calculate new texture coordinates
            NSPoint uva = (NSPoint){ texture_uv_array[va * 2], texture_uv_array[va * 2 + 1] };
            NSPoint uvb = (NSPoint){ texture_uv_array[vb * 2], texture_uv_array[vb * 2 + 1] };
            
            // if either of these is the polar vertex treat it specially to help with polar distortion:
            if (uva.y == 0.0 || uva.y == 1.0)  uva.x = uvb.x;
            if (uvb.y == 0.0 || uvb.y == 1.0)  uvb.x = uva.x;
            
            texture_uv_array[vindex * 2] = 0.5 * (uva.x + uvb.x);
            texture_uv_array[vindex * 2 + 1] = 0.5 * (uva.y + uvb.y);
        }
        
        // add new edge to the look-up
        num = vindex + 1;
        NSMapInsertKnownAbsent(sEdgeToVertex, key, (void *)num);
        return vindex;
    }
}

References base_vertex_array, next_free_vertex, sEdgeToVertex, and texture_uv_array.

canCollide

- (BOOL) canCollide

implementation

Reimplemented from Entity.

Definition at line 615 of file PlanetEntity.m.

{
    switch (planet_type)
    {
        case STELLAR_TYPE_MINIATURE:
        case STELLAR_TYPE_ATMOSPHERE:
            return NO;
            break;
        case STELLAR_TYPE_MOON:
        case STELLAR_TYPE_NORMAL_PLANET:
        case STELLAR_TYPE_SUN:
            return YES;
            break;
    }
    return YES;
}

References canCollide, planet_type, STELLAR_TYPE_ATMOSPHERE, STELLAR_TYPE_MINIATURE, STELLAR_TYPE_MOON, STELLAR_TYPE_NORMAL_PLANET, and STELLAR_TYPE_SUN.

Referenced by canCollide.

Here is the call graph for this function:

Here is the caller graph for this function:

checkCloseCollisionWith:

- (BOOL) checkCloseCollisionWith: (Entity *) other

implementation

Reimplemented from Entity.

Definition at line 633 of file PlanetEntity.m.

                                :(Entity *)other
{
#ifndef NDEBUG
    if (gDebugFlags & DEBUG_COLLISIONS)
        OOLog(@"planet.collide", @"PLANET Collision!");
#endif
    
    if (!other)
        return NO;
    if (other->isShip)
    {
        ShipEntity *ship = (ShipEntity *)other;
        if ([ship behaviour] == BEHAVIOUR_LAND_ON_PLANET)
        {
            return NO;
        }
#ifndef NDEBUG
        if ([ship reportAIMessages])
        {
            HPVector p1 = ship->position;
            OOLog(@"planet.collide.shipHit", @"DEBUG: %@ %d collided with planet at (%.1f,%.1f,%.1f)",[ship name], [ship universalID], p1.x,p1.y,p1.z);
        }
#endif
    }
 
    return YES;
}

References DEBUG_COLLISIONS, gDebugFlags, Entity::isShip, <OOStellarBody>::name, OOLog, Entity::position, and Entity::universalID.

Here is the call graph for this function:

cloudTextureWithCloudColor:cloudImpress:cloudBias:

- (OOTexture *) cloudTextureWithCloudColor: (OOColor *) cloudColor cloudImpress: (GLfloat) cloud_impress cloudBias: (GLfloat) cloud_bias

implementation

Provided by category PlanetEntity(OOPrivate).

Definition at line 1585 of file PlanetEntity.m.

                                          :(OOColor *)cloudColor cloudImpress:(GLfloat)cloud_impress cloudBias:(GLfloat)cloud_bias
{
    unsigned char *data;
    GLuint width, height;
    
    fillRanNoiseBuffer();
    if (![TextureStore getCloudTextureNameFor:cloudColor
                                             :cloud_impress
                                             :cloud_bias
                                     intoData:&data
                                        width:&width
                                       height:&height])
    {
        return nil;
    }
    
    OOPixMap pm = OOMakePixMap(data, width, height, kOOPixMapRGBA, 0, 0);
    OOTextureGenerator *loader = [[OOPixMapTextureLoader alloc] initWithPixMap:pm
                                                                textureOptions:kOOTextureDefaultOptions | kOOTextureRepeatS
                                                                  freeWhenDone:YES];
    [loader autorelease];
    
    return [OOTexture textureWithGenerator:loader];
}

References fillRanNoiseBuffer(), kOOPixMapRGBA, nil, OOMakePixMap(), and OOTexture::textureWithGenerator:.

Referenced by PlanetEntity(OOPrivate)::initAsAtmosphereForPlanet:dictionary:.

Here is the call graph for this function:

Here is the caller graph for this function:

dealloc

- (void) dealloc

implementation

Reimplemented from Entity.

Definition at line 580 of file PlanetEntity.m.

{
    [self deleteDisplayLists];
    
    DESTROY(atmosphere);
    DESTROY(_texture);
    DESTROY(_textureFileName);
    
    [[OOGraphicsResetManager sharedManager] unregisterClient:self];
    
    [super dealloc];
}

References _texture, _textureFileName, atmosphere, Entity::dealloc, dealloc, deleteDisplayLists, DESTROY, OOGraphicsResetManager::sharedManager, and OOGraphicsResetManager::unregisterClient:.

Referenced by dealloc.

Here is the call graph for this function:

Here is the caller graph for this function:

deleteDisplayLists

- (void) deleteDisplayLists

implementation

Provided by category PlanetEntity(OOPrivate).

Definition at line 1503 of file PlanetEntity.m.

{
    unsigned i;
    for (i = 0; i < MAX_SUBDIVIDE; i++)
    {
        if (displayListNames[i] != 0)
        {
            glDeleteLists(displayListNames[i], 1);
            displayListNames[i] = 0;
        }
    }
}

References PlanetEntity(OOPrivate)::deleteDisplayLists, and MAX_SUBDIVIDE.

Referenced by dealloc, PlanetEntity(OOPrivate)::deleteDisplayLists, PlanetEntity(OOPrivate)::initMiniatureFromPlanet:withAlpha:, resetGraphicsState, and setUpPlanetFromTexture:.

Here is the call graph for this function:

Here is the caller graph for this function:

descriptionComponents

- (NSString *) descriptionComponents

implementation

Reimplemented from Entity.

Definition at line 594 of file PlanetEntity.m.

{
    NSString *typeString;
    switch (planet_type)
    {
        case STELLAR_TYPE_MINIATURE:
            typeString = @"STELLAR_TYPE_MINIATURE"; break;
        case STELLAR_TYPE_NORMAL_PLANET:
            typeString = @"STELLAR_TYPE_NORMAL_PLANET"; break;
        case STELLAR_TYPE_ATMOSPHERE:
            typeString = @"STELLAR_TYPE_ATMOSPHERE";    break;
        case STELLAR_TYPE_MOON:
            typeString = @"STELLAR_TYPE_MOON";  break;
        
        default:
            typeString = @"UNKNOWN";
    }
    return [NSString stringWithFormat:@"ID: %u position: %@ type: %@ radius: %.3fkm", [self universalID], HPVectorDescription([self position]), typeString, 0.001 * [self radius]];
}

References descriptionComponents, planet_type, Entity::position, radius, STELLAR_TYPE_ATMOSPHERE, STELLAR_TYPE_MINIATURE, STELLAR_TYPE_MOON, STELLAR_TYPE_NORMAL_PLANET, and Entity::universalID.

Referenced by descriptionComponents.

Here is the call graph for this function:

Here is the caller graph for this function:

drawImmediate:translucent:

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

implementation

Reimplemented from Entity.

Definition at line 763 of file PlanetEntity.m.

                      :(bool)immediate translucent:(bool)translucent
{
    if ([UNIVERSE breakPatternHide] || translucent || immediate)  return;  // DON'T DRAW
    GLfloat radWithAtmosphere = [self radius] + ATMOSPHERE_DEPTH;
    if (radWithAtmosphere * radWithAtmosphere * 1.1 < cam_zero_distance)
    {
        // for some reason this check doesn't work when extremely close to
        // the planet and with the horizon near the side of the frame (FP
        // inaccuracy?)
        if (![UNIVERSE viewFrustumIntersectsSphereAt:cameraRelativePosition withRadius:radWithAtmosphere])
        {
            // Don't draw
            return;
        }
    }
 
    [self drawUnconditionally];
}

References ATMOSPHERE_DEPTH, Entity::cam_zero_distance, Entity::cameraRelativePosition, drawUnconditionally, radius, and UNIVERSE.

Referenced by drawUnconditionally.

Here is the call graph for this function:

Here is the caller graph for this function:

drawModelWithVertexArraysAndSubdivision:

- (void) drawModelWithVertexArraysAndSubdivision: (int) subdivide

implementation

Provided by category PlanetEntity(OOPrivate).

Definition at line 1163 of file PlanetEntity.m.

                                                : (int) subdivide
{
    OOGL(glDrawElements(GL_TRIANGLES, 3 * n_triangles[subdivide], GL_UNSIGNED_INT, &vertexdata.index_array[triangle_start[subdivide]]));
}

References n_triangles, OOGL, and triangle_start.

Referenced by drawUnconditionally.

Here is the caller graph for this function:

drawUnconditionally

- (void) drawUnconditionally

Definition at line 783 of file PlanetEntity.m.

{
    uint8_t subdivideLevel =    2;      // 4 is probably the maximum!
    
    double  drawFactor = [[UNIVERSE gameView] viewSize].width / 100.0;
    double  drawRatio2 = drawFactor * collision_radius / sqrt_zero_distance; // equivalent to size on screen in pixels
    
    if (cam_zero_distance > 0.0)
    {
        subdivideLevel = 2 + floor(drawRatio2);
        if (subdivideLevel > 4)  subdivideLevel = 4;
    }
    
    if (planet_type == STELLAR_TYPE_MINIATURE)
    {
        subdivideLevel = [UNIVERSE reducedDetail]? 3 : 4;       // max detail or less
    }
        
    lastSubdivideLevel = subdivideLevel;  // record
    
    OOSetOpenGLState(OPENGL_STATE_OPAQUE);
    OOGL(glPushAttrib(GL_ENABLE_BIT));
    
//  OOGL(glEnable(GL_LIGHTING));
//  OOGL(glEnable(GL_LIGHT1));
    GLfloat specular[4] = { 0.0f, 0.0f, 0.0f, 0.0f };
    OOGL(glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, specular));
    OOGL(glMateriali(GL_FRONT_AND_BACK, GL_SHININESS, 0));
    
    /*
 
    The depth test gets disabled in parts of this and instead
    we rely on the painters algorithm instead.
 
    The depth buffer isn't granular enough to cope with huge objects at vast
    distances.
 
    */
    
    BOOL ignoreDepthBuffer = (planet_type == STELLAR_TYPE_ATMOSPHERE);
    
    if (cam_zero_distance > collision_radius * collision_radius * 25) // is 'far away'
    {
        ignoreDepthBuffer |= YES;
    }
    
    [_texture ensureFinishedLoading];
    
    switch (planet_type)
    {
        case STELLAR_TYPE_ATMOSPHERE:
            if (root_planet)
            {
                subdivideLevel = root_planet->lastSubdivideLevel;  // copy it from the planet (stops jerky LOD and such)
            }
            OOGLMultModelVew(rotMatrix);    // rotate the clouds!
            OOGL(glEnable(GL_BLEND));
//          OOGL(glDisable(GL_LIGHTING));
            // Fall through.
 
        case STELLAR_TYPE_MOON:
        case STELLAR_TYPE_NORMAL_PLANET:
        case STELLAR_TYPE_MINIATURE:
            //if ((gDebugFlags & DEBUG_WIREFRAME_GRAPHICS)
            if ([UNIVERSE wireframeGraphics])
            {
                // Drop the detail level a bit, it still looks OK in wireframe and does not penalize
                // the system that much.
                subdivideLevel = 2;
                OOGLWireframeModeOn();
            }
            
            {
                GLfloat mat1[]      = { 1.0, 1.0, 1.0, 1.0 };   // opaque white
                
                if (_texture != nil)
                {
                    if ([_texture isCubeMap])
                    {
#if OO_TEXTURE_CUBE_MAP
                        OOGL(glDisable(GL_TEXTURE_2D));
                        OOGL(glEnable(GL_TEXTURE_CUBE_MAP));
#endif
                    }
                    else
                    {
//                      OOGL(glEnable(GL_TEXTURE_2D));
                    }
                    OOGL(glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, mat1));
                    [_texture apply];
                }
                else
                {
                    OOGL(glDisable(GL_TEXTURE_2D));
                    [OOTexture applyNone];
                }
 
                OOGL(glShadeModel(GL_SMOOTH));
                
                // far enough away to draw flat ?
                if (ignoreDepthBuffer)
                {
                    OOGL(glDisable(GL_DEPTH_TEST));
                }
 
                OOGL(glColor4fv(mat1));
                OOGL(glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, mat1));
                
                OOGL(glEnableClientState(GL_COLOR_ARRAY));
                OOGL(glColorPointer(4, GL_FLOAT, 0, vertexdata.color_array));
//              OOGL(glEnableClientState(GL_VERTEX_ARRAY));
                OOGL(glVertexPointer(3, GL_FLOAT, 0, vertexdata.vertex_array));
//              OOGL(glEnableClientState(GL_NORMAL_ARRAY));
                OOGL(glNormalPointer(GL_FLOAT, 0, vertexdata.normal_array));
                
                if (_texture != nil)
                {
                    OOGL(glEnableClientState(GL_TEXTURE_COORD_ARRAY));
                    if ([_texture isCubeMap])
                    {
                        OOGL(glTexCoordPointer(3, GL_FLOAT, 0, vertexdata.vertex_array));
                    }
                    else
                    {
                        OOGL(glTexCoordPointer(2, GL_FLOAT, 0, vertexdata.uv_array));
                    }
                }
                else
                {
                    OOGL(glDisableClientState(GL_TEXTURE_COORD_ARRAY));
                }
                
                if (displayListNames[subdivideLevel] != 0)
                {
                    OOGL(glCallList(displayListNames[subdivideLevel]));
                }
                else
                {
                    
                    OOGL(displayListNames[subdivideLevel] = glGenLists(1));
                    if (displayListNames[subdivideLevel] != 0)  // sanity check
                    {
                        OOGL(glNewList(displayListNames[subdivideLevel], GL_COMPILE_AND_EXECUTE));
                        
                        OOGL(glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE));
                        OOGL(glEnable(GL_COLOR_MATERIAL));
                        
                        [self drawModelWithVertexArraysAndSubdivision:subdivideLevel];
                        
                        OOGL(glDisable(GL_COLOR_MATERIAL));
                        OOGL(glEndList());
                    }
                }
 
#if OO_TEXTURE_CUBE_MAP
                if ([_texture isCubeMap])
                {
                    OOGL(glDisable(GL_TEXTURE_CUBE_MAP));
                    OOGL(glEnable(GL_TEXTURE_2D));
                }
#endif
 
            OOGL(glDisableClientState(GL_COLOR_ARRAY));
            OOGL(glDisableClientState(GL_TEXTURE_COORD_ARRAY));
            OOGL(glEnable(GL_DEPTH_TEST));
 
            }
            
            //if ((gDebugFlags & DEBUG_WIREFRAME_GRAPHICS)
            if ([UNIVERSE wireframeGraphics])
            {
                OOGLWireframeModeOff();
            }
//          OOGL(glDisableClientState(GL_VERTEX_ARRAY));
//          OOGL(glDisableClientState(GL_NORMAL_ARRAY));
            
            break;
            
        case STELLAR_TYPE_SUN:
            break;
    }
 
    if (ignoreDepthBuffer)
    {
        OOGL(glEnable(GL_DEPTH_TEST));
    }
    OOGL(glEnable(GL_TEXTURE_2D));
//  OOGL(glEnable(GL_LIGHTING));
    OOGL(glDisable(GL_BLEND));
 
 
    OOGL(glPopAttrib());
    OOVerifyOpenGLState();
    OOCheckOpenGLErrors(@"PlanetEntity after drawing %@", self);
 
    if (atmosphere)
    {
        OOGLPopModelView(); // get old draw matrix back
        OOGLPushModelView();   // and store it again
        OOGLTranslateModelView(cameraRelativePosition); // centre on the planet
        // rotate
//      OOGLMultModelView([atmosphere rotationMatrix]);
        // draw atmosphere entity
        [atmosphere drawImmediate:false translucent:false];
    }
 
 
}

References _texture, OOTexture::apply, OOTexture::applyNone, atmosphere, Entity::cam_zero_distance, Entity::cameraRelativePosition, Entity::collision_radius, displayListNames, drawImmediate:translucent:, drawModelWithVertexArraysAndSubdivision:, drawUnconditionally, OOTexture::ensureFinishedLoading, lastSubdivideLevel, nil, OOCheckOpenGLErrors(), OOGL, OOGLPopModelView(), OOGLPushModelView(), OOGLTranslateModelView(), OOGLWireframeModeOff(), OOGLWireframeModeOn(), OOSetOpenGLState, OOVerifyOpenGLState, OPENGL_STATE_OPAQUE, planet_type, root_planet, Entity::rotMatrix, sqrt_zero_distance, STELLAR_TYPE_ATMOSPHERE, STELLAR_TYPE_MINIATURE, STELLAR_TYPE_MOON, STELLAR_TYPE_NORMAL_PLANET, STELLAR_TYPE_SUN, UNIVERSE, and vertexdata.

Referenced by amb_polar_sea, drawImmediate:translucent:, and drawUnconditionally.

Here is the call graph for this function:

Here is the caller graph for this function:

hasAtmosphere

- (BOOL) hasAtmosphere

Definition at line 1157 of file PlanetEntity.m.

{
    return atmosphere != nil;
}

References atmosphere, hasAtmosphere, and nil.

Referenced by amb_polar_sea, hasAtmosphere, and setUpPlanetFromTexture:.

Here is the call graph for this function:

Here is the caller graph for this function:

init

- (id) init

implementation

Reimplemented from Entity.

Definition at line 192 of file PlanetEntity.m.

{
    [self release];
    [NSException raise:NSInternalInconsistencyException format:@"%s, believed dead, called.", __PRETTY_FUNCTION__];
    return nil;
}

References init, and nil.

Referenced by init.

Here is the call graph for this function:

Here is the caller graph for this function:

initAsAtmosphereForPlanet:dictionary:

- (id) initAsAtmosphereForPlanet: (PlanetEntity *) planet dictionary: (NSDictionary *) dict

implementation

Provided by category PlanetEntity(OOPrivate).

Definition at line 200 of file PlanetEntity.m.

                                :(PlanetEntity *)planet dictionary:(NSDictionary *)dict
{
    BOOL    procGen = [UNIVERSE doProcedurallyTexturedPlanets];
    
    if (dict == nil)  dict = [NSDictionary dictionary];
    
    self = [super init];
    
    int percent_land = 100 - [dict oo_intForKey:@"percent_cloud" defaultValue:100 - (3 + (gen_rnd_number() & 31)+(gen_rnd_number() & 31))];
    
    polar_color_factor = 1.0;
    
#define CLEAR_SKY_ALPHA         0.05
#define CLOUD_ALPHA             0.50
#define POLAR_CLEAR_SKY_ALPHA   0.34
#define POLAR_CLOUD_ALPHA       0.75
    
    amb_land[0] = gen_rnd_number() / 256.0;
    amb_land[1] = gen_rnd_number() / 256.0;
    amb_land[2] = gen_rnd_number() / 256.0;
    amb_land[3] = CLEAR_SKY_ALPHA;           // blue sky, zero clouds
    amb_sea[0] = 0.5 + gen_rnd_number() / 512.0;
    amb_sea[1] = 0.5 + gen_rnd_number() / 512.0;
    amb_sea[2] = 0.5 + gen_rnd_number() / 512.0;
    amb_sea[3] = CLOUD_ALPHA;                     // 50% opaque clouds
    amb_polar_land[0] = gen_rnd_number() / 256.0;
    amb_polar_land[1] = gen_rnd_number() / 256.0;
    amb_polar_land[2] = gen_rnd_number() / 256.0;
    amb_polar_land[3] = POLAR_CLEAR_SKY_ALPHA;   // 34% gray clouds
    amb_polar_sea[0] = 0.9 + gen_rnd_number() / 2560.0;
    amb_polar_sea[1] = 0.9 + gen_rnd_number() / 2560.0;
    amb_polar_sea[2] = 0.9 + gen_rnd_number() / 2560.0;
    amb_polar_sea[3] = POLAR_CLOUD_ALPHA;     // 75% clouds
    
    // Colour overrides from dictionary
    OOColor     *clearSkyColor = nil;
    OOColor     *cloudColor = nil;
    OOColor     *polarClearSkyColor = nil;
    OOColor     *polarCloudColor = nil;
    float       cloudAlpha;
    
    
    clearSkyColor = [OOColor colorWithDescription:[dict objectForKey:@"atmosphere_color"]];
    cloudColor = [OOColor colorWithDescription:[dict objectForKey:@"cloud_color"]];
    polarClearSkyColor = [OOColor colorWithDescription:[dict objectForKey:@"polar_atmosphere_color"]];
    polarCloudColor = [OOColor colorWithDescription:[dict objectForKey:@"polar_cloud_color"]];
    cloudAlpha = OOClamp_0_1_f([dict oo_floatForKey:@"cloud_alpha" defaultValue:1.0]);
    
    if (clearSkyColor != nil)
    {
        [clearSkyColor getRed:&amb_land[0] green:&amb_land[1] blue:&amb_land[2] alpha:&amb_land[3]];
    }
    
    if (cloudColor != nil)
    {
        [cloudColor getRed:&amb_sea[0] green:&amb_sea[1] blue:&amb_sea[2] alpha:&amb_sea[3]];
    }
    
    if (polarClearSkyColor != nil)
    {
        [polarClearSkyColor getRed:&amb_polar_land[0] green:&amb_polar_land[1] blue:&amb_polar_land[2] alpha:&amb_polar_land[3]];
    }
    else if (clearSkyColor != nil)
    {
        memmove(amb_polar_land, amb_land, sizeof amb_polar_land);
        amb_polar_land[3] = OOClamp_0_1_f(amb_polar_land[3] * (POLAR_CLEAR_SKY_ALPHA / CLEAR_SKY_ALPHA));
    }
    
    if (polarCloudColor != nil)
    {
        [polarCloudColor getRed:&amb_polar_sea[0] green:&amb_polar_sea[1] blue:&amb_polar_sea[2] alpha:&amb_polar_sea[3]];
    }
    else if (cloudColor != nil)
    {
        memmove(amb_polar_sea, amb_sea, sizeof amb_polar_sea);
        amb_polar_sea[3] *= (POLAR_CLOUD_ALPHA / CLOUD_ALPHA);
    }
    
    //amb_land[3] is already 0.05
    amb_sea[3] *= cloudAlpha;
    amb_polar_land[3] *= cloudAlpha;
    amb_polar_sea[3] *= cloudAlpha;
    
    amb_sea[3] = OOClamp_0_1_f(amb_sea[3]);
    amb_polar_sea[3] = OOClamp_0_1_f(amb_polar_sea[3]);
    
    atmosphere = nil;
    
    if (procGen)
    {
        RANROTSeed ranrotSavedSeed = RANROTGetFullSeed();
        RNG_Seed saved_seed = currentRandomSeed();
        cloudColor = [OOColor colorWithRed: amb_sea[0] green: amb_sea[1] blue: amb_sea[2] alpha: amb_sea[3]];
        float cloud_bias = -0.01 * (float)percent_land;
        float cloud_impress = 1.0 - cloud_bias;
        
        _texture = [self cloudTextureWithCloudColor:cloudColor cloudImpress:cloud_impress cloudBias:cloud_bias];
        [_texture retain];
        isTextureImage = NO;
        
        setRandomSeed(saved_seed);
        RANROTSetFullSeed(ranrotSavedSeed);
    }
    
    if (!planet)
    {
        OOLogERR(@"planet.atmosphere.init.noPlanet", @"planet entity initAsAtmosphereForPlanet: no planet found.");
        return self;
    }
    
    [self setOwner: planet];
    
    position = [planet position];
    orientation = [planet orientation];
    
    if (planet->planet_type == STELLAR_TYPE_NORMAL_PLANET)
        collision_radius = planet->collision_radius + ATMOSPHERE_DEPTH; //  atmosphere is 500m deep only
    if (planet->planet_type == STELLAR_TYPE_MINIATURE)
        collision_radius = planet->collision_radius + ATMOSPHERE_DEPTH * PLANET_MINIATURE_FACTOR*2.0; //not to scale: invisible otherwise
    
    shuttles_on_ground = 0;
    last_launch_time = 0.0;
    shuttle_launch_interval = 3600.0;
    
    scanClass = CLASS_NO_DRAW;
    
    // orientation.w =  M_SQRT1_2; // is already planet->orientation
    // orientation.x =  M_SQRT1_2;
    // orientation.y =  0.0;
    // orientation.z =  0.0;
    
    planet_type =   STELLAR_TYPE_ATMOSPHERE;
    
    planet_seed =    ranrot_rand();   // random set-up for vertex colours
    
    [self setUseTexturedModel:YES];
    [self initialiseBaseVertexArray];
    [self initialiseBaseTerrainArray:percent_land];
    unsigned i;
    for (i =  0; i < next_free_vertex; i++)
    {
        [self paintVertex:i :planet_seed];
    }
    
    [self scaleVertices];
 
    // set speed of rotation
    rotational_velocity = [dict oo_floatForKey:@"atmosphere_rotational_velocity" defaultValue:[planet rotationalVelocity]*(0.9+(randf()*0.2))]; // 90-110% of planet rotation speed
    
    root_planet = planet;
    
    rotationAxis = vector_up_from_quaternion(orientation);
    
    [[OOGraphicsResetManager sharedManager] registerClient:self];
    
    return self;
}

References ATMOSPHERE_DEPTH, CLEAR_SKY_ALPHA, CLOUD_ALPHA, cloudTextureWithCloudColor:cloudImpress:cloudBias:, Entity::collision_radius, OOColor::colorWithDescription:, OOColor::colorWithRed:green:blue:alpha:, currentRandomSeed(), gen_rnd_number(), OOColor::getRed:green:blue:alpha:, Entity::init, initialiseBaseTerrainArray:, initialiseBaseVertexArray, next_free_vertex, nil, OOLogERR, Entity::orientation, PLANET_MINIATURE_FACTOR, planet_type, PlanetEntity, POLAR_CLEAR_SKY_ALPHA, POLAR_CLOUD_ALPHA, Entity::position, ranrot_rand, RANROTGetFullSeed(), RANROTSetFullSeed(), OOGraphicsResetManager::registerClient:, rotationalVelocity, scaleVertices, Entity::setOwner:, setRandomSeed(), setUseTexturedModel:, OOGraphicsResetManager::sharedManager, STELLAR_TYPE_ATMOSPHERE, STELLAR_TYPE_MINIATURE, STELLAR_TYPE_NORMAL_PLANET, and vector_up_from_quaternion().

Here is the call graph for this function:

initFromDictionary:withAtmosphere:andSeed:

- (id) initFromDictionary:		(NSDictionary*)	dict
withAtmosphere:		(BOOL)	atmo
andSeed:		(Random_Seed)	p_seed

Definition at line 378 of file PlanetEntity.m.

                         :(NSDictionary*)dict withAtmosphere:(BOOL)atmo andSeed:(Random_Seed)p_seed
{
    BOOL procGen = [UNIVERSE doProcedurallyTexturedPlanets];
    
    if (dict == nil)  dict = [NSDictionary dictionary];
    RANROTSeed ranrotSavedSeed = RANROTGetFullSeed();
    
    self = [super init];
    
    planet_type =  atmo ? STELLAR_TYPE_NORMAL_PLANET : STELLAR_TYPE_MOON;
    
    if (atmo)
        planet_seed = p_seed.a * 13 + p_seed.c * 11 + p_seed.e * 7; // pseudo-random set-up for vertex colours
    else
        planet_seed = p_seed.a * 7 + p_seed.c * 11 + p_seed.e * 13; // pseudo-random set-up for vertex colours
    
    OOTexture *texture = [dict oo_objectOfClass:[OOTexture class] forKey:@"_oo_textureObject"];
    if (texture != nil)
    {
        _texture = [texture retain];
        isTextureImage = [dict oo_boolForKey:@"_oo_isExplicitlyTextured"];
    }
    else
    {
        NSDictionary *textureSpec = [dict oo_textureSpecifierForKey:@"texture" defaultName:nil];
        if (textureSpec != nil)
        {
            [self loadTexture:textureSpec];
        }
 
// CIM: nothing actually uses textureSpec after the assignment below, so skip it
/*      if (textureSpec == nil && !procGen && !atmo)
        {
            // Moons use metal.png by default.
            textureSpec = OOTextureSpecFromObject(@"metal.png", nil);
            } */
        
        NSString *seedStr = [dict oo_stringForKey:@"seed"];
        if (seedStr != nil)
        {
            Random_Seed seed = RandomSeedFromString(seedStr);
            if (!is_nil_seed(seed))
            {
                p_seed = seed;
            }
            else
            {
                OOLogERR(@"planet.fromDict", @"could not interpret \"%@\" as planet seed, using default.", seedStr);
            }
        }
    }
    
    seed_for_planet_description(p_seed);
    
    NSMutableDictionary *planetInfo = [NSMutableDictionary dictionaryWithDictionary:[UNIVERSE generateSystemData:p_seed]];
    int radius_km = [dict oo_intForKey:KEY_RADIUS 
                        defaultValue:[planetInfo oo_intForKey:KEY_RADIUS]];
    int techlevel = [dict oo_intForKey:KEY_TECHLEVEL
                        defaultValue:[planetInfo oo_intForKey:KEY_TECHLEVEL]];
    
    shuttles_on_ground = 1 + floor(techlevel * 0.5);
    last_launch_time = 0.0;
    shuttle_launch_interval = 3600.0 / shuttles_on_ground; // all are launched in an hour
 
    last_launch_time = [UNIVERSE getTime] + 30.0 - shuttle_launch_interval;   // debug - launch 30s after player enters universe
 
    collision_radius = radius_km * 10.0; // scale down by a factor of 100 !
    
    scanClass = CLASS_NO_DRAW;
    
    orientation.w =  M_SQRT1_2;
    orientation.x =  M_SQRT1_2;
    orientation.y =  0.0;
    orientation.z =  0.0;
    
    [self setUseTexturedModel:(procGen || _texture != nil)];
    
    int percent_land = [planetInfo oo_intForKey:@"percent_land" defaultValue:24 + (gen_rnd_number() % 48)];
    //if (isTextured)  percent_land =  atmo ? 0 :100; // moon/planet override
    
    // save the current random number generator seed
    RNG_Seed saved_seed = currentRandomSeed();
    
    // For historical reasons, stir the PRNG vertexCount times.
    unsigned i;
    for (i = 0; i < vertexCount; i++)  gen_rnd_number();
    
    [planetInfo setObject:[NSNumber numberWithFloat:0.01 * percent_land] forKey:@"land_fraction"];
    
    polar_color_factor = [dict oo_doubleForKey:@"polar_color_factor" defaultValue:0.5f];
    
    Vector land_hsb, sea_hsb, land_polar_hsb, sea_polar_hsb;
    
    if (isTextureImage)
    {
        // standard overlay colours.
        land_hsb.x = 0.0;   land_hsb.y = 0.0;   land_hsb.z = 1.0;   // non-saturated fully bright (white)
        sea_hsb.x = 0.0;    sea_hsb.y = 1.0;    sea_hsb.z = 1.0;    // fully-saturated fully bright (red)   
        // override the mainPlanet texture colour...
        [self setTextureColorForPlanet:!![dict objectForKey:@"mainForLocalSystem"] inSystem:[dict oo_boolForKey:@"mainForLocalSystem" defaultValue:NO]];
    }
    else
    {
        // random land & sea colours.
        land_hsb.x = gen_rnd_number() / 256.0;  land_hsb.y = gen_rnd_number() / 256.0;  land_hsb.z = 0.5 + gen_rnd_number() / 512.0;
        sea_hsb.x = gen_rnd_number() / 256.0;  sea_hsb.y = gen_rnd_number() / 256.0;  sea_hsb.z = 0.5 + gen_rnd_number() / 512.0;
        while (dot_product(land_hsb,sea_hsb) > .80) // make sure land and sea colors differ significantly
        {
            sea_hsb.x = gen_rnd_number() / 256.0;  sea_hsb.y = gen_rnd_number() / 256.0;  sea_hsb.z = 0.5 + gen_rnd_number() / 512.0;
        }
        
        // assign land_hsb and sea_hsb overrides from planetinfo.plist if they're there.
        ScanVectorFromString([dict objectForKey:@"land_hsb_color"], &land_hsb);
        ScanVectorFromString([dict objectForKey:@"sea_hsb_color"], &sea_hsb);
        
        // polar areas are brighter but have less color (closer to white)
        land_polar_hsb.x = land_hsb.x;  land_polar_hsb.y = (land_hsb.y / 4.0);  land_polar_hsb.z = 1.0 - (land_hsb.z / 10.0);
        sea_polar_hsb.x = sea_hsb.x;  sea_polar_hsb.y = (sea_hsb.y / 4.0);  sea_polar_hsb.z = 1.0 - (sea_hsb.z / 10.0);
        
        OOColor *amb_land_color = [OOColor colorWithHue:land_hsb.x saturation:land_hsb.y brightness:land_hsb.z alpha:1.0];
        OOColor *amb_sea_color = [OOColor colorWithHue:sea_hsb.x saturation:sea_hsb.y brightness:sea_hsb.z alpha:1.0];
        OOColor *amb_polar_land_color = [OOColor colorWithHue:land_polar_hsb.x saturation:land_polar_hsb.y brightness:land_polar_hsb.z alpha:1.0];
        OOColor *amb_polar_sea_color = [OOColor colorWithHue:sea_polar_hsb.x saturation:sea_polar_hsb.y brightness:sea_polar_hsb.z alpha:1.0];
        
        amb_land[0] = [amb_land_color redComponent];
        amb_land[1] = [amb_land_color blueComponent];
        amb_land[2] = [amb_land_color greenComponent];
        amb_land[3] = 1.0;
        amb_sea[0] = [amb_sea_color redComponent];
        amb_sea[1] = [amb_sea_color blueComponent];
        amb_sea[2] = [amb_sea_color greenComponent];
        amb_sea[3] = 1.0;
        amb_polar_land[0] = [amb_polar_land_color redComponent];
        amb_polar_land[1] = [amb_polar_land_color blueComponent];
        amb_polar_land[2] = [amb_polar_land_color greenComponent];
        amb_polar_land[3] = 1.0;
        amb_polar_sea[0] = [amb_polar_sea_color redComponent];
        amb_polar_sea[1] = [amb_polar_sea_color blueComponent];
        amb_polar_sea[2] = [amb_polar_sea_color greenComponent];
        amb_polar_sea[3] = 1.0;
        
        [planetInfo setObject:amb_land_color forKey:@"land_color"];
        [planetInfo setObject:amb_sea_color forKey:@"sea_color"];
        [planetInfo setObject:amb_polar_land_color forKey:@"polar_land_color"];
        [planetInfo setObject:amb_polar_sea_color forKey:@"polar_sea_color"];
    }
 
    if (procGen && _texture == nil)
    {
        _texture = [self planetTextureWithInfo:planetInfo];
        isTextureImage = NO;
        [_texture retain];
    }
    
    [self initialiseBaseVertexArray];
    [self initialiseBaseTerrainArray:percent_land];
    
    for (i = 0; i < next_free_vertex; i++)
    {
        [self paintVertex:i :planet_seed];
    }
    
    [self scaleVertices];
    // set speed of rotation    
    if ([dict objectForKey:@"rotational_velocity"])
    {
        rotational_velocity = [dict oo_floatForKey:@"rotational_velocity" defaultValue:0.01f * randf()]; // 0.0 .. 0.01 avr 0.005
    }
    else
    {
        rotational_velocity = [planetInfo oo_floatForKey:@"rotation_speed" defaultValue:0.002 * (0.5+0.5*randf())]; // 0.001 .. 0.002 avr 0.0015
        rotational_velocity *= [planetInfo oo_floatForKey:@"rotation_speed_factor" defaultValue:1.0f];
    }
 
    // do atmosphere
    NSDictionary *atmoDict = dict;
    if (_texture != nil)  atmoDict =     [NSDictionary dictionaryWithObjectsAndKeys:@"0", @"percent_cloud", [NSNumber numberWithFloat:[planetInfo oo_floatForKey:@"cloud_alpha" defaultValue:1.0]], @"cloud_alpha", nil];
    if (atmo)  atmosphere = [[PlanetEntity alloc] initAsAtmosphereForPlanet:self dictionary:atmoDict];
    
    setRandomSeed(saved_seed);
    RANROTSetFullSeed(ranrotSavedSeed);
 
    // set energy
    energy = collision_radius * 1000.0;
    
    root_planet = self;
    
    rotationAxis = vector_up_from_quaternion(orientation);
 
    /* MKW - rotate planet based on current time.
     *     - do it here so that we catch all planets (OXP-added and otherwise! */
    int     deltaT = floor(fmod([PLAYER clockTimeAdjusted], 86400));
    quaternion_rotate_about_axis(&orientation, rotationAxis, rotational_velocity * deltaT);
 
    [self setStatus:STATUS_ACTIVE];
    
    [[OOGraphicsResetManager sharedManager] registerClient:self];
    
    return self;
}

References _texture, Random_Seed::a, amb_land, amb_polar_land, amb_polar_sea, amb_sea, atmosphere, OOColor::blueComponent, Random_Seed::c, Entity::collision_radius, OOColor::colorWithHue:saturation:brightness:alpha:, currentRandomSeed(), Random_Seed::e, Entity::energy, gen_rnd_number(), OOColor::greenComponent, Entity::init, initialiseBaseTerrainArray:, initialiseBaseVertexArray, is_nil_seed(), isTextureImage, last_launch_time, loadTexture:, M_SQRT1_2, next_free_vertex, nil, OOLogERR, Entity::orientation, planet_seed, planet_type, planetTextureWithInfo:, PLAYER, polar_color_factor, quaternion_rotate_about_axis(), RandomSeedFromString(), RANROTGetFullSeed(), RANROTSetFullSeed(), OOColor::redComponent, OOGraphicsResetManager::registerClient:, OOTexture::retain, root_planet, rotational_velocity, rotationAxis, scaleVertices, Entity::scanClass, ScanVectorFromString(), seed_for_planet_description(), setRandomSeed(), Entity::setStatus:, setTextureColorForPlanet:inSystem:, setUseTexturedModel:, OOGraphicsResetManager::sharedManager, shuttle_launch_interval, shuttles_on_ground, STELLAR_TYPE_MOON, STELLAR_TYPE_NORMAL_PLANET, texture, vector_up_from_quaternion(), and vertexCount.

Here is the call graph for this function:

initialiseBaseTerrainArray:

- (void) initialiseBaseTerrainArray: (int) percent_land

implementation

Provided by category PlanetEntity(OOPrivate).

Definition at line 1364 of file PlanetEntity.m.

                                   :(int) percent_land
{
    RANROTSeed saved_seed = RANROTGetFullSeed();
 
    // set first 12 or 14 vertices
    if (percent_land >= 0)
    {
        GLuint vi;
        for (vi = 0; vi < vertexCount; vi++)
        {
            if (gen_rnd_number() < 256 * percent_land / 100)
                base_terrain_array[vi] = 0;  // land
            else
                base_terrain_array[vi] = 100;  // sea
 
        }
    }
    
    // for the next levels of subdivision simply build up from the level below!...
    BOOL isTextured = [self isTextured];
    
    int sublevel;
    for (sublevel = 0; sublevel < MAX_SUBDIVIDE - 1; sublevel++)
    {
        int tri;
        for (tri = 0; tri < n_triangles[sublevel]; tri++)
        {
            // get the six vertices for this group of four triangles
            int v0 = vertex_index_array[triangle_start[sublevel] + tri * 3 + 0];
            int v1 = vertex_index_array[triangle_start[sublevel] + tri * 3 + 1];
            int v2 = vertex_index_array[triangle_start[sublevel] + tri * 3 + 2];
            int v01 = baseVertexIndexForEdge(v0, v1, isTextured); // sets it up if required
            int v12 = baseVertexIndexForEdge(v1, v2, isTextured); // ..
            int v20 = baseVertexIndexForEdge(v2, v0, isTextured); // ..
            // v01
            if (base_terrain_array[v0] == base_terrain_array[v1])
                base_terrain_array[v01] = base_terrain_array[v0];
            else
            {
                uint32_t s1 = 0xffff0000 * base_vertex_array[v01].x;
                uint32_t s2 = 0x00ffff00 * base_vertex_array[v01].y;
                uint32_t s3 = 0x0000ffff * base_vertex_array[v01].z;
                ranrot_srand(s1+s2+s3);
                base_terrain_array[v01] = (ranrot_rand() & 4) *25;
            }
            // v12
            if (base_terrain_array[v1] == base_terrain_array[v2])
                base_terrain_array[v12] = base_terrain_array[v1];
            else
            {
                uint32_t s1 = 0xffff0000 * base_vertex_array[v12].x;
                uint32_t s2 = 0x00ffff00 * base_vertex_array[v12].y;
                uint32_t s3 = 0x0000ffff * base_vertex_array[v12].z;
                ranrot_srand(s1+s2+s3);
                base_terrain_array[v12] = (ranrot_rand() & 4) *25;
            }
            // v20
            if (base_terrain_array[v2] == base_terrain_array[v0])
                base_terrain_array[v20] = base_terrain_array[v2];
            else
            {
                uint32_t s1 = 0xffff0000 * base_vertex_array[v20].x;
                uint32_t s2 = 0x00ffff00 * base_vertex_array[v20].y;
                uint32_t s3 = 0x0000ffff * base_vertex_array[v20].z;
                ranrot_srand(s1+s2+s3);
                base_terrain_array[v20] = (ranrot_rand() & 4) *25;
            }
        }
    }
 
    RANROTSetFullSeed(saved_seed);
}

References base_terrain_array, base_vertex_array, baseVertexIndexForEdge(), gen_rnd_number(), isTextured, MAX_SUBDIVIDE, n_triangles, ranrot_rand, ranrot_srand(), RANROTGetFullSeed(), RANROTSetFullSeed(), and vertex_index_array.

Referenced by PlanetEntity(OOPrivate)::initAsAtmosphereForPlanet:dictionary:, initFromDictionary:withAtmosphere:andSeed:, and setUpPlanetFromTexture:.

Here is the call graph for this function:

Here is the caller graph for this function:

initialiseBaseVertexArray

- (void) initialiseBaseVertexArray

implementation

Provided by category PlanetEntity(OOPrivate).

Definition at line 1211 of file PlanetEntity.m.

{
    BOOL isTextured = [self isTextured];
    static BOOL lastOneWasTextured;
    
    if (lastOneWasTextured != isTextured)
    {
        if (sEdgeToVertex != NULL)
        {
            NSFreeMapTable(sEdgeToVertex);
            sEdgeToVertex = NULL;
        }
        lastOneWasTextured = isTextured;
    }
    
    if (sEdgeToVertex == NULL)
    {
        sEdgeToVertex = NSCreateMapTable(NSIntegerMapKeyCallBacks, NSIntegerMapValueCallBacks, 7680);  // make a new one
        next_free_vertex = 0;
        
        const Vector *vertices = NULL;
        const BaseFace (*faces)[3] = NULL;
        GLuint faceCount = 0;
        if (useTexturedModel)
        {
            vertices = kTexturedVertices;
            faces = kTexturedFaces;
            faceCount = sizeof kTexturedFaces / sizeof *kTexturedFaces;
        }
        else
        {
            vertices = kUntexturedVertices;
            faces = kUntexturedFaces;
            faceCount = sizeof kUntexturedFaces / sizeof *kUntexturedFaces;
        }
        
        // set first 12 or 14 vertices
        GLuint vi;
        for (vi = 0; vi < vertexCount; vi++)
        {
            base_vertex_array[next_free_vertex++] =  vertices[vi];
        }
        
        // set first 20 triangles
        triangle_start[0] = 0;
        n_triangles[0] = faceCount;
        GLuint fi;
        for (fi = 0; fi < faceCount; fi++)
        {
            unsigned j;
            for (j = 0; j < 3; j++)
            {
                vertex_index_array[fi * 3 + j] = faces[fi][j].v;
                texture_uv_array[faces[fi][j].v * 2 + 0] = faces[fi][j].s;
                texture_uv_array[faces[fi][j].v * 2 + 1] = faces[fi][j].t;
            }
        }
        
        // for the next levels of subdivision simply build up from the level below!...
        unsigned sublevel;
        for (sublevel = 0; sublevel < MAX_SUBDIVIDE - 1; sublevel++)
        {
            int newlevel = sublevel + 1;
            triangle_start[newlevel] = triangle_start[sublevel] + n_triangles[sublevel] * 3;
            n_triangles[newlevel] = n_triangles[sublevel] * 4;
 
            int tri;
            for (tri = 0; tri < n_triangles[sublevel]; tri++)
            {
                // get the six vertices for this group of four triangles
                int v0 = vertex_index_array[triangle_start[sublevel] + tri * 3 + 0];
                int v1 = vertex_index_array[triangle_start[sublevel] + tri * 3 + 1];
                int v2 = vertex_index_array[triangle_start[sublevel] + tri * 3 + 2];
                int v01 = baseVertexIndexForEdge(v0, v1, isTextured); // sets it up if required
                int v12 = baseVertexIndexForEdge(v1, v2, isTextured); // ..
                int v20 = baseVertexIndexForEdge(v2, v0, isTextured); // ..
                // v0 v01 v20
                vertex_index_array[triangle_start[newlevel] + tri * 12 + 0] = v0;
                vertex_index_array[triangle_start[newlevel] + tri * 12 + 1] = v01;
                vertex_index_array[triangle_start[newlevel] + tri * 12 + 2] = v20;
                // v01 v1 v12
                vertex_index_array[triangle_start[newlevel] + tri * 12 + 3] = v01;
                vertex_index_array[triangle_start[newlevel] + tri * 12 + 4] = v1;
                vertex_index_array[triangle_start[newlevel] + tri * 12 + 5] = v12;
                // v20 v12 v2
                vertex_index_array[triangle_start[newlevel] + tri * 12 + 6] = v20;
                vertex_index_array[triangle_start[newlevel] + tri * 12 + 7] = v12;
                vertex_index_array[triangle_start[newlevel] + tri * 12 + 8] = v2;
                // v01 v12 v20
                vertex_index_array[triangle_start[newlevel] + tri * 12 + 9] = v01;
                vertex_index_array[triangle_start[newlevel] + tri * 12 +10] = v12;
                vertex_index_array[triangle_start[newlevel] + tri * 12 +11] = v20;
 
            }
        }
    }
    
    // all done - copy the indices to the instance
    unsigned i;
    for (i = 0; i < MAX_TRI_INDICES; i++)
    {
        vertexdata.index_array[i] = vertex_index_array[i];
    }
}

References base_vertex_array, baseVertexIndexForEdge(), PlanetEntity(OOPrivate)::initialiseBaseVertexArray, isTextured, kTexturedFaces, kTexturedVertices, kUntexturedFaces, kUntexturedVertices, MAX_SUBDIVIDE, MAX_TRI_INDICES, n_triangles, next_free_vertex, sEdgeToVertex, texture_uv_array, triangle_start, and vertex_index_array.

Referenced by PlanetEntity(OOPrivate)::initAsAtmosphereForPlanet:dictionary:, initFromDictionary:withAtmosphere:andSeed:, PlanetEntity(OOPrivate)::initialiseBaseVertexArray, and setUpPlanetFromTexture:.

Here is the call graph for this function:

Here is the caller graph for this function:

initMiniatureFromPlanet:withAlpha:

- (id) initMiniatureFromPlanet: (PlanetEntity *) planet withAlpha: (float) alpha

implementation

Provided by category PlanetEntity(OOPrivate).

isExplicitlyTextured

- (BOOL) isExplicitlyTextured

Definition at line 1523 of file PlanetEntity.m.

{
    return isTextureImage;
}

References isExplicitlyTextured, and isTextureImage.

Referenced by isExplicitlyTextured, and planet_seed.

Here is the call graph for this function:

Here is the caller graph for this function:

isPlanet

- (BOOL) isPlanet

implementation

Reimplemented from Entity.

Definition at line 1620 of file PlanetEntity.m.

{
    return YES;
}

References isPlanet.

Referenced by isPlanet.

Here is the call graph for this function:

Here is the caller graph for this function:

isTextured

- (BOOL) isTextured

Definition at line 1007 of file PlanetEntity.m.

{
    return _texture != nil;
}

References _texture, isTextured, and nil.

Referenced by PlanetEntity(OOPrivate)::initialiseBaseTerrainArray:, PlanetEntity(OOPrivate)::initialiseBaseVertexArray, isTextured, planet_seed, and setUpPlanetFromTexture:.

Here is the call graph for this function:

Here is the caller graph for this function:

isVisible

- (BOOL) isVisible

implementation

Reimplemented from Entity.

Definition at line 1626 of file PlanetEntity.m.

{
    return YES;
}

References isVisible.

Referenced by isVisible.

Here is the call graph for this function:

Here is the caller graph for this function:

launchShuttle

- (void) launchShuttle

Definition at line 1169 of file PlanetEntity.m.

{
    ShipEntity  *shuttle_ship;
    Quaternion  q1;
    HPVector        launch_pos = position;
    double      start_distance = collision_radius + 125.0;
 
    quaternion_set_random(&q1);
 
    Vector vf = vector_forward_from_quaternion(q1);
 
    launch_pos.x += start_distance * vf.x;
    launch_pos.y += start_distance * vf.y;
    launch_pos.z += start_distance * vf.z;
 
    shuttle_ship = [UNIVERSE newShipWithRole:@"shuttle"];   // retain count = 1
    if (shuttle_ship)
    {
        if (![shuttle_ship crew])
        {
            [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];
 
        [shuttle_ship release];
    }
}

References Entity::collision_radius, launchShuttle, Entity::position, quaternion_set_random(), ShipEntity::setCargoFlag:, Entity::setOrientation:, Entity::setPosition:, Entity::setScanClass:, ShipEntity::setSingleCrewWithRole:, ShipEntity::switchAITo:, and vector_forward_from_quaternion().

Referenced by amb_polar_sea, launchShuttle, and update:.

Here is the call graph for this function:

Here is the caller graph for this function:

loadTexture:

- (void) loadTexture: (NSDictionary *) configuration

implementation

Provided by category PlanetEntity(OOPrivate).

Definition at line 1535 of file PlanetEntity.m.

                    :(NSDictionary *)configuration
{
    [_texture release];
    _texture = [OOTexture textureWithConfiguration:configuration extraOptions:kOOTextureAllowCubeMap | kOOTextureRepeatS];
    [_texture retain];
    
    [_textureFileName release];
    if (_texture != nil)
    {
        _textureFileName = [[configuration oo_stringForKey:@"name"] copy];
        isTextureImage = YES;
    }
    else
    {
        _textureFileName = nil;
        isTextureImage = NO;
    }
}

References nil, and OOTexture::textureWithConfiguration:extraOptions:.

Referenced by initFromDictionary:withAtmosphere:andSeed:, and setUpPlanetFromTexture:.

Here is the call graph for this function:

Here is the caller graph for this function:

miniaturize

- (void) miniaturize

Definition at line 359 of file PlanetEntity.m.

{
    planet_type = STELLAR_TYPE_MINIATURE;
    shuttles_on_ground = 0;
    last_launch_time = 0.0;
    shuttle_launch_interval = 3600.0;
    [self setStatus:STATUS_COCKPIT_DISPLAY];
    collision_radius = [self collisionRadius] * PLANET_MINIATURE_FACTOR; // teeny tiny
    [self scaleVertices];
    if (atmosphere != nil)
    {
        atmosphere->collision_radius = collision_radius + ATMOSPHERE_DEPTH * PLANET_MINIATURE_FACTOR*2.0; //not to scale: invisible otherwise
        [atmosphere scaleVertices];
    }
    rotational_velocity = 0.04;
    rotationAxis = kBasisYVector;
}

References atmosphere, ATMOSPHERE_DEPTH, Entity::collision_radius, Entity::collisionRadius, kBasisYVector, last_launch_time, miniaturize, nil, PLANET_MINIATURE_FACTOR, planet_type, rotational_velocity, rotationAxis, scaleVertices, Entity::setStatus:, shuttle_launch_interval, shuttles_on_ground, and STELLAR_TYPE_MINIATURE.

Referenced by miniaturize.

Here is the call graph for this function:

Here is the caller graph for this function:

paintVertex:vi:

- (void) paintVertex: (unsigned) vi: (int) seed

implementation

Provided by category PlanetEntity(OOPrivate).

Definition at line 1438 of file PlanetEntity.m.

                    :(unsigned) vi :(int) seed
{
    RANROTSeed saved_seed = RANROTGetFullSeed();
    BOOL isTextured = _texture != nil;
    
    GLfloat paint_land[4] = { 0.2, 0.9, 0.0, 1.0};
    GLfloat paint_sea[4] = { 0.0, 0.2, 0.9, 1.0};
    GLfloat paint_color[4];
    Vector  v = base_vertex_array[vi];
    int     r = isTextured ? 0 : base_terrain_array[vi];    // use land color (0) for textured planets
    int i;
    double pole_blend = v.z * v.z * polar_color_factor;
    if (pole_blend < 0.0)   pole_blend = 0.0;
    if (pole_blend > 1.0)   pole_blend = 1.0;
    
    paint_land[0] = (1.0 - pole_blend)*amb_land[0] + pole_blend*amb_polar_land[0];
    paint_land[1] = (1.0 - pole_blend)*amb_land[1] + pole_blend*amb_polar_land[1];
    paint_land[2] = (1.0 - pole_blend)*amb_land[2] + pole_blend*amb_polar_land[2];
    paint_sea[0] = (1.0 - pole_blend)*amb_sea[0] + pole_blend*amb_polar_sea[0];
    paint_sea[1] = (1.0 - pole_blend)*amb_sea[1] + pole_blend*amb_polar_sea[1];
    paint_sea[2] = (1.0 - pole_blend)*amb_sea[2] + pole_blend*amb_polar_sea[2];
    if (planet_type == STELLAR_TYPE_ATMOSPHERE)  // do alphas
    {
        paint_land[3] = (1.0 - pole_blend)*amb_land[3] + pole_blend*amb_polar_land[3];
        paint_sea[3] = (1.0 - pole_blend)*amb_sea[3] + pole_blend*amb_polar_sea[3];
    }
    
    ranrot_srand((uint32_t)(seed+v.x*1000+v.y*100+v.z*10));
    
    for (i = 0; i < 3; i++)
    {
        double cv = (ranrot_rand() % 100)*0.01;  //  0..1 ***** DON'T CHANGE THIS LINE, '% 100' MAY NOT BE EFFICIENT BUT THE PATTERNING IS GOOD.
        paint_land[i] += (cv - 0.5)*0.1;
        paint_sea[i] += (cv - 0.5)*0.1;
    }
    
    for (i = 0; i < 4; i++)
    {
        if (planet_type == STELLAR_TYPE_ATMOSPHERE && isTextured)
            paint_color[i] = 1.0;
        else
            paint_color[i] = (r * paint_sea[i])*0.01 + ((100 - r) * paint_land[i])*0.01;
        // finally initialise the color array entry
        vertexdata.color_array[vi*4 + i] = paint_color[i];
    }
 
    RANROTSetFullSeed(saved_seed);
}

References base_terrain_array, base_vertex_array, nil, ranrot_rand, ranrot_srand(), RANROTGetFullSeed(), RANROTSetFullSeed(), and STELLAR_TYPE_ATMOSPHERE.

Here is the call graph for this function:

planet_seed

- (int) planet_seed

References isExplicitlyTextured, isTextured, polar_color_factor, texture, and textureFileName.

Here is the call graph for this function:

planetTextureWithInfo:

- (OOTexture *) planetTextureWithInfo: (NSDictionary *) info

implementation

Provided by category PlanetEntity(OOPrivate).

Definition at line 1561 of file PlanetEntity.m.

                                     :(NSDictionary *)info
{
    unsigned char *data;
    GLuint width, height;
    
    fillRanNoiseBuffer();
    if (![TextureStore getPlanetTextureNameFor:info
                                      intoData:&data
                                         width:&width
                                        height:&height])
    {
        return nil;
    }
    
    OOPixMap pm = OOMakePixMap(data, width, height, kOOPixMapRGBA, 0, 0);
    OOTextureGenerator *loader = [[OOPixMapTextureLoader alloc] initWithPixMap:pm
                                                                textureOptions:kOOTextureDefaultOptions | kOOTextureRepeatS
                                                                  freeWhenDone:YES];
    [loader autorelease];
    
    return [OOTexture textureWithGenerator:loader];
}

References fillRanNoiseBuffer(), kOOPixMapRGBA, nil, OOMakePixMap(), and OOTexture::textureWithGenerator:.

Referenced by initFromDictionary:withAtmosphere:andSeed:.

Here is the call graph for this function:

Here is the caller graph for this function:

planetType

- (OOStellarBodyType) planetType

Reimplemented from <OOStellarBody>.

Definition at line 1113 of file PlanetEntity.m.

{
    return planet_type;
}

References planet_type, and planetType.

Referenced by amb_polar_sea, and planetType.

Here is the call graph for this function:

Here is the caller graph for this function:

polar_color_factor

- (double) polar_color_factor

References amb_land.

radius

- (double) radius

Reimplemented from <OOStellarBody>.

Definition at line 1125 of file PlanetEntity.m.

{
    return collision_radius;
}

References Entity::collision_radius, and radius.

Referenced by amb_polar_sea, descriptionComponents, drawImmediate:translucent:, and radius.

Here is the call graph for this function:

Here is the caller graph for this function:

resetGraphicsState

- (void) resetGraphicsState

implementation

Definition at line 1517 of file PlanetEntity.m.

{
    [self deleteDisplayLists];
}

References deleteDisplayLists, and resetGraphicsState.

Referenced by resetGraphicsState.

Here is the call graph for this function:

Here is the caller graph for this function:

rotationalVelocity

- (double) rotationalVelocity

Definition at line 1136 of file PlanetEntity.m.

{
    return rotational_velocity;
}

References rotational_velocity, and rotationalVelocity.

Referenced by amb_polar_sea, PlanetEntity(OOPrivate)::initAsAtmosphereForPlanet:dictionary:, rotationalVelocity, and setRotationalVelocity:.

Here is the call graph for this function:

Here is the caller graph for this function:

scaleVertices

- (void) scaleVertices

implementation

Provided by category PlanetEntity(OOPrivate).

Definition at line 1488 of file PlanetEntity.m.

{
    NSUInteger vi;
    for (vi = 0; vi < next_free_vertex; vi++)
    {
        Vector  v = base_vertex_array[vi];
        vertexdata.normal_array[vi] = v;
        vertexdata.vertex_array[vi] = make_vector(v.x * collision_radius, v.y * collision_radius, v.z * collision_radius);
        
        vertexdata.uv_array[vi * 2] = texture_uv_array[vi * 2];
        vertexdata.uv_array[vi * 2 + 1] = texture_uv_array[vi * 2 + 1];
    }
}

References base_vertex_array, next_free_vertex, PlanetEntity(OOPrivate)::scaleVertices, and texture_uv_array.

Referenced by PlanetEntity(OOPrivate)::initAsAtmosphereForPlanet:dictionary:, initFromDictionary:withAtmosphere:andSeed:, miniaturize, PlanetEntity(OOPrivate)::scaleVertices, and setUpPlanetFromTexture:.

Here is the call graph for this function:

Here is the caller graph for this function:

setOrientation:

- (void) setOrientation: (Quaternion) inOrientation

implementation

Reimplemented from Entity.

Definition at line 739 of file PlanetEntity.m.

                       :(Quaternion)inOrientation
{
    rotationAxis = vector_up_from_quaternion(inOrientation);
    [super setOrientation:inOrientation];
    if (atmosphere) [atmosphere setOrientation:inOrientation];
}

References atmosphere, rotationAxis, Entity::setOrientation:, setOrientation:, and vector_up_from_quaternion().

Referenced by setOrientation:.

Here is the call graph for this function:

Here is the caller graph for this function:

setPlanetType:

- (void) setPlanetType:

(OOStellarBodyType)

pt

Definition at line 1119 of file PlanetEntity.m.

                      :(OOStellarBodyType) pt
{
    planet_type = pt;
}

References planet_type.

setPosition:

- (void) setPosition: (HPVector) posn

implementation

Reimplemented from Entity.

Definition at line 732 of file PlanetEntity.m.

                    :(HPVector)posn
{
    position = posn;
    [atmosphere setPosition:posn];
}

References Entity::position, and setPosition:.

Referenced by setPosition:.

Here is the call graph for this function:

Here is the caller graph for this function:

setRadius:

- (void) setRadius:

(GLfloat)

rad

Definition at line 1131 of file PlanetEntity.m.

                  :(GLfloat) rad
{
    collision_radius = rad;
}

References Entity::collision_radius.

setRotationalVelocity:

- (void) setRotationalVelocity:

(double)

v

Definition at line 1141 of file PlanetEntity.m.

                              :(double) v
{
    if (atmosphere) // change rotation speed proportionally
    {
        [atmosphere setRotationalVelocity:[atmosphere rotationalVelocity] * v / [self rotationalVelocity]];
    }
    rotational_velocity = v;
}

References atmosphere, rotational_velocity, rotationalVelocity, and setRotationalVelocity:.

Referenced by setRotationalVelocity:.

Here is the call graph for this function:

Here is the caller graph for this function:

setTextureColorForPlanet:inSystem:

- (void) setTextureColorForPlanet: (BOOL) isMain inSystem: (BOOL) isLocal

implementation

Provided by category PlanetEntity(OOPrivate).

Definition at line 1019 of file PlanetEntity.m.

                                 :(BOOL)isMain inSystem:(BOOL)isLocal
{   
    Vector land_hsb, land_polar_hsb;
    land_hsb.x = 0.0;   land_hsb.y = 0.0;   land_hsb.z = 1.0;   // white
    
    // the colour override should only apply to main planets
    if (isMain)
    {
        if (isLocal)  ScanVectorFromString([[UNIVERSE currentSystemData] objectForKey:@"texture_hsb_color"], &land_hsb);
        else  ScanVectorFromString([[UNIVERSE generateSystemData:[PLAYER target_system_seed]] objectForKey:@"texture_hsb_color"], &land_hsb);
    }
    
    land_polar_hsb.x = land_hsb.x;  land_polar_hsb.y = (land_hsb.y / 5.0);  land_polar_hsb.z = 1.0 - (land_hsb.z / 10.0);
    
    amb_sea[0] = amb_land[0] = [[OOColor colorWithHue:land_hsb.x saturation:land_hsb.y brightness:land_hsb.z alpha:1.0] redComponent];
    amb_sea[1] = amb_land[1] = [[OOColor colorWithHue:land_hsb.x saturation:land_hsb.y brightness:land_hsb.z alpha:1.0] blueComponent];
    amb_sea[2] = amb_land[2] = [[OOColor colorWithHue:land_hsb.x saturation:land_hsb.y brightness:land_hsb.z alpha:1.0] greenComponent];
    amb_sea[3] = amb_land[3] = 1.0;
    amb_polar_sea[0] =amb_polar_land[0] = [[OOColor colorWithHue:land_polar_hsb.x saturation:land_polar_hsb.y brightness:land_polar_hsb.z alpha:1.0] redComponent];
    amb_polar_sea[1] =amb_polar_land[1] = [[OOColor colorWithHue:land_polar_hsb.x saturation:land_polar_hsb.y brightness:land_polar_hsb.z alpha:1.0] blueComponent];
    amb_polar_sea[2] = amb_polar_land[2] = [[OOColor colorWithHue:land_polar_hsb.x saturation:land_polar_hsb.y brightness:land_polar_hsb.z alpha:1.0] greenComponent];
    amb_polar_sea[3] =amb_polar_land[3] = 1.0;
}

References OOColor::blueComponent, OOColor::colorWithHue:saturation:brightness:alpha:, OOColor::greenComponent, PLAYER, OOColor::redComponent, ScanVectorFromString(), and UNIVERSE.

Referenced by initFromDictionary:withAtmosphere:andSeed:, and setUpPlanetFromTexture:.

Here is the call graph for this function:

Here is the caller graph for this function:

setUpPlanetFromTexture:

- (BOOL) setUpPlanetFromTexture:

(NSString *)

fileName

Definition at line 1044 of file PlanetEntity.m.

                               :(NSString *)fileName
{
    if (fileName == nil)  return NO;
    
    [self loadTexture:OOTextureSpecFromObject(fileName, nil)];
    [self deleteDisplayLists];
    
    unsigned i;
    [self setUseTexturedModel:YES];
    
    // recolour main planet according to "texture_hsb_color"
    // this function is only called for local systems!
    [self setTextureColorForPlanet:([UNIVERSE planet] == self) inSystem:YES];
    
    [self initialiseBaseVertexArray];
    [self initialiseBaseTerrainArray:100];
    for (i =  0; i < next_free_vertex; i++)
    {
        [self paintVertex:i :planet_seed];
    }
    
    [self scaleVertices];
    
    GLfloat oldCloudAlpha = 0.0;
    if (atmosphere)
    {
        oldCloudAlpha = [atmosphere amb_sea][3] / CLOUD_ALPHA;
    }
 
    NSDictionary *atmo_dictionary = [NSDictionary dictionaryWithObjectsAndKeys:@"0", @"percent_cloud", [NSNumber numberWithFloat:oldCloudAlpha], @"cloud_alpha", nil];
    [atmosphere autorelease];
    atmosphere = [self hasAtmosphere] ? [[PlanetEntity alloc] initAsAtmosphereForPlanet:self dictionary:atmo_dictionary] : nil;
    
    //rotationAxis = vector_up_from_quaternion(orientation);
    
    return [self isTextured];
}

References amb_sea, atmosphere, CLOUD_ALPHA, deleteDisplayLists, hasAtmosphere, initialiseBaseTerrainArray:, initialiseBaseVertexArray, isTextured, loadTexture:, next_free_vertex, nil, scaleVertices, setTextureColorForPlanet:inSystem:, and setUseTexturedModel:.

Here is the call graph for this function:

setUseTexturedModel:

- (void) setUseTexturedModel: (BOOL) flag

implementation

Provided by category PlanetEntity(OOPrivate).

Definition at line 747 of file PlanetEntity.m.

                            :(BOOL)flag
{
    if (flag)
    {
        useTexturedModel = YES;
        vertexCount = sizeof kTexturedVertices / sizeof *kTexturedVertices;
    }
    else
    {
        useTexturedModel = NO;
        vertexCount = sizeof kUntexturedVertices / sizeof *kTexturedVertices;
    }
}

References kTexturedVertices, and kUntexturedVertices.

Referenced by PlanetEntity(OOPrivate)::initAsAtmosphereForPlanet:dictionary:, initFromDictionary:withAtmosphere:andSeed:, and setUpPlanetFromTexture:.

Here is the caller graph for this function:

sqrtZeroDistance

- (double) sqrtZeroDistance

implementation

Provided by category PlanetEntity(OOPrivate).

Definition at line 1151 of file PlanetEntity.m.

{
    return sqrt_zero_distance;
}

References PlanetEntity(OOPrivate)::sqrtZeroDistance.

Referenced by PlanetEntity(OOPrivate)::sqrtZeroDistance.

Here is the call graph for this function:

Here is the caller graph for this function:

texture

- (OOTexture *) texture

Definition at line 1529 of file PlanetEntity.m.

{
    return _texture;
}

References _texture, and texture.

Referenced by initFromDictionary:withAtmosphere:andSeed:, planet_seed, and texture.

Here is the call graph for this function:

Here is the caller graph for this function:

textureFileName

- (NSString *) textureFileName

Definition at line 1013 of file PlanetEntity.m.

{
    return _textureFileName;
}

References _textureFileName, and textureFileName.

Referenced by planet_seed, and textureFileName.

Here is the call graph for this function:

Here is the caller graph for this function:

update:

- (void) update: (OOTimeDelta) delta_t

implementation

Reimplemented from Entity.

Definition at line 662 of file PlanetEntity.m.

               :(OOTimeDelta) delta_t
{
    [super update:delta_t];
    sqrt_zero_distance = sqrt(cam_zero_distance);
 
    switch (planet_type)
    {
        case STELLAR_TYPE_NORMAL_PLANET:
            // we have atmosphere in any case.
            {
                double alt = sqrt_zero_distance - collision_radius;
                double atmo = 10.0 * (atmosphere->collision_radius - collision_radius);   // effect starts at 10x the height of the clouds
 
                if ((alt > 0)&&(alt <= atmo))
                {
                    double aleph = (atmo - alt) / atmo;
                    if (aleph < 0.0) aleph = 0.0;
                    if (aleph > 1.0) aleph = 1.0;
                    
                    [UNIVERSE setSkyColorRed:0.8 * aleph * aleph
                                       green:0.8 * aleph * aleph
                                        blue:0.9 * aleph
                                       alpha:aleph];
                }
                else if (alt > 0 && alt <= atmo * 1.5)
                {
                    /* Without this, if you leave the atmosphere at very low
                     * frame rates, you might still have skyalpha > 0 when you
                     * go sun-skimming. Since skyalpha > 0 simulates atmospheric
                     * friction and continually pumps heat into the ship, this
                     * is rapidly fatal - CIM */
                    [UNIVERSE setSkyColorRed:0.0f
                                                         green:0.0f
                                                            blue:0.0f
                                                         alpha:0.0f];
                }
            }
        case STELLAR_TYPE_MOON:
            {
                double ugt = [UNIVERSE getTime];
 
                if ((shuttles_on_ground > 0)&&(ugt > last_launch_time + shuttle_launch_interval))
                {
                    [self launchShuttle];
                    shuttles_on_ground--;
                    last_launch_time = ugt;
                }
            }
        
        case STELLAR_TYPE_MINIATURE:
            // normal planetary rotation
            if (atmosphere) [atmosphere update:delta_t];
            quaternion_rotate_about_axis(&orientation, rotationAxis, rotational_velocity * delta_t);
            [self orientationChanged];
            break;
 
        case STELLAR_TYPE_ATMOSPHERE:
            {
                // atmospheric rotation
                quaternion_rotate_about_axis(&orientation, rotationAxis, rotational_velocity * delta_t);
                [self orientationChanged];
            }
            break;
        
        case STELLAR_TYPE_SUN:
            break;
    }
}

References atmosphere, Entity::cam_zero_distance, Entity::collision_radius, last_launch_time, launchShuttle, Entity::orientation, Entity::orientationChanged, planet_type, quaternion_rotate_about_axis(), rotational_velocity, rotationAxis, shuttle_launch_interval, shuttles_on_ground, sqrt_zero_distance, STELLAR_TYPE_ATMOSPHERE, STELLAR_TYPE_MINIATURE, STELLAR_TYPE_MOON, STELLAR_TYPE_NORMAL_PLANET, STELLAR_TYPE_SUN, Entity::update:, and update:.

Referenced by update:.

Here is the call graph for this function:

Here is the caller graph for this function:

welcomeShuttle:

- (void) welcomeShuttle:

(ShipEntity *)

shuttle

Definition at line 1205 of file PlanetEntity.m.

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

References shuttles_on_ground.

Member Data Documentation

_texture

- (OOTexture*) _texture

private

Definition at line 65 of file PlanetEntity.h.

Referenced by allTextures, dealloc, drawUnconditionally, initFromDictionary:withAtmosphere:andSeed:, isTextured, and texture.

_textureFileName

- (NSString*) _textureFileName

private

Definition at line 64 of file PlanetEntity.h.

Referenced by dealloc, and textureFileName.

amb_land

- (GLfloat *) amb_land

private

Definition at line 1089 of file PlanetEntity.m.

{
    return amb_land;
}

Referenced by initFromDictionary:withAtmosphere:andSeed:, and polar_color_factor.

amb_polar_land

- (GLfloat *) amb_polar_land

private

Definition at line 1095 of file PlanetEntity.m.

{
    return amb_polar_land;
}

Referenced by amb_land, and initFromDictionary:withAtmosphere:andSeed:.

amb_polar_sea

- (GLfloat *) amb_polar_sea

private

Definition at line 1107 of file PlanetEntity.m.

{
    return amb_polar_sea;
}

Referenced by amb_sea, and initFromDictionary:withAtmosphere:andSeed:.

amb_sea

- (GLfloat *) amb_sea

private

Definition at line 1101 of file PlanetEntity.m.

{
    return amb_sea;
}

Referenced by amb_polar_land, initFromDictionary:withAtmosphere:andSeed:, and setUpPlanetFromTexture:.

atmosphere

- (PlanetEntity *) atmosphere

private

Definition at line 994 of file PlanetEntity.m.

{
    return atmosphere;
}

Referenced by amb_polar_sea, dealloc, drawUnconditionally, hasAtmosphere, initFromDictionary:withAtmosphere:andSeed:, miniaturize, setOrientation:, setRotationalVelocity:, setUpPlanetFromTexture:, and update:.

displayListNames

- (GLuint displayListNames[MAX_SUBDIVIDE])

private

Definition at line 86 of file PlanetEntity.h.

Referenced by drawUnconditionally.

isTextureImage

- (BOOL) isTextureImage

private

Definition at line 63 of file PlanetEntity.h.

Referenced by initFromDictionary:withAtmosphere:andSeed:, and isExplicitlyTextured.

last_launch_time

- (double) last_launch_time

private

Definition at line 81 of file PlanetEntity.h.

Referenced by initFromDictionary:withAtmosphere:andSeed:, miniaturize, and update:.

lastSubdivideLevel

- (uint8_t) lastSubdivideLevel

private

Definition at line 61 of file PlanetEntity.h.

Referenced by drawUnconditionally.

planet_seed

- (int) planet_seed

private

Definition at line 1001 of file PlanetEntity.m.

{
    return planet_seed;
}

Referenced by initFromDictionary:withAtmosphere:andSeed:.

planet_type

- (OOStellarBodyType) planet_type

private

Definition at line 59 of file PlanetEntity.h.

Referenced by canCollide, descriptionComponents, drawUnconditionally, PlanetEntity(OOPrivate)::initAsAtmosphereForPlanet:dictionary:, initFromDictionary:withAtmosphere:andSeed:, miniaturize, planetType, setPlanetType:, and update:.

polar_color_factor

- (double) polar_color_factor

private

Definition at line 1083 of file PlanetEntity.m.

{
    return polar_color_factor;
}

Referenced by initFromDictionary:withAtmosphere:andSeed:, and planet_seed.

root_planet

- (PlanetEntity*) root_planet

private

Definition at line 78 of file PlanetEntity.h.

Referenced by drawUnconditionally, and initFromDictionary:withAtmosphere:andSeed:.

rotational_velocity

- (double) rotational_velocity

private

Definition at line 70 of file PlanetEntity.h.

Referenced by initFromDictionary:withAtmosphere:andSeed:, miniaturize, rotationalVelocity, setRotationalVelocity:, and update:.

rotationAxis

- (Vector) rotationAxis

private

Definition at line 90 of file PlanetEntity.h.

Referenced by initFromDictionary:withAtmosphere:andSeed:, miniaturize, setOrientation:, and update:.

shuttle_launch_interval

- (double) shuttle_launch_interval

private

Definition at line 82 of file PlanetEntity.h.

Referenced by initFromDictionary:withAtmosphere:andSeed:, miniaturize, and update:.

shuttles_on_ground

- (int) shuttles_on_ground

private

Definition at line 80 of file PlanetEntity.h.

Referenced by initFromDictionary:withAtmosphere:andSeed:, miniaturize, update:, and welcomeShuttle:.

sqrt_zero_distance

- (double) sqrt_zero_distance

private

Definition at line 84 of file PlanetEntity.h.

Referenced by drawUnconditionally, and update:.

useTexturedModel

- (BOOL) useTexturedModel

private

Definition at line 62 of file PlanetEntity.h.

vertexCount

- (GLuint) vertexCount

private

Definition at line 87 of file PlanetEntity.h.

Referenced by initFromDictionary:withAtmosphere:andSeed:.

vertexdata

- (VertexData) vertexdata

private

Definition at line 88 of file PlanetEntity.h.

Referenced by drawUnconditionally.

---

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

• src/Core/Entities/PlanetEntity.h
• src/Core/Entities/PlanetEntity.m