PlanetEntity(OOPrivate) Category Reference

Inheritance diagram for PlanetEntity(OOPrivate):

Collaboration diagram for PlanetEntity(OOPrivate):

Instance Methods
(double)	- sqrtZeroDistance
(void)	- drawModelWithVertexArraysAndSubdivision:
(void)	- initialiseBaseVertexArray
(void)	- initialiseBaseTerrainArray:
(void)	- paintVertex:vi:
(void)	- scaleVertices
(id)	- initAsAtmosphereForPlanet:dictionary:
(void)	- setTextureColorForPlanet:inSystem:
(id)	- initMiniatureFromPlanet:withAlpha:
(void)	- loadTexture:
(OOTexture *)	- planetTextureWithInfo:
(OOTexture *)	- cloudTextureWithCloudColor:cloudImpress:cloudBias:
(void)	- deleteDisplayLists
(void)	- setUseTexturedModel:
Instance Methods inherited from <OOGraphicsResetClient>
(void)	- resetGraphicsState

Detailed Description

Definition at line 67 of file PlanetEntity.m.

Method Documentation

cloudTextureWithCloudColor:cloudImpress:cloudBias:

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

Extends class PlanetEntity.

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

deleteDisplayLists

- (void) deleteDisplayLists

Extends class PlanetEntity.

Definition at line 1317 of file PlanetEntity.m.

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

drawModelWithVertexArraysAndSubdivision:

- (void) drawModelWithVertexArraysAndSubdivision:

(int)

subdivide

Extends class PlanetEntity.

Definition at line 102 of file PlanetEntity.m.

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

initAsAtmosphereForPlanet:dictionary:

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

Extends class PlanetEntity.

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

initialiseBaseTerrainArray:

- (void) initialiseBaseTerrainArray:

(int)

percent_land

Extends class PlanetEntity.

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

initialiseBaseVertexArray

- (void) initialiseBaseVertexArray

Extends class PlanetEntity.

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

initMiniatureFromPlanet:withAlpha:

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

Extends class PlanetEntity.

loadTexture:

- (void) loadTexture:

(NSDictionary *)

configuration

Extends class PlanetEntity.

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

paintVertex:vi:

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

Extends class PlanetEntity.

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

planetTextureWithInfo:

- (OOTexture *) planetTextureWithInfo:

(NSDictionary *)

info

Extends class PlanetEntity.

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

scaleVertices

- (void) scaleVertices

Extends class PlanetEntity.

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

setTextureColorForPlanet:inSystem:

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

Extends class PlanetEntity.

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

setUseTexturedModel:

- (void) setUseTexturedModel:

(BOOL)

flag

Extends class PlanetEntity.

Definition at line 102 of file PlanetEntity.m.

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

sqrtZeroDistance

- (double) sqrtZeroDistance

Extends class PlanetEntity.

Definition at line 102 of file PlanetEntity.m.

{
    return sqrt_zero_distance;
}

---

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

• src/Core/Entities/PlanetEntity.m