OOSkyQuadSet Class Reference

Inheritance diagram for OOSkyQuadSet:

Collaboration diagram for OOSkyQuadSet:

Instance Methods
(id)	- initWithQuadsWithTexture:inArray:count:
(void)	- render
(size_t)	- totalSize
(OOTexture *)	- texture
(void)	- dealloc [implementation]
(NSString *)	- description [implementation]

Class Methods
(void)	+ addQuads:count:toArray:

Private Attributes
OOTexture *	_texture
unsigned	_count
GLfloat *	_positions
GLfloat *	_texCoords
GLfloat *	_colors

Detailed Description

Definition at line 76 of file OOSkyDrawable.m.

Method Documentation

addQuads:count:toArray:

+ (void) addQuads:		(OOSkyQuadDesc *)	quads
count:		(unsigned)	count
toArray:		(NSMutableArray *)	ioArray

Definition at line 515 of file OOSkyDrawable.m.

                :(OOSkyQuadDesc *)quads count:(unsigned)count toArray:(NSMutableArray *)ioArray
{
    NSMutableSet            *seenTextures = nil;
    OOTexture               *texture = nil;
    OOSkyQuadSet            *quadSet = nil;
    unsigned                i;
    
    // Iterate over all quads.
    seenTextures = [NSMutableSet set];
    for (i = 0; i != count; ++i)
    {
        texture = quads[i].texture;
        
        // If we haven't seen this quad's texture before...
        if (![seenTextures containsObject:texture])
        {
            [seenTextures addObject:texture];
            
            // ...create a quad set for this texture.
            quadSet = [[self alloc] initWithQuadsWithTexture:texture
                                                     inArray:quads
                                                       count:count];
            if (quadSet != nil)
            {
                [ioArray addObject:quadSet];
                [quadSet release];
            }
        }
    }
}

References count, nil, texture, and OOSkyQuadDesc::texture.

Referenced by OOSkyDrawable(OOPrivate)::addQuads:count:.

Here is the call graph for this function:

Here is the caller graph for this function:

dealloc

- (void) dealloc

implementation

Definition at line 670 of file OOSkyDrawable.m.

{
    [_texture release];
    
    if (_positions != NULL)  free(_positions);
    if (_texCoords != NULL)  free(_texCoords);
    if (_colors != NULL)  free(_colors);
    
    [super dealloc];
}

References _colors, _positions, _texCoords, dealloc, and OOTexture::release.

Referenced by dealloc.

Here is the call graph for this function:

Here is the caller graph for this function:

description

- (NSString *) description

implementation

Definition at line 682 of file OOSkyDrawable.m.

{
    return [NSString stringWithFormat:@"<%@ %p>{%u quads, texture: %@}", [self class], self, _count, _texture];
}

References description.

Referenced by description.

Here is the call graph for this function:

Here is the caller graph for this function:

initWithQuadsWithTexture:inArray:count:

- (id) initWithQuadsWithTexture:		(OOTexture *)	texture
inArray:		(OOSkyQuadDesc *)	array
count:		(unsigned)	totalCount

Definition at line 547 of file OOSkyDrawable.m.

                              :(OOTexture *)texture inArray:(OOSkyQuadDesc *)array count:(unsigned)totalCount
{
    BOOL                    OK = YES;
    unsigned                i, j, vertexCount;
    GLfloat                 *pos;
    GLfloat                 *tc;
    GLfloat                 *col;
    GLfloat                 r, g, b, x;
    size_t                  posSize, tcSize, colSize;
    unsigned                count = 0;
    int                 skyColorCorrection = [[NSUserDefaults standardUserDefaults] oo_integerForKey:@"sky-color-correction" defaultValue:0];
    
// Hejl / Burgess-Dawson filmic tone mapping
// this algorithm has gamma correction already embedded 
#define SKYCOLOR_TONEMAP_COMPONENT(skyColorComponent) \
do { \
    x = MAX(0.0, skyColorComponent - 0.004); \
    *col++ = (x * (6.2 * x + 0.5)) / (x * (6.2 * x + 1.7) + 0.06); \
} while (0) 
 
    self = [super init];
    if (self == nil)  OK = NO;
    
    if (OK)
    {
        // Count the quads in the array using this texture.
        for (i = 0; i != totalCount; ++i)
        {
            if (array[i].texture == texture)  ++_count;
        }
        if (_count == 0)  OK = NO;
    }
    
    if (OK)
    {
        // Allocate arrays.
        vertexCount = _count * 4;
        posSize = sizeof *_positions * vertexCount * kSkyQuadSetPositionEntriesPerVertex;
        tcSize = sizeof *_texCoords * vertexCount * kSkyQuadSetTexCoordEntriesPerVertex;
        colSize = sizeof *_colors * vertexCount * kSkyQuadSetColorEntriesPerVertex;
        
        _positions = malloc(posSize);
        _texCoords = malloc(tcSize);
        _colors = malloc(colSize);
        
        if (_positions == NULL || _texCoords == NULL || _colors == NULL)  OK = NO;
        
        pos = _positions;
        tc = _texCoords;
        col = _colors;
    }
    
    if (OK)
    {
        // Find the matching quads again, and convert them to renderable representation.
        for (i = 0; i != totalCount; ++i)
        {
            if (array[i].texture == texture)
            {
                r = [array[i].color redComponent];
                g = [array[i].color greenComponent];
                b = [array[i].color blueComponent];
                
                // Loop over vertices
                for (j = 0; j != 4; ++j)
                {
                    *pos++ = array[i].corners[j].x;
                    *pos++ = array[i].corners[j].y;
                    *pos++ = array[i].corners[j].z;
                    
                    // Colour is the same for each vertex
                    if (skyColorCorrection == 0)        // no color correction
                    {
                        *col++ = r;
                        *col++ = g;
                        *col++ = b;
                    }
                    else if (skyColorCorrection == 1)   // gamma correction only
                    {
                        *col++ = pow(r, 1.0/2.2);
                        *col++ = pow(g, 1.0/2.2);
                        *col++ = pow(b, 1.0/2.2);
                    }
                    else                    // gamma correctioin + filmic tone mapping
                    {
                        SKYCOLOR_TONEMAP_COMPONENT(r);
                        SKYCOLOR_TONEMAP_COMPONENT(g);
                        SKYCOLOR_TONEMAP_COMPONENT(b);
                    }
                    *col++ = 1.0f;  // Alpha is unused but needs to be there
                }
                
                // Texture co-ordinates are the same for each quad.
                *tc++ = sMinTexCoord;
                *tc++ = sMinTexCoord;
                
                *tc++ = sMaxTexCoord;
                *tc++ = sMinTexCoord;
                
                *tc++ = sMaxTexCoord;
                *tc++ = sMaxTexCoord;
                
                *tc++ = sMinTexCoord;
                *tc++ = sMaxTexCoord;
                
                count++;
            }
        }
        
        _texture = [texture retain];
        OOLog(@"sky.setup", @"Generated quadset with %u quads for texture %@", count, _texture);
    }
    
    if (!OK)
    {
        [self release];
        self = nil;
    }
    
    return self;
}

References _colors, _count, _positions, _texCoords, _texture, OOSkyQuadDesc::corners, count, kSkyQuadSetColorEntriesPerVertex, kSkyQuadSetPositionEntriesPerVertex, kSkyQuadSetTexCoordEntriesPerVertex, nil, OOLog, OOTexture::retain, SKYCOLOR_TONEMAP_COMPONENT, sMaxTexCoord, sMinTexCoord, texture, and x.

Here is the call graph for this function:

render

- (void) render

Definition at line 688 of file OOSkyDrawable.m.

{
    OO_ENTER_OPENGL();
    
    [_texture apply];
    
    OOGL(glVertexPointer(kSkyQuadSetPositionEntriesPerVertex, GL_FLOAT, 0, _positions));
    OOGL(glTexCoordPointer(kSkyQuadSetTexCoordEntriesPerVertex, GL_FLOAT, 0, _texCoords));
    OOGL(glColorPointer(kSkyQuadSetColorEntriesPerVertex, GL_FLOAT, 0, _colors));
    
    OOGL(glDrawArrays(GL_QUADS, 0, 4 * _count));
}

References _colors, _count, _positions, _texCoords, OOTexture::apply, kSkyQuadSetColorEntriesPerVertex, kSkyQuadSetPositionEntriesPerVertex, kSkyQuadSetTexCoordEntriesPerVertex, OO_ENTER_OPENGL, OOGL, and render.

Referenced by render.

Here is the call graph for this function:

Here is the caller graph for this function:

texture

- (OOTexture *) texture

Definition at line 709 of file OOSkyDrawable.m.

{
    return _texture;
}

References _texture, and texture.

Referenced by addQuads:count:toArray:, OOSkyDrawable::allTextures, initWithQuadsWithTexture:inArray:count:, and texture.

Here is the call graph for this function:

Here is the caller graph for this function:

totalSize

- (size_t) totalSize

Definition at line 703 of file OOSkyDrawable.m.

{
    return [self oo_objectSize] + _count * 4 * (sizeof *_positions + sizeof *_texCoords + sizeof *_colors);
}

References _colors, _count, _positions, _texCoords, and totalSize.

Referenced by OOSkyDrawable::totalSize, and totalSize.

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

_colors

- (GLfloat*) _colors

private

Definition at line 83 of file OOSkyDrawable.m.

Referenced by dealloc, initWithQuadsWithTexture:inArray:count:, render, and totalSize.

_count

- (unsigned) _count

private

Definition at line 80 of file OOSkyDrawable.m.

Referenced by initWithQuadsWithTexture:inArray:count:, render, and totalSize.

_positions

- (GLfloat*) _positions

private

Definition at line 81 of file OOSkyDrawable.m.

Referenced by dealloc, initWithQuadsWithTexture:inArray:count:, render, and totalSize.

_texCoords

- (GLfloat*) _texCoords

private

Definition at line 82 of file OOSkyDrawable.m.

Referenced by dealloc, initWithQuadsWithTexture:inArray:count:, render, and totalSize.

_texture

- (OOTexture*) _texture

private

Definition at line 79 of file OOSkyDrawable.m.

Referenced by initWithQuadsWithTexture:inArray:count:, and texture.

---

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

• src/Core/OOSkyDrawable.m