OOSkyDrawable Class Reference

#include <OOSkyDrawable.h>

Inheritance diagram for OOSkyDrawable:

Collaboration diagram for OOSkyDrawable:

Instance Methods
(id)	- initWithColor1:Color2:Color3:Color4:starCount:nebulaCount:nebulaHueFix:clusterFactor:alpha:scale:
(void)	- dealloc [implementation]
(void)	- renderOpaqueParts [implementation]
(BOOL)	- hasOpaqueParts [implementation]
(GLfloat)	- maxDrawDistance [implementation]
(NSSet *)	- allTextures [implementation]
(size_t)	- totalSize [implementation]
(void)	- setUpStarsWithColor1:color2: [implementation]
(void)	- setUpNebulaeWithColor1:color2:clusterFactor:nebulaHueFix:alpha:scale: [implementation]
(void)	- loadStarTextures [implementation]
(void)	- loadNebulaTextures [implementation]
(void)	- addQuads:count: [implementation]
(void)	- ensureTexturesLoaded [implementation]
(void)	- resetGraphicsState [implementation]
Instance Methods inherited from OODrawable
(void)	- renderTranslucentParts
(BOOL)	- hasTranslucentParts
(GLfloat)	- collisionRadius
(BoundingBox)	- boundingBox
(void)	- setBindingTarget:
(void)	- dumpSelfState

Private Attributes
unsigned	_starCount
unsigned	_nebulaCount
NSMutableArray *	_quadSets
GLint	_displayListName

Detailed Description

Definition at line 36 of file OOSkyDrawable.h.

Method Documentation

addQuads:count:

- (void) addQuads: (OOSkyQuadDesc *) quads count: (unsigned) count

implementation

Provided by category OOSkyDrawable(OOPrivate).

Definition at line 83 of file OOSkyDrawable.m.

                :(OOSkyQuadDesc *)quads count:(unsigned)count
{
    if (_quadSets == nil)  _quadSets = [[NSMutableArray alloc] init];
    
    [OOSkyQuadSet addQuads:quads count:count toArray:_quadSets];
}

allTextures

- (NSSet *) allTextures

implementation

Reimplemented from OODrawable.

Definition at line 83 of file OOSkyDrawable.m.

{
    NSMutableSet *result = [NSMutableSet setWithCapacity:[_quadSets count]];
    
    NSEnumerator *quadSetEnum = nil;
    OOSkyQuadSet *quadSet = nil;
    for (quadSetEnum = [_quadSets objectEnumerator]; (quadSet = [quadSetEnum nextObject]); )
    {
        [result addObject:[quadSet texture]];
    }
    
    return result;
}

dealloc

- (void) dealloc

implementation

Definition at line 83 of file OOSkyDrawable.m.

{
    OO_ENTER_OPENGL();
    
    [_quadSets release];
    [[OOGraphicsResetManager sharedManager] unregisterClient:self];
    if (_displayListName != 0)  glDeleteLists(_displayListName, 1);
    
    [super dealloc];
}

ensureTexturesLoaded

- (void) ensureTexturesLoaded

implementation

Provided by category OOSkyDrawable(OOPrivate).

Definition at line 83 of file OOSkyDrawable.m.

{
    [sStarTextures ensureTexturesLoaded];
    [sNebulaTextures ensureTexturesLoaded];
}

hasOpaqueParts

- (BOOL) hasOpaqueParts

implementation

Reimplemented from OODrawable.

Definition at line 83 of file OOSkyDrawable.m.

{
    return YES;
}

initWithColor1:Color2:Color3:Color4:starCount:nebulaCount:nebulaHueFix:clusterFactor:alpha:scale:

- (id) initWithColor1:		(OOColor *)	color1
Color2:		(OOColor *)	color2
Color3:		(OOColor *)	color3
Color4:		(OOColor *)	color4
starCount:		(unsigned)	starCount
nebulaCount:		(unsigned)	nebulaCount
nebulaHueFix:		(BOOL)	nebulaHueFix
clusterFactor:		(float)	nebulaClusterFactor
alpha:		(float)	nebulaAlpha
scale:		(float)	nebulaScale

