OOPolygonSprite Class Reference

#include <OOPolygonSprite.h>

Inheritance diagram for OOPolygonSprite:

Collaboration diagram for OOPolygonSprite:

Instance Methods
(id)	- initWithDataArray:outlineWidth:name:
(void)	- drawFilled
(void)	- drawOutline
(void)	- dealloc [implementation]
(NSString *)	- descriptionComponents [implementation]
(void)	- drawWithData:count:VBO: [implementation]
(void)	- resetGraphicsState [implementation]
(BOOL)	- loadPolygons:outlineWidth: [implementation]
(void)	- oo_drawHUDBeaconIconAt:size:alpha:z: [implementation]

Private Attributes
GLfloat *	_solidData
size_t	_solidCount
GLfloat *	_outlineData
size_t	_outlineCount
NSString *	_name

Detailed Description

Definition at line 37 of file OOPolygonSprite.h.

Method Documentation

dealloc

- (void) dealloc

implementation

Definition at line 78 of file OOPolygonSprite.m.

{
    [[OOGraphicsResetManager sharedManager] unregisterClient:self];
    
#ifndef NDEBUG
    DESTROY(_name);
#endif
    free(_solidData);
    free(_outlineData);
    
    [super dealloc];
}

descriptionComponents

- (NSString *) descriptionComponents

implementation

Definition at line 78 of file OOPolygonSprite.m.

{
    return _name;
}

drawFilled

- (void) drawFilled

Definition at line 78 of file OOPolygonSprite.m.

{
#if !OO_USE_VBO
    GLuint _solidVBO;   // Unusued
#endif
    
    [self drawWithData:_solidData count:_solidCount VBO:&_solidVBO];
}

drawOutline

- (void) drawOutline

Definition at line 78 of file OOPolygonSprite.m.

{
#if !OO_USE_VBO
    GLuint _outlineVBO; // Unusued
#endif
    
    [self drawWithData:_outlineData count:_outlineCount VBO:&_outlineVBO];
}

drawWithData:count:VBO:

- (void) drawWithData: (GLfloat *) data count: (size_t) count VBO: (GLuint *) vbo

implementation

Definition at line 78 of file OOPolygonSprite.m.

                     :(GLfloat *)data count:(size_t)count VBO:(GLuint *)vbo
{
    if (count == 0)  return;
    NSParameterAssert(vbo != NULL && data != NULL);
    
    OO_ENTER_OPENGL();
    OOSetOpenGLState(OPENGL_STATE_OVERLAY);
    
#if OO_USE_VBO
    BOOL useVBO = [[OOOpenGLExtensionManager sharedManager] vboSupported];
    
    if (useVBO)
    {
        if (*vbo == 0)
        {
            OOGL(glGenBuffersARB(1, vbo));
            if (*vbo != 0)
            {
                OOGL(glBindBufferARB(GL_ARRAY_BUFFER, *vbo));
                OOGL(glBufferDataARB(GL_ARRAY_BUFFER, sizeof (GLfloat) * count * 2, data, GL_STATIC_DRAW));
            }
        }
        else
        {
            OOGL(glBindBufferARB(GL_ARRAY_BUFFER, *vbo));
        }
        if (*vbo != 0)  data = NULL;    // Must pass NULL pointer to glVertexPointer to use VBO.
    }
#endif
    
    OOGL(glEnableClientState(GL_VERTEX_ARRAY));
    OOGL(glVertexPointer(2, GL_FLOAT, 0, data));
    OOGL(glDrawArrays(GL_TRIANGLES, 0, count));
    OOGL(glDisableClientState(GL_VERTEX_ARRAY));
    
#if OO_USE_VBO
    if (useVBO)  OOGL(glBindBufferARB(GL_ARRAY_BUFFER, 0));
#endif
    
    OOVerifyOpenGLState();
    OOCheckOpenGLErrors(@"OOPolygonSprite after rendering %@", self);
}

initWithDataArray:outlineWidth:name:

- (id) initWithDataArray:		(NSArray *)	dataArray
outlineWidth:		(GLfloat)	outlineWidth
name:		(NSString *)	name

