Cocos2D drawing a custom filled polygon

#import <Foundation/Foundation.h>
#import "cocos2d.h"
 
@interface PolygonNode : CCNode 
 
// Store the number of points in the polygon
@property (nonatomic, readwrite) int numberOfPoints;
 
@property (nonatomic, readwrite) ccVertex2F * glPoints ;
 
// The stroke color
@property (nonatomic, readwrite) ccColor4B strokeColor;
 
// The fill color
@property (nonatomic, readwrite) ccColor4B fillColor;
 
// If a stroke should be drawn
@property (nonatomic, readwrite) BOOL stroke;
 
// If the polygon should be filled
@property (nonatomic, readwrite) BOOL fill;
 
// Whether to close the polygon
@property (nonatomic, readwrite) BOOL closed;
 
// Standard constructor
+(id) newPolygonNode: (NSMutableArray *) newPoints;
 
// Draw the polygon node as a rectangle
+(id) newPolygonNodeAsRectangle: (int) width: (int) height;
 
// Set the points using a NSMutableArray
-(void) setupPoints: (NSMutableArray*) points;
 
@end

#import "PolygonNode.h"
 
@implementation PolygonNode
 
@synthesize strokeColor;
@synthesize fillColor;
@synthesize glPoints;
@synthesize numberOfPoints;
 
@synthesize stroke;
@synthesize fill;
@synthesize closed;
 
// Initialise the object. Allocate the array of points and set the default values.
// by default this will draw a closed white polygon with a red border
-(id) init {
	if( (self=[super init]) ) {
		//points = [[NSMutableArray alloc] initWithObjects: nil];
 
        closed = YES;
        fill = YES;
        stroke = YES;
 
        self.strokeColor = ccc4(255, 0, 0, 255);
        self.fillColor = ccc4(255, 255, 255, 255);
	}
	return self;
}
 
// Override the node draw method. Call the ccDrawPoly method
// to perform the OpenGL draw operation
-(void) draw {
	[super draw];
    [self ccDrawPoly];
}
 
// Draw the polygon using OpenGL
-(void) ccDrawPoly  {
 
    // Disable textures - we want to draw with plaine colors
    glDisableClientState(GL_COLOR_ARRAY);
	glDisableClientState(GL_TEXTURE_COORD_ARRAY);
	glDisable(GL_TEXTURE_2D);
 
    // Setup the vertex pointer. This puts gives OpenGL access
    // to our array of points
    glVertexPointer(2, GL_FLOAT, 0, self.glPoints);
 
    if(fill) {
        // Set the OpenGL color
        glColor4ub(fillColor.r, fillColor.g, fillColor.b, fillColor.a);
 
        // Draw the polygon
        if(closed)
            glDrawArrays(GL_TRIANGLE_FAN, 0, numberOfPoints);
        else
            glDrawArrays(GL_TRIANGLE_STRIP, 0, numberOfPoints);
    }
    if(stroke) {
        glColor4f(strokeColor.r, strokeColor.g, strokeColor.b, strokeColor.a);
        if(closed)
            glDrawArrays(GL_LINE_LOOP, 0, (GLsizei) numberOfPoints);
        else
            glDrawArrays(GL_LINE_STRIP, 0, (GLsizei) numberOfPoints);
    }
 
 
	// restore default state
	glEnableClientState(GL_COLOR_ARRAY);
	glEnableClientState(GL_TEXTURE_COORD_ARRAY);
	glEnable(GL_TEXTURE_2D);	
 
}
 
// Constructor to create a polygon from an NSMutableArray of points
+(id) newPolygonNode: (NSMutableArray *) newPoints {
	return [[self alloc] initPolygonNode: newPoints] ;
}
 
// Set polygon as rectangle
+ (id) newPolygonNodeAsRectangle:(int)width withHeight:(int)height {
    NSMutableArray * pts = [[NSMutableArray alloc] initWithObjects:Nil];
 
    [pts addObject:[NSValue valueWithCGPoint:ccp(0,0)]];
    [pts addObject:[NSValue valueWithCGPoint:ccp(width,0)]];
    [pts addObject:[NSValue valueWithCGPoint:ccp(width,height)]];
    [pts addObject:[NSValue valueWithCGPoint:ccp(0,height)]];
 
    return [[self alloc] initPolygonNode: pts];
}
 
-(id) initPolygonNode: (NSMutableArray *) points {
	if((self = [self init] )) {
        [self setupPoints:points];
	}
	return self;
}
 
// Convert a NSMutableArray into an array of ccVertex2F which can
// be understood by OpenGL
-(void) setupPoints: (NSMutableArray*) points {
    self.numberOfPoints = [points count];
 
    ccVertex2F *newPoint = malloc(numberOfPoints * sizeof(ccVertex2F));
    if (newPoint == NULL) {
        // Handle error
    }
 
	// iPhone and 32-bit machines
    if( sizeof(CGPoint) == sizeof(ccVertex2F) ) {
		for(NSUInteger i=0; i<numberOfPoints; i++) {
			NSValue *val = [points objectAtIndex:i];
			CGPoint pt = [val CGPointValue];
			newPoint[i] = (ccVertex2F) { pt.x * CC_CONTENT_SCALE_FACTOR(), pt.y * CC_CONTENT_SCALE_FACTOR() };
		}
 	} else {
		// 64-bit machines (Mac)
 
		for(NSUInteger i=0; i<numberOfPoints; i++) {
			NSValue *val = [points objectAtIndex:i];
			CGPoint pt = [val CGPointValue];
			newPoint[i] = (ccVertex2F) { pt.x, pt.y };
		}
	}
 
    self.glPoints = newPoint;
}
 
-(void) dealloc {
    free(self.glPoints);
	[super dealloc];
}
@end

        // Create an array of CGPoints 
		CGPoint points[] = {ccp(0,0), ccp(100,0), ccp(100,100), ccp(50, 150), ccp(0,100)};
		// Create a new mutable array
        NSMutableArray * result = [[NSMutableArray alloc] initWithObjects: nil];
 
        // Add the points to the mutable array using a NSValue wrapper
		for(int i=0; i<(sizeof(points)/sizeof(CGPoint)); i++) {
			NSValue* point = [NSValue valueWithCGPoint:points[i]];
			[result addObject:point];
		}
 
        // Create the polygon
		poly = [PolygonNode newPolygonNode: result];
 
        // Set the fill color
        poly.fillColor = ccc4(0, 255, 100, 255);
 
        // Add the polygon to the scene
		[self addChild:poly];