Definition at line 83 of file OOSkyDrawable.m.

                    :(OOColor *)color1
              Color2:(OOColor *)color2
              Color3:(OOColor *)color3
              Color4:(OOColor *)color4
           starCount:(unsigned)starCount
         nebulaCount:(unsigned)nebulaCount
        nebulaHueFix:(BOOL)nebulaHueFix
       clusterFactor:(float)nebulaClusterFactor
               alpha:(float)nebulaAlpha
               scale:(float)nebulaScale
{
    NSAutoreleasePool       *pool = nil;
    
    if (!sInited)
    {
        sInited = YES;
        if ([[NSUserDefaults standardUserDefaults] boolForKey:@"sky-render-inset-coords"])
        {
            sMinTexCoord += 1.0f/128.0f;
            sMaxTexCoord -= 1.0f/128.0f;
        }
    }
    
    self = [super init];
    if (self == nil)  return nil;
    
    _starCount = starCount;
    _nebulaCount = nebulaCount;
    
    pool = [[NSAutoreleasePool alloc] init];
    [self setUpStarsWithColor1:color1 color2:color2];
    
    if (![UNIVERSE reducedDetail])
    {
        [self setUpNebulaeWithColor1:color3
                              color2:color4
                       clusterFactor:nebulaClusterFactor
                        nebulaHueFix:nebulaHueFix
                               alpha:nebulaAlpha
                               scale:nebulaScale];
    }
    [pool release];
    
    [[OOGraphicsResetManager sharedManager] registerClient:self];
    
    return self;
}

loadNebulaTextures

- (void) loadNebulaTextures

implementation

Provided by category OOSkyDrawable(OOPrivate).

Definition at line 83 of file OOSkyDrawable.m.

{
    if (sNebulaTextures == nil)
    {
        sNebulaTextures = [[OOProbabilisticTextureManager alloc]
                            initWithPListName:@"nebulatextures.plist"
                                      options:kOOTextureDefaultOptions | kOOTextureAlphaMask
                                   anisotropy:0.0f
                                      lodBias:0.0f];
        if (sNebulaTextures == nil)
        {
            [NSException raise:OOLITE_EXCEPTION_DATA_NOT_FOUND format:@"No nebula textures could be loaded."];
        }
    }
    
    [sNebulaTextures setSeed:RANROTGetFullSeed()];
    
}

loadStarTextures

- (void) loadStarTextures

implementation

Provided by category OOSkyDrawable(OOPrivate).

Definition at line 83 of file OOSkyDrawable.m.

{
    if (sStarTextures == nil)
    {
        sStarTextures = [[OOProbabilisticTextureManager alloc]
                            initWithPListName:@"startextures.plist"
                                      options:kOOTextureMinFilterMipMap | kOOTextureMagFilterLinear | kOOTextureAlphaMask
                                   anisotropy:0.0f
                                      lodBias:-0.0f];
        if (sStarTextures == nil)
        {
            [NSException raise:OOLITE_EXCEPTION_DATA_NOT_FOUND format:@"No star textures could be loaded."];
        }
    }
    
    [sStarTextures setSeed:RANROTGetFullSeed()];
    
}

maxDrawDistance

- (GLfloat) maxDrawDistance

implementation

Reimplemented from OODrawable.

Definition at line 83 of file OOSkyDrawable.m.

{
    return INFINITY;
}

renderOpaqueParts

- (void) renderOpaqueParts

implementation

Reimplemented from OODrawable.

Definition at line 83 of file OOSkyDrawable.m.

{
    // While technically translucent, the sky doesn't need to be depth-sorted
    // since it'll be behind everything else anyway.
    
    OO_ENTER_OPENGL();
    OOSetOpenGLState(OPENGL_STATE_ADDITIVE_BLENDING);
    
    OOGL(glDisable(GL_DEPTH_TEST));  // don't read the depth buffer
    OOGL(glEnable(GL_TEXTURE_2D));
    
    // Make stars dim in atmosphere. Note: works OK on night side because sky is dark blue, not black.
    GLfloat fogColor[4] = {0.02, 0.02, 0.02, 1.0};
    OOGL(glFogfv(GL_FOG_COLOR, fogColor));
    
    if (_displayListName != 0)
    {
        OOGL(glCallList(_displayListName));
    }
    else
    {
        // Set up display list
        [self ensureTexturesLoaded];
        _displayListName = glGenLists(1);
        
        OOGL(glNewList(_displayListName, GL_COMPILE));
        
        OOGL(glEnableClientState(GL_TEXTURE_COORD_ARRAY));
        OOGL(glEnableClientState(GL_COLOR_ARRAY));
        
        [_quadSets makeObjectsPerformSelector:@selector(render)];
        
        OOGL(glDisableClientState(GL_TEXTURE_COORD_ARRAY));
        OOGL(glDisableClientState(GL_COLOR_ARRAY));
        
        OOGL(glEndList());
    }
    
    // Restore state
    OOGL(glEnable(GL_DEPTH_TEST));
    OOGL(glDisable(GL_TEXTURE_2D));
    
    // Resetting fog is draw loop's responsibility.
    
    OOVerifyOpenGLState();
    OOCheckOpenGLErrors(@"OOSkyDrawable after rendering");
}

