OOPolygonSprite.m File Reference

import "OOPolygonSprite.h"
import "OOCollectionExtractors.h"
import "OOMacroOpenGL.h"
import "OOMaths.h"
import "OOPointMaths.h"
import "OOGraphicsResetManager.h"
import "ResourceManager.h"
import "legacy_random.h"

Include dependency graph for OOPolygonSprite.m:

Go to the source code of this file.

Classes
category	OOPolygonSprite(Private)
struct	TessPolygonData

Macros
#define	APIENTRY
#define	kCosMitreLimit   0.866f

Typedefs
typedef GLvoid(*	TessFuncPtr) ()

Functions
static NSArray *	DataArrayToPoints (TessPolygonData *data, NSArray *dataArray)
static NSArray *	BuildOutlineContour (NSArray *dataArray, GLfloat width, BOOL inner)
static void	SubmitVertices (GLUtesselator *tesselator, TessPolygonData *polygonData, NSArray *contour)
static BOOL	GrowTessPolygonData (TessPolygonData *data, size_t capacityHint)
static BOOL	AppendVertex (TessPolygonData *data, NSPoint vertex)
static void	SVGDumpBegin (TessPolygonData *data)
static void	SVGDumpEnd (TessPolygonData *data)
static void	SVGDumpBeginGroup (TessPolygonData *data, NSString *name)
static void	SVGDumpEndGroup (TessPolygonData *data)
static void	SVGDumpAppendBaseContour (TessPolygonData *data, NSArray *points)
static void	SVGDumpBeginPrimitive (TessPolygonData *data)
static void	SVGDumpEndPrimitive (TessPolygonData *data)
static void	SVGDumpAppendTriangle (TessPolygonData *data, NSPoint v0, NSPoint v1, NSPoint v2)
static void APIENTRY	TessBeginCallback (GLenum type, void *polygonData)
static void APIENTRY	TessVertexCallback (void *vertexData, void *polygonData)
static void APIENTRY	TessCombineCallback (GLdouble coords[3], void *vertexData[4], GLfloat weight[4], void **outData, void *polygonData)
static void APIENTRY	TessEndCallback (void *polygonData)
static void APIENTRY	ErrorCallback (GLenum error, void *polygonData)

Macro Definition Documentation

APIENTRY

#define APIENTRY

Definition at line 51 of file OOPolygonSprite.m.

kCosMitreLimit

#define kCosMitreLimit   0.866f

Definition at line 55 of file OOPolygonSprite.m.

Referenced by BuildOutlineContour().

Typedef Documentation

TessFuncPtr

typedef GLvoid(* TessFuncPtr) ()

Definition at line 119 of file OOPolygonSprite.m.

Function Documentation

AppendVertex()

static BOOL AppendVertex ( TessPolygonData * data, NSPoint vertex )

static

Definition at line 647 of file OOPolygonSprite.m.

{
    NSCParameterAssert(data != NULL);
    
    if (data->capacity == data->count && !GrowTessPolygonData(data, data->capacity * 2))  return NO;
    
    data->data[data->count * 2] = vertex.x;
    data->data[data->count * 2 + 1] = vertex.y;
    data->count++;
    return YES;
}

References TessPolygonData::capacity, TessPolygonData::count, TessPolygonData::data, and GrowTessPolygonData().

Referenced by TessVertexCallback().

Here is the call graph for this function:

Here is the caller graph for this function:

BuildOutlineContour()

static NSArray * BuildOutlineContour ( NSArray * dataArray, GLfloat width, BOOL inner )

static

Definition at line 511 of file OOPolygonSprite.m.