Definition at line 78 of file OOPolygonSprite.m.

                        :(NSArray *)dataArray outlineWidth:(GLfloat)outlineWidth name:(NSString *)name
{
    if ((self = [super init]))
    {
#ifndef NDEBUG
        _name = [name copy];
#endif
        
        if ([dataArray count] == 0)
        {
            [self release];
            return nil;
        }
        
        // Normalize data to array-of-arrays form.
        if (![[dataArray objectAtIndex:0] isKindOfClass:[NSArray class]])
        {
            dataArray = [NSArray arrayWithObject:dataArray];
        }
        if (![self loadPolygons:dataArray outlineWidth:outlineWidth])
        {
            [self release];
            return nil;
        }
        
        [[OOGraphicsResetManager sharedManager] registerClient:self];
    }
    
    return self;
}

loadPolygons:outlineWidth:

- (BOOL) loadPolygons: (NSArray *) dataArray outlineWidth: (float) outlineWidth

implementation

Provided by category OOPolygonSprite(Private).

Definition at line 78 of file OOPolygonSprite.m.

                     :(NSArray *)dataArray outlineWidth:(float)outlineWidth
{
    NSParameterAssert(dataArray != nil);
    
    NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
    GLUtesselator *tesselator = NULL;
    
    TessPolygonData polygonData;
    memset(&polygonData, 0, sizeof polygonData);
    polygonData.OK = YES;
#ifndef NDEBUG
    polygonData.name = _name;
    if ([[NSUserDefaults standardUserDefaults] boolForKey:@"polygon-sprite-dump-svg"])  SVGDumpBegin(&polygonData);
#endif
    
    // For efficiency, grow to more than big enough for most cases to avoid regrowing.
    if (!GrowTessPolygonData(&polygonData, 100))
    {
        polygonData.OK = NO;
        goto END;
    }
    
    tesselator = gluNewTess();
    if (tesselator == NULL)
    {
        polygonData.OK = NO;
        goto END;
    }
    
    dataArray = DataArrayToPoints(&polygonData, dataArray);
    
    /*** Tesselate polygon fill ***/
    gluTessCallback(tesselator, GLU_TESS_BEGIN_DATA, (TessFuncPtr)TessBeginCallback);
    gluTessCallback(tesselator, GLU_TESS_VERTEX_DATA, (TessFuncPtr)TessVertexCallback);
    gluTessCallback(tesselator, GLU_TESS_END_DATA, (TessFuncPtr)TessEndCallback);
    gluTessCallback(tesselator, GLU_TESS_ERROR_DATA, (TessFuncPtr)ErrorCallback);
    gluTessCallback(tesselator, GLU_TESS_COMBINE_DATA, (TessFuncPtr)TessCombineCallback);
    
    gluTessBeginPolygon(tesselator, &polygonData);
    SVGDumpBeginGroup(&polygonData, @"Fill");
    
    NSUInteger contourCount = [dataArray count], contourIndex;
    for (contourIndex = 0; contourIndex < contourCount && polygonData.OK; contourIndex++)
    {
        NSArray *contour = [dataArray oo_arrayAtIndex:contourIndex];
        if (contour == nil)
        {
            polygonData.OK = NO;
            break;
        }
        
        SubmitVertices(tesselator, &polygonData, contour);
    }
    
    gluTessEndPolygon(tesselator);
    SVGDumpEndGroup(&polygonData);
    
    if (polygonData.OK)
    {
        _solidCount = polygonData.count;
        
        if (_solidCount != 0)
        {
            _solidData = realloc(polygonData.data, polygonData.count * sizeof (GLfloat) * 2);
            if (_solidData != NULL)  polygonData.data = NULL;   // realloc succeded.
            else
            {
                // Unlikely, but legal: realloc failed to shrink buffer.
                _solidData = polygonData.data;
                if (_solidData == NULL)  polygonData.OK = NO;
            }
        }
        else
        {
            // Empty polygon.
            _solidData = NULL;
        }
    }
    if (!polygonData.OK)  goto END;
    
    /*** Tesselate polygon outline ***/
    gluDeleteTess(tesselator);
    tesselator = gluNewTess();
    if (tesselator == NULL)
    {
        polygonData.OK = NO;
        goto END;
    }
    
    polygonData.count = 0;
    polygonData.capacity = 0;
    if (!GrowTessPolygonData(&polygonData, 100))
    {
        polygonData.OK = NO;
        goto END;
    }
#ifndef NDEBUG
    polygonData.generatingOutline = YES;
#endif
    
    gluTessCallback(tesselator, GLU_TESS_BEGIN_DATA, (TessFuncPtr)TessBeginCallback);
    gluTessCallback(tesselator, GLU_TESS_VERTEX_DATA, (TessFuncPtr)TessVertexCallback);
    gluTessCallback(tesselator, GLU_TESS_END_DATA, (TessFuncPtr)TessEndCallback);
    gluTessCallback(tesselator, GLU_TESS_ERROR_DATA, (TessFuncPtr)ErrorCallback);
    gluTessCallback(tesselator, GLU_TESS_COMBINE_DATA, (TessFuncPtr)TessCombineCallback);
    gluTessProperty(tesselator, GLU_TESS_WINDING_RULE, GLU_TESS_WINDING_POSITIVE);
    
    gluTessBeginPolygon(tesselator, &polygonData);
    SVGDumpBeginGroup(&polygonData, @"Outline");
    
    outlineWidth *= 0.5f; // Half the width in, half the width out.
    contourCount = [dataArray count];
    for (contourIndex = 0; contourIndex < contourCount && polygonData.OK; contourIndex++)
    {
        NSArray *contour = [dataArray oo_arrayAtIndex:contourIndex];
        if (contour == nil)
        {
            polygonData.OK = NO;
            break;
        }
    
        SubmitVertices(tesselator, &polygonData, BuildOutlineContour(contour, outlineWidth, NO));
        SubmitVertices(tesselator, &polygonData, BuildOutlineContour(contour, outlineWidth, YES));
    }
    
    gluTessEndPolygon(tesselator);
    SVGDumpEndGroup(&polygonData);
    
    if (polygonData.OK)
    {
        if (polygonData.count != 0)
        {
            _outlineCount = polygonData.count;
            _outlineData = realloc(polygonData.data, polygonData.count * sizeof (GLfloat) * 2);
            if (_outlineData != NULL)  polygonData.data = NULL; // realloc succeded.
            else
            {
                // Unlikely, but legal: realloc failed to shrink buffer.
                _outlineData = polygonData.data;
                if (_outlineData == NULL)  polygonData.OK = NO;
            }
        }
        else
        {
            // Empty polygon.
            _outlineCount = 0;
            _outlineData = NULL;
        }
    }
    
END:
    SVGDumpEnd(&polygonData);
    free(polygonData.data);
    gluDeleteTess(tesselator);
    [pool release];
#ifndef NDEBUG
    DESTROY(polygonData.debugSVG);
#endif
    return polygonData.OK;
}

oo_drawHUDBeaconIconAt:size:alpha:z:

- (void) oo_drawHUDBeaconIconAt: (NSPoint) where size: (NSSize) size alpha: (GLfloat) alpha z: (GLfloat) z

implementation

Provided by category OOPolygonSprite(OOHUDBeaconIcon).

Definition at line 4384 of file HeadUpDisplay.m.

                               :(NSPoint)where size:(NSSize)size alpha:(GLfloat)alpha z:(GLfloat)z
{
    GLfloat x = where.x - size.width;
    GLfloat y = where.y - 1.5 * size.height;
    
    GLfloat ox = x - size.width * 0.5;
    GLfloat oy = y - size.height * 0.5;
    GLfloat width = size.width * (1.0f / 6.0f);
    GLfloat height = size.height * (1.0f / 6.0f);
    
    OOGLPushModelView();
    OOGLTranslateModelView(make_vector(ox, oy, z));
    OOGLScaleModelView(make_vector(width, height, 1.0f));
    [self drawFilled];
    glColor4f(0.0, 0.0, 0.0, 0.5 * alpha);
    [self drawOutline];
    OOGLPopModelView();
}

resetGraphicsState

- (void) resetGraphicsState

implementation

Definition at line 78 of file OOPolygonSprite.m.

{
#if OO_USE_VBO
    OO_ENTER_OPENGL();
    
    if (_solidVBO != 0)  glDeleteBuffersARB(1, &_solidVBO);
    if (_outlineVBO != 0)  glDeleteBuffersARB(1, &_outlineVBO);
    
    _solidVBO = 0;
    _outlineVBO = 0;
#endif
}

Member Data Documentation

_name

- (NSString*) _name

private

Definition at line 51 of file OOPolygonSprite.h.

_outlineCount

- (size_t) _outlineCount

private

Definition at line 43 of file OOPolygonSprite.h.

_outlineData

- (GLfloat*) _outlineData

private

Definition at line 42 of file OOPolygonSprite.h.

_solidCount

- (size_t) _solidCount

private

Definition at line 41 of file OOPolygonSprite.h.

_solidData

- (GLfloat*) _solidData

private

Definition at line 40 of file OOPolygonSprite.h.

---

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

• src/Core/OOPolygonSprite.h
• src/Core/OOPolygonSprite.m