resetGraphicsState

- (void) resetGraphicsState

implementation

Provided by category OOSkyDrawable(OOPrivate).

Definition at line 83 of file OOSkyDrawable.m.

{
    OO_ENTER_OPENGL();
    
    if (_displayListName != 0)
    {
        glDeleteLists(_displayListName, 1);
        _displayListName = 0;
    }
}

setUpNebulaeWithColor1:color2:clusterFactor:nebulaHueFix:alpha:scale:

- (void) setUpNebulaeWithColor1: (OOColor *) color1 color2: (OOColor *) color2 clusterFactor: (float) nebulaClusterFactor nebulaHueFix: (BOOL) nebulaHueFix alpha: (float) nebulaAlpha scale: (float) nebulaScale

implementation

Provided by category OOSkyDrawable(OOPrivate).

Definition at line 83 of file OOSkyDrawable.m.

                              :(OOColor *)color1
                        color2:(OOColor *)color2
                 clusterFactor:(float)nebulaClusterFactor
                  nebulaHueFix:(BOOL)nebulaHueFix
                         alpha:(float)nebulaAlpha
                         scale:(float)nebulaScale
{
    OOSkyQuadDesc       *quads = NULL, *currQuad = NULL;
    unsigned            i, actualCount = 0, clusters = 0;
    OOColor             *color;
    Quaternion          q;
    Vector              vi, vj, vk;
    double              size, r2;
    Vector              middle, offset;
    int                 r1;
    
    [self loadNebulaTextures];
    
    quads = malloc(sizeof *quads * _nebulaCount);
    if (quads == NULL)  return;
    
    currQuad = quads;
    for (i = 0; i < _nebulaCount; ++i)
    {
        color = SaturatedColorInRange(color1, color2, nebulaHueFix);
        
        // Select a direction and rotation.
        q = OORandomQuaternion();
        
        // Create a cluster of nebula quads.
        while ((i < _nebulaCount) && (randf() < nebulaClusterFactor))
        {
            // Select size.
            r1 = 1 + (ranrot_rand() & 15);
            size = nebulaScale * r1 * SKY_ELEMENT_SCALE_FACTOR;
            
            // Calculate centre position and offset to first corner.
            basis_vectors_from_quaternion(q, &vi, &vj, &vk);
            
            // Select colour and texture. Smaller nebula quads are dimmer.
#if DEBUG_COLORS
            currQuad->color = DebugColor(vk);
#else
            currQuad->color = [color colorWithBrightnessFactor:nebulaAlpha * (0.5f + (float)r1 / 32.0f)];
#endif
            currQuad->texture = [sNebulaTextures selectTexture];    // Not retained, since sStarTextures is never released.
            
            middle = vector_multiply_scalar(vk, BILLBOARD_DEPTH);
            offset = vector_multiply_scalar(vector_add(vi, vj), 0.5f * size);
            
            // Rotate vi and vj by a random angle
            r2 = randf() * M_PI * 2.0;
            quaternion_rotate_about_axis(&q, vk, r2);
            vi = vector_right_from_quaternion(q);
            vj = vector_up_from_quaternion(q);
            
            // Scale the "side" vectors.
            vj = vector_multiply_scalar(vj, size);
            vi = vector_multiply_scalar(vi, size);
            
            // Set up corners.
            currQuad->corners[0] = vector_subtract(middle, offset);
            currQuad->corners[1] = vector_add(currQuad->corners[0], vj);
            currQuad->corners[2] = vector_add(currQuad->corners[1], vi);
            currQuad->corners[3] = vector_add(currQuad->corners[0], vi);
            
            // Shuffle direction quat around a bit to spread the cluster out.
            size = NEBULA_SHUFFLE_FACTOR / (nebulaScale * SKY_ELEMENT_SCALE_FACTOR);
            q.x += size * (randf() - 0.5);
            q.y += size * (randf() - 0.5);
            q.z += size * (randf() - 0.5);
            q.w += size * (randf() - 0.5);
            quaternion_normalize(&q);
            
            ++i;
            ++currQuad;
            ++actualCount;
        }
        ++clusters;
    }
    
    /*  The above code generates less than _nebulaCount quads, because i is
        incremented once in the outer loop as well as in the inner loop. To
        keep skies looking the same, we leave the bug in and fill in the
        actual generated count here.
    */
    _nebulaCount = actualCount;
    
    [self addQuads:quads count:_nebulaCount];
    free(quads);
}