{
    NSUInteger i, count = [dataArray count];
    if (count < 2)  return dataArray;
    
    /*
        Generate inner or outer boundary for a contour, offset by the specified
        width inwards/outwards from the line. At anticlockwise (convex) corners
        sharper than acos(kCosMitreLimit), the corner is mitred, i.e. an
        additional line segment is generated so the outline doesn't protrude
        arbitratrily far.
        
        Overview of the maths:
        For each vertex, we consider a normalized vector A from the previous
        vertex and a normalized vector B to the next vertex. (These are always
        defined since the polygons are closed.)
        
        The dot product of A and B is the cosine of the angle, which we compare
        to kCosMitreLimit to determine mitreing. If the dot product is exactly
        1, the vectors are antiparallel and we have a cap; the mitreing case
        handles this implicitly. (The non-mitreing case would result in a
        divide-by-zero.)
        
        Non-mitreing case:
            To position the vertex, we need a vector N normal to the corner.
            We observe that A + B is tangent to the corner, and a 90 degree
            rotation in 2D is trivial. The offset along this line is
            proportional to the secant of the angle between N and the 90 degree
            rotation of A (or B; the angle is by definition the same), or
            width / (N dot rA).
            Since both N and rA are rotated by ninety degrees in the same
            direction, we can cut out both rotations (i.e., using the tangent
            and A) and get the same result.
            
        Mitreing case:
            The two new vertices are the original vertex offset by scale along
            the ninety-degree rotation of A and B respectively.
    */
    
    NSPoint prev, current, next;
    if (inner)
    {
        prev = [[dataArray objectAtIndex:0] pointValue];
        current = [[dataArray objectAtIndex:count -1] pointValue];
        next = [[dataArray objectAtIndex:count - 2] pointValue];    
    }
    else
    {
        prev = [[dataArray objectAtIndex:count - 1] pointValue];
        current = [[dataArray objectAtIndex:0] pointValue];
        next = [[dataArray objectAtIndex:1] pointValue];
    }
    
    NSMutableArray *result = [NSMutableArray arrayWithCapacity:count];
    
    for (i = 0; i < count; i++)
    {
        NSPoint a = PtNormal(PtSub(current, prev));
        NSPoint b = PtNormal(PtSub(next, current));
        
        CGFloat dot = PtDot(a, b);
        BOOL clockwise = PtCross(a, b) < 0.0f;
        
        if (-dot < kCosMitreLimit || !clockwise)
        {
            // Non-mitreing case.
            NSPoint t = PtNormal(PtAdd(a, b));
            NSPoint v = PtScale(PtRotACW(t), width / PtDot(t, a));
            
            if (!isnan(v.x) && !isnan(v.y))
            {
                [result addObject:[NSValue valueWithPoint:PtAdd(v, current)]];
            }
        }
        else
        {
            // Mitreing case.
            NSPoint v1 = PtScale(PtAdd(PtRotACW(a), a), width);
            NSPoint v2 = PtScale(PtSub(PtRotACW(b), b), width);
            
            if (!isnan(v1.x) && !isnan(v1.y))
            {
                [result addObject:[NSValue valueWithPoint:PtAdd(v1, current)]];
            }
            if (!isnan(v2.x) && !isnan(v2.y))
            {
                [result addObject:[NSValue valueWithPoint:PtAdd(v2, current)]];
            }
        }
        
        prev = current;
        current = next;
        
        if (inner)
        {
            next = [[dataArray objectAtIndex:(count * 2 - 3 - i) % count] pointValue];
        }
        else
        {
            next = [[dataArray objectAtIndex:(i + 2) % count] pointValue];
        }
    }
    
    return result;
}

References count, kCosMitreLimit, PtAdd(), PtCross(), PtDot(), PtNormal(), PtRotACW(), PtScale(), and PtSub().

Here is the call graph for this function:

DataArrayToPoints()

static NSArray * DataArrayToPoints ( TessPolygonData * data, NSArray * dataArray )

static

Definition at line 442 of file OOPolygonSprite.m.