setUpStarsWithColor1:color2:

- (void) setUpStarsWithColor1: (OOColor *) color1 color2: (OOColor *) color2

implementation

Provided by category OOSkyDrawable(OOPrivate).

Definition at line 83 of file OOSkyDrawable.m.

                            :(OOColor *)color1 color2:(OOColor *)color2
{
    OOSkyQuadDesc       *quads = NULL, *currQuad = NULL;
    unsigned            i;
    Quaternion          q;
    Vector              vi, vj, vk;
    float               size;
    Vector              middle, offset;
    
    [self loadStarTextures];
    
    quads = malloc(sizeof *quads * _starCount);
    if (quads == NULL)  return;
    
    currQuad = quads;
    for (i = 0; i != _starCount; ++i)
    {
        // Select a direction and rotation.
        q = OORandomQuaternion();
        basis_vectors_from_quaternion(q, &vi, &vj, &vk);
        
        // Select colour and texture.
#if DEBUG_COLORS
        currQuad->color = DebugColor(vk);
#else
        currQuad->color = [color1 blendedColorWithFraction:randf() ofColor:color2];
#endif
        currQuad->texture = [sStarTextures selectTexture];  // Not retained, since sStarTextures is never released.
        
        // Select scale; calculate centre position and offset to first corner.
        size = (1 + (ranrot_rand() % 6)) * SKY_ELEMENT_SCALE_FACTOR;
        middle = vector_multiply_scalar(vk, BILLBOARD_DEPTH);
        offset = vector_multiply_scalar(vector_add(vi, vj), 0.5f * size);
        
        // Scale the "side" vectors.
        Vector vj2 = vector_multiply_scalar(vj, size);
        Vector vi2 = vector_multiply_scalar(vi, size);
        
        // Set up corners.
        currQuad->corners[0] = vector_subtract(middle, offset);
        currQuad->corners[1] = vector_add(currQuad->corners[0], vj2);
        currQuad->corners[2] = vector_add(currQuad->corners[1], vi2);
        currQuad->corners[3] = vector_add(currQuad->corners[0], vi2);
        
        ++currQuad;
    }
    
    [self addQuads:quads count:_starCount];
    free(quads);
}

totalSize

- (size_t) totalSize

implementation

Reimplemented from OODrawable.

Definition at line 83 of file OOSkyDrawable.m.

{
    size_t result = [super totalSize];
    
    NSEnumerator *quadSetEnum = nil;
    OOSkyQuadSet *quadSet = nil;
    for (quadSetEnum = [_quadSets objectEnumerator]; (quadSet = [quadSetEnum nextObject]); )
    {
        result += [quadSet totalSize];
    }
    
    return result;
}

Member Data Documentation

_displayListName

- (GLint) _displayListName

private

Definition at line 44 of file OOSkyDrawable.h.

_nebulaCount

- (unsigned) _nebulaCount

private

Definition at line 40 of file OOSkyDrawable.h.

_quadSets

- (NSMutableArray*) _quadSets

private

Definition at line 42 of file OOSkyDrawable.h.

_starCount

- (unsigned) _starCount

private

Definition at line 39 of file OOSkyDrawable.h.

---

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

• src/Core/OOSkyDrawable.h
• src/Core/OOSkyDrawable.m