{
    /*  This converts an icon definition in the form of an array of array of
        numbers to internal data in the form of an array of arrays of NSValues
        containing NSPoint data. In addition to repacking the data, it performs
        the following data processing:
          * Sequences of duplicate vertices are removed (including across the
            beginning and end, in case of manually closed contours).
          * Vertices containing nans or infinities are skipped, Just In Case.
          * The signed area of each contour is calculated; if it is negative,
            the contour is clockwise, and we need to flip it.
    */
    
    SVGDumpBeginGroup(data, @"Base contours");
    
    NSUInteger polyIter, polyCount = [dataArray count];
    NSArray *subArrays[polyCount];
    
    for (polyIter = 0; polyIter < polyCount; polyIter++)
    {
        NSArray *polyDef = [dataArray objectAtIndex:polyIter];
        NSUInteger vertIter, vertCount = [polyDef count] / 2;
        NSMutableArray *newPolyDef = [NSMutableArray arrayWithCapacity:vertCount];
        CGFloat area = 0;
        
        CGFloat oldX = [polyDef oo_doubleAtIndex:(vertCount -1) * 2];
        CGFloat oldY = [polyDef oo_doubleAtIndex:(vertCount -1) * 2 + 1];
        
        for (vertIter = 0; vertIter < vertCount; vertIter++)
        {
            CGFloat x = [polyDef oo_doubleAtIndex:vertIter * 2];
            CGFloat y = [polyDef oo_doubleAtIndex:vertIter * 2 + 1];
            
            // Skip bad or duplicate vertices.
            if (x == oldX && y == oldY)  continue;
            if (isnan(x) || isnan(y))  continue;
            if (!isfinite(x) || !isfinite(y))  continue;
            
            area += x * oldY - oldX * y;
            
            oldX = x;
            oldY = y;
            
            [newPolyDef addObject:[NSValue valueWithPoint:NSMakePoint(x, y)]];
        }
        
        // Eliminate duplicates at ends - the initialization of oldX and oldY will catch one pair, but not extra-silly cases.
        while ([newPolyDef count] > 1 && [[newPolyDef objectAtIndex:0] isEqual:[newPolyDef lastObject]])
        {
            [newPolyDef removeLastObject];
        }
        
        if (area >= 0)
        {
            subArrays[polyIter] = newPolyDef;
        }
        else
        {
            subArrays[polyIter] = [[newPolyDef reverseObjectEnumerator] allObjects];
        }
        
        SVGDumpAppendBaseContour(data, subArrays[polyIter]);
    }
    
    SVGDumpEndGroup(data);
    return [NSArray arrayWithObjects:subArrays count:polyCount];
}

References count, SVGDumpAppendBaseContour(), SVGDumpBeginGroup(), SVGDumpEndGroup(), x, and y.

Here is the call graph for this function:

ErrorCallback()

static void APIENTRY ErrorCallback ( GLenum error, void * polygonData )

static

Definition at line 780 of file OOPolygonSprite.m.

{
    TessPolygonData *data = polygonData;
    NSCParameterAssert(data != NULL);
    
    NSString *name = @"";
#ifndef NDEBUG
    name = [NSString stringWithFormat:@" \"%@\"", data->name];
#endif
    
    char *errStr = (char *)gluErrorString(error);
    
    OOLog(@"polygonSprite.tesselate.error", @"Error %s (%u) while tesselating polygon%@.", errStr, error, name);
    data->OK = NO;
}

References TessPolygonData::OK, and OOLog.

GrowTessPolygonData()

static BOOL GrowTessPolygonData ( TessPolygonData * data, size_t capacityHint )

static

Definition at line 618 of file OOPolygonSprite.m.

{
    NSCParameterAssert(data != NULL);
    
    size_t minCapacity = data->capacity + 1;
    size_t desiredCapacity = MAX(capacityHint, minCapacity);
    size_t newCapacity = 0;
    GLfloat *newData = realloc(data->data, desiredCapacity * sizeof (GLfloat) * 2);
    if (newData != NULL)
    {
        newCapacity = desiredCapacity;
    }
    else
    {
        desiredCapacity = minCapacity;
        newData = realloc(data->data, desiredCapacity * sizeof (GLfloat) * 2);
        if (newData != NULL)  newCapacity = desiredCapacity;
    }
    
    if (newData == NULL)  return NO;
    
    NSCAssert(newCapacity > data->capacity, @"Buffer regrow logic error");
    
    data->data = newData;
    data->capacity = newCapacity;
    return YES;
}

References TessPolygonData::capacity, TessPolygonData::data, and MAX.

Referenced by AppendVertex().

Here is the caller graph for this function:

SubmitVertices()

static void SubmitVertices ( GLUtesselator * tesselator, TessPolygonData * polygonData, NSArray * contour )

static

Definition at line 421 of file OOPolygonSprite.m.

{
    NSUInteger vertexCount = [contour count], vertexIndex;
    if (vertexCount > 2)
    {
        gluTessBeginContour(tesselator);
        
        for (vertexIndex = 0; vertexIndex < vertexCount && polygonData->OK; vertexIndex++)
        {
            NSValue *pointValue = [contour objectAtIndex:vertexIndex];
            NSPoint p = [pointValue pointValue];
            GLdouble vert[3] = { p.x, p.y, 0.0 };
            
            gluTessVertex(tesselator, vert, pointValue);
        }
        
        gluTessEndContour(tesselator);
    }
}

References TessPolygonData::OK.

SVGDumpAppendBaseContour()

static void SVGDumpAppendBaseContour ( TessPolygonData * data, NSArray * points )

static

Definition at line 838 of file OOPolygonSprite.m.

{
    if (data->debugSVG == nil)  return;
    
    NSString *groupName = [NSString stringWithFormat:@"contour %u", data->svgID++];
    [data->debugSVG appendFormat:@"\t\t<g id=\"%@\" stroke=\"#BBB\" fill=\"none\">\n\t\t<path stroke-width=\"0.05\" d=\"", groupName];
    
    NSUInteger i, count = [points count];
    for (i = 0; i < count; i++)
    {
        NSPoint p = [[points objectAtIndex:i] pointValue];
        [data->debugSVG appendFormat:@"%c %f %f ", (i == 0) ? 'M' : 'L', p.x, -p.y];
    }
    
    // Close and add a circle at the first vertex. (SVG has support for end markers, but this isn’t reliable across implementations.)
    NSPoint p = [[points objectAtIndex:0] pointValue];
    [data->debugSVG appendFormat:@"z\"/>\n\t\t\t<circle cx=\"%f\" cy=\"%f\" r=\"0.1\" fill=\"#BBB\" stroke=\"none\"/>\n\t\t</g>\n", p.x, -p.y];
}

References count, TessPolygonData::debugSVG, and nil.

Referenced by DataArrayToPoints().

Here is the caller graph for this function:

SVGDumpAppendTriangle()

static void SVGDumpAppendTriangle ( TessPolygonData * data, NSPoint v0, NSPoint v1, NSPoint v2 )

static

Definition at line 901 of file OOPolygonSprite.m.

{
    if (data->debugSVG == nil)  return;
    [data->debugSVG appendFormat:@"\t\t\t<path d=\"M %f %f L %f %f L %f %f z\"/>\n", v0.x, -v0.y, v1.x, -v1.y, v2.x, -v2.y];
}

References TessPolygonData::debugSVG, and nil.

Referenced by TessVertexCallback().

Here is the caller graph for this function:

SVGDumpBegin()

static void SVGDumpBegin ( TessPolygonData * data )

static

Definition at line 800 of file OOPolygonSprite.m.

{
    DESTROY(data->debugSVG);
    data->debugSVG = [[NSMutableString alloc] initWithString:
       @"<?xml version=\"1.0\" standalone=\"no\"?>\n"
        "<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\" \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n"
        "<svg viewBox=\"-5 -5 10 10\" version=\"1.1\" xmlns=\"http://www.w3.org/2000/svg\">\n"
        "\t<desc>Oolite polygon sprite debug dump.</desc>\n"
        "\t\n"
    ];
}

References TessPolygonData::debugSVG, and DESTROY.

SVGDumpBeginGroup()

static void SVGDumpBeginGroup ( TessPolygonData * data, NSString * name )

static

Definition at line 823 of file OOPolygonSprite.m.

{
    if (data->debugSVG == nil)  return;
    
    [data->debugSVG appendFormat:@"\t<g id=\"%@ %u\">\n", name, data->svgID++];
}

References TessPolygonData::debugSVG, and nil.

Referenced by DataArrayToPoints().

Here is the caller graph for this function:

SVGDumpBeginPrimitive()

static void SVGDumpBeginPrimitive ( TessPolygonData * data )

static

Definition at line 858 of file OOPolygonSprite.m.

{
    if (data->debugSVG == nil)  return;
    
    NSString *groupName = @"Unknown primitive";
    switch (data->mode)
    {
        case GL_TRIANGLES:
            groupName = @"Triangle soup";
            break;
            
        case GL_TRIANGLE_FAN:
            groupName = @"Triangle fan";
            break;
            
        case GL_TRIANGLE_STRIP:
            groupName = @"Triangle strip";
            break;
    }
    groupName = [groupName stringByAppendingFormat:@" %u", data->svgID++];
    
    // Pick random colour for the primitive.
    uint8_t red = (Ranrot() & 0x3F) + 0x20;
    uint8_t green = (Ranrot() & 0x3F) + 0x20;
    uint8_t blue = (Ranrot() & 0x3F) + 0x20;
    if (!data->generatingOutline)
    {
        red += 0x80;
        green += 0x80;
        blue += 0x80;
    }
    
    [data->debugSVG appendFormat:@"\t\t<g id=\"%@\" fill=\"#%2X%2X%2X\" fill-opacity=\"0.3\" stroke=\"%@\" stroke-width=\"0.01\">\n", groupName, red, green, blue, data->generatingOutline ? @"#060" : @"#008"];
}

References TessPolygonData::debugSVG, TessPolygonData::generatingOutline, TessPolygonData::mode, nil, and Ranrot().

Referenced by TessBeginCallback().

Here is the call graph for this function:

Here is the caller graph for this function:

SVGDumpEnd()

static void SVGDumpEnd ( TessPolygonData * data )

static

Definition at line 813 of file OOPolygonSprite.m.

{
    if (data->debugSVG == nil)  return;
    
    [data->debugSVG appendString:@"</svg>\n"];
    [ResourceManager writeDiagnosticString:data->debugSVG toFileNamed:[NSString stringWithFormat:@"Polygon Sprites/%@.svg", data->name]];
    DESTROY(data->debugSVG);
}

References TessPolygonData::debugSVG, DESTROY, nil, and ResourceManager::writeDiagnosticString:toFileNamed:.

Here is the call graph for this function:

SVGDumpEndGroup()

static void SVGDumpEndGroup ( TessPolygonData * data )

static

Definition at line 831 of file OOPolygonSprite.m.

{
    if (data->debugSVG == nil)  return;
    [data->debugSVG appendString:@"\t</g>\n"];  
}

References TessPolygonData::debugSVG, and nil.

Referenced by DataArrayToPoints().

Here is the caller graph for this function:

SVGDumpEndPrimitive()

static void SVGDumpEndPrimitive ( TessPolygonData * data )

static

Definition at line 894 of file OOPolygonSprite.m.

{
    if (data->debugSVG == nil)  return;
    [data->debugSVG appendString:@"\t\t</g>\n"];
}

References TessPolygonData::debugSVG, and nil.

Referenced by TessEndCallback().

Here is the caller graph for this function:

TessBeginCallback()

static void APIENTRY TessBeginCallback ( GLenum type, void * polygonData )

static

Definition at line 660 of file OOPolygonSprite.m.

{
    TessPolygonData *data = polygonData;
    NSCParameterAssert(data != NULL);
    
    data->mode = type;
    data->vCount = 0;
    
    SVGDumpBeginPrimitive(data);
}

References TessPolygonData::mode, SVGDumpBeginPrimitive(), and TessPolygonData::vCount.

Here is the call graph for this function:

TessCombineCallback()

static void APIENTRY TessCombineCallback ( GLdouble coords[3], void * vertexData[4], GLfloat weight[4], void ** outData, void * polygonData )

static

Definition at line 761 of file OOPolygonSprite.m.

{
    NSPoint point = { coords[0], coords[1] };
    *outData = [NSValue valueWithPoint:point];
}

TessEndCallback()

static void APIENTRY TessEndCallback ( void * polygonData )

static

Definition at line 768 of file OOPolygonSprite.m.

{
    TessPolygonData *data = polygonData;
    NSCParameterAssert(data != NULL);
    
    data->mode = 0;
    data->vCount = 0;
    
    SVGDumpEndPrimitive(data);
}

References TessPolygonData::mode, SVGDumpEndPrimitive(), and TessPolygonData::vCount.

Here is the call graph for this function:

TessVertexCallback()

static void APIENTRY TessVertexCallback ( void * vertexData, void * polygonData )

static

Definition at line 672 of file OOPolygonSprite.m.

{
    TessPolygonData *data = polygonData;
    NSValue *vertValue = vertexData;
    NSCParameterAssert(vertValue != NULL && data != NULL);
    if (!data->OK)  return;
    
    NSPoint p = [vertValue pointValue];
    NSPoint vertex = { p.x, p.y };
    size_t vCount = data->vCount++;
    
    switch (data->mode)
    {
        case GL_TRIANGLES:
            data->OK = AppendVertex(data, vertex);
#ifndef NDEBUG
            switch (vCount % 3)
            {
                case 0:
                    data->pending0 = vertex;
                    break;
                    
                case 1:
                    data->pending1 = vertex;
                    break;
                    
                case 2:
                    SVGDumpAppendTriangle(data, data->pending0, data->pending1, vertex);
            }
#endif
            break;
            
        case GL_TRIANGLE_FAN:
            if (vCount == 0)  data->pending0 = vertex;
            else if (vCount == 1)  data->pending1 = vertex;
            else
            {
                data->OK = AppendVertex(data, data->pending0) &&
                           AppendVertex(data, data->pending1) &&
                           AppendVertex(data, vertex);
                SVGDumpAppendTriangle(data, data->pending0, data->pending1, vertex);
                data->pending1 = vertex;
            }
            break;
            
        case GL_TRIANGLE_STRIP:
            if (vCount == 0)  data->pending0 = vertex;
            else if (vCount == 1)  data->pending1 = vertex;
            else
            {
                /*  In order to produce consistent winding, the vertex->triangle
                    order for GL_TRIANGLE_STRIP is:
                    0, 1, 2
                    2, 1, 3
                    2, 3, 4
                    4, 3, 5
                    4, 5, 6
                    6, 5, 7
                    6, 7, 8
                    
                    Vertices 0 and 1 are special-cased above, and the first
                    time we get here it's time for the first triangle, which
                    is pending0, pending1, v. v (i.e., vertex 2) then goes into
                    pending0.
                    For the second triangle, the triangle is again pending0,
                    pending1, v, and we then put v (i.e., vertex 3) into
                    pending1.
                    The third triangle follows the same pattern as the first,
                    and the fourthe the same as the second.
                    In other words, after storing each triangle, v goes into
                    pending0 for even vertex indicies, and pending1 for odd
                    vertex indices.
                 */
                data->OK = AppendVertex(data, data->pending0) &&
                           AppendVertex(data, data->pending1) &&
                           AppendVertex(data, vertex);
                SVGDumpAppendTriangle(data, data->pending0, data->pending1, vertex);
                if ((vCount % 2) == 0)  data->pending0 = vertex;
                else  data->pending1 = vertex;
            }
            break;
            
        default:
            OOLog(@"polygonSprite.tesselate.error", @"Unexpected tesselator primitive mode %u.", data->mode);
            data->OK = NO;
    }
}

References AppendVertex(), TessPolygonData::mode, TessPolygonData::OK, OOLog, TessPolygonData::pending0, TessPolygonData::pending1, SVGDumpAppendTriangle(), and TessPolygonData::vCount.

Here is the call graph for this function: