(root)/iphone/common : 65 : source/GLString.m

 

#import "GLString.h"

#import "gfx.h"

#import "VertexArray.h"

 

#import <OpenGLES/ES2/gl.h>

#import <CoreGraphics/CoreGraphics.h>

 

 

// The following is a NSBezierPath category to allow

// for rounded corners of the border

 

 

 

#pragma mark -

 

@implementation GLQuartzTexture

 

- (id) init

{

        if (!(self = [super init]))

                return nil;

 

        antialias = YES;

        subpixelAA = YES;

        filterTexture = NO;

        

        texturePadding = 1.0;

        requiresUpdate = YES;

 

        return self;

}

 

- (void) finalize

{

        if (texName)

                [GLResourceDisposal disposeOfResourcesWithTypes: texName, GL_TEXTURE, NULL];

 

        [super finalize];

}

 

- (void) deleteTexture

{

        if (texName)

        {

                glDeleteTextures(1, &texName);

                texName = 0;

                requiresUpdate = YES;

                textureSize = CGSizeZero;

        }

}

 

- (void) freeGLResources

{

        [self deleteTexture];

}

 

- (void) updateTextureIfRequired

{

        if (requiresUpdate)

                [self genTexture];

}

 

- (void) bindTexture

{

        if (!texName)

                [self genTexture];

        glBindTexture(GL_TEXTURE_2D, texName);

}

 

- (void) setAntialias:(BOOL)request

{

        antialias = request;

        requiresUpdate = YES;

}

 

- (void) setSubpixelAA:(BOOL)request

{

        subpixelAA = request;

        requiresUpdate = YES;

}

 

- (void) setFilterTexture:(BOOL)request

{

        filterTexture = request;

        requiresUpdate = YES;

}

 

- (void) setMipmapTexture:(BOOL)request

{

        mipmapTexture = request;

        requiresUpdate = YES;

}

 

- (void) setTexturePadding:(double)rad

{

        texturePadding = rad;

        requiresUpdate = YES;

}

 

- (void) doQuartzDrawingInContext: (CGContextRef) context sized: (CGSize) imgSize

{

}

 

- (void) generateTextureSized: (CGSize) texSize; // generates the texture without drawing texture to current context

{               

        CGSize previousSize = textureSize;

        

        int width = texSize.width;

        int height = texSize.height;

 

        void* spriteData = calloc(1, width * height * 4);

        

        

        CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();

        CGContextRef spriteContext = CGBitmapContextCreate(spriteData, width, height, 8, width * 4, colorSpace, kCGImageAlphaPremultipliedLast);

        assert(spriteContext);

        

        UIGraphicsPushContext(spriteContext);

 

        CGContextSetShouldSmoothFonts(spriteContext, subpixelAA);

 

        [self doQuartzDrawingInContext: spriteContext sized: texSize];

 

        UIGraphicsPopContext();

        CGContextRelease(spriteContext);

        CGColorSpaceRelease(colorSpace);

        

        if (!texName)

                glGenTextures(1, &texName);

        glBindTexture(GL_TEXTURE_2D, texName);

 

        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, spriteData);

 

        free(spriteData);

 

        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);

        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

 

        if (mipmapTexture)

                glGenerateMipmap(GL_TEXTURE_2D);

        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filterTexture ? (mipmapTexture ? GL_LINEAR_MIPMAP_LINEAR : GL_LINEAR) : GL_NEAREST);

 

        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filterTexture ? GL_LINEAR : GL_NEAREST);

        

        textureSize = texSize;

        

        requiresUpdate = NO;

}

 

- (CGSize) updatedTextureSize

{

        return CGSizeZero;

}

 

- (void) genTexture

{

        [self generateTextureSized: [self updatedTextureSize]];

}

 

- (CGSize) textureSize

{

        if (requiresUpdate)

                return [self updatedTextureSize];

        else

                return textureSize;

}

 

- (void) drawWithBounds:(CGRect)bounds

{

        [self updateTextureIfRequired];

 

        if ([self texName])

        {

                

                //glDisable (GL_DEPTH_TEST); // ensure text is not remove by depth buffer test.

                //glEnable (GL_BLEND); // for text fading

                //glBlendFunc (GL_ONE, GL_ONE_MINUS_SRC_ALPHA); // ditto

                glEnable (GL_TEXTURE_2D);       

                

                glBindTexture (GL_TEXTURE_2D, [self texName]);

                

                [[VertexArray sharedQuad] draw];

                

        }

}

 

- (void) drawAtPoint:(CGPoint)point scaled: (double) scale

{

        [self drawWithBounds: CGRectMake(point.x-[self texturePadding]*scale, point.y-[self texturePadding]*scale, [self textureSize].width*scale, [self textureSize].height*scale)];

}

- (void) drawAtPoint:(CGPoint)point

{

        [self drawAtPoint: point scaled: 1.0];

}

 

- (void) drawCenteredAtPoint:(CGPoint)point scaled: (double) scale

{

        [self drawWithBounds: CGRectMake(point.x-0.5*[self textureSize].width*scale, point.y-0.5*[self textureSize].height*scale, [self textureSize].width*scale, [self textureSize].height*scale)];

}

- (void) drawCenteredAtPoint:(CGPoint)point

{

        [self drawCenteredAtPoint: point scaled: 1.0];

}

 

 

@synthesize antialias, subpixelAA, texturePadding, filterTexture, mipmapTexture, textureSize, texName;

 

@end

 

#pragma mark -

 

@implementation GLQuartzBox

 

- (id) init

{

        if (!(self = [super init]))

                return nil;

 

        cornerRadius = 4.0;

        borderWidth = 1.0;

//      borderColor = [NSColor clearColor];

 

        return self;

}

 

CGPathRef CGPathWithRoundedRect(CGRect rect, CGFloat r)

{

        CGMutablePathRef path = CGPathCreateMutable();

        CGPathMoveToPoint(path, NULL,

                rect.origin.x + rect.size.width - r,    rect.origin.y);

        CGPathAddArcToPoint(path, NULL,

                rect.origin.x + rect.size.width,                rect.origin.y,

                rect.origin.x + rect.size.width,                rect.origin.y + r, r);

        CGPathAddLineToPoint(path, NULL,

                rect.origin.x + rect.size.width, rect.origin.y + rect.size.height - r);

        CGPathAddArcToPoint(path, NULL,

                rect.origin.x + rect.size.width,                rect.origin.y + rect.size.height,

                rect.origin.x + rect.size.width - r,    rect.origin.y + rect.size.height, r);

        CGPathAddLineToPoint(path, NULL,

                rect.origin.x + r, rect.origin.y + rect.size.height);

        CGPathAddArcToPoint(path, NULL,

                rect.origin.x,                                                  rect.origin.y + rect.size.height,

                rect.origin.x,                                                  rect.origin.y + rect.size.height - r, r);

        CGPathAddLineToPoint(path, NULL,

                rect.origin.x, rect.origin.y + r);

        CGPathAddArcToPoint(path, NULL,

                rect.origin.x,                                                  rect.origin.y,

                rect.origin.x + r,                                              rect.origin.y, r);

        CGPathAddLineToPoint(path, NULL,

                rect.origin.x + r,                                              rect.origin.y);

                

        CGPathCloseSubpath(path);

        return path;

}

 

- (void) doQuartzDrawingInContext: (CGContextRef) context sized: (CGSize) imgSize

{

        float borderAlpha = 0.0;

        float boxAlpha = 0.0;

                

        if (borderColor)

                borderAlpha = CGColorGetAlpha([borderColor CGColor]);

        if (boxColor)

                boxAlpha = CGColorGetAlpha([boxColor CGColor]);

 

        double bw = (borderAlpha ? borderWidth : 0.0);

        

        if (boxAlpha)

        { // this should be == 0.0f but need to make sure

                [boxColor set];

                CGPathRef path = CGPathWithRoundedRect(CGRectInset(CGRectMake(texturePadding, texturePadding, frameSize.width, frameSize.height), 0.5*borderWidth, 0.5*borderWidth), cornerRadius);

                CGContextAddPath(context, path);

                CGContextDrawPath(context, kCGPathFill);

        }

 

        if (borderAlpha)

        {

                [borderColor set]; 

                CGPathRef path = CGPathWithRoundedRect(CGRectInset(CGRectMake(texturePadding, texturePadding, frameSize.width, frameSize.height), 0.5*borderWidth, 0.5*borderWidth), cornerRadius);

 

                CGContextAddPath(context, path);

                CGContextSetLineWidth(context, bw);

                CGContextDrawPath(context, kCGPathStroke);

        }

        

}

 

- (CGSize) updatedTextureSize

{

        CGSize texSize = CGSizeMake(ceil(frameSize.width+2.0*texturePadding), ceil(frameSize.height+2.0*texturePadding));

        return texSize;

}

 

- (void) setBoxColor:(UIColor *)color // set default text color

{

        [boxColor autorelease];

        boxColor = [color retain];

        requiresUpdate = YES;

}

 

 

- (void) setBorderColor:(UIColor *)color // set default text color

{

        [borderColor autorelease];

        borderColor = [color retain];

        requiresUpdate = YES;

}

 

- (void) setCornerRadius:(double)rad

{

        cornerRadius = rad;

        requiresUpdate = YES;

}

 

- (void) setBorderWidth:(double)rad

{

        borderWidth = rad;

        requiresUpdate = YES;

}

 

@synthesize cornerRadius, borderWidth, boxColor, borderColor, frameSize;

 

@end

 

#pragma mark -

 

@implementation GLQuartzArc

 

- (id) init

{

        if (!(self = [super init]))

                return nil;

 

        outerRadius = 10.0;

        borderWidth = 1.0;

        endAngle = 2.0*M_PI;

        cornerRadius = 5.0;

 

        return self;

}

 

- (void) doQuartzDrawingInContext: (CGContextRef) context sized: (CGSize) imgSize // generates the texture without drawing texture to current context

{

        double bw = (CGColorGetAlpha([borderColor CGColor]) ? borderWidth : 0.0);

        

//      double meanRadius = 0.5*(innerRadius+outerRadius);

//      double rdiff = (outerRadius-innerRadius);

        double angleRange = endAngle - startAngle;

//      double innerOffset = texturePadding + rdiff;

        

        double cornerCenterRadius = outerRadius - cornerRadius;

        double cornerAngle = cornerRadius/cornerCenterRadius;

        

        BOOL fullCircle = (angleRange > 2.0*M_PI*(1.0-FLT_EPSILON));

        

        if (fullCircle)

        {

                cornerAngle = 0.0;

                cornerCenterRadius = outerRadius;

                endAngle = 2.0*M_PI + startAngle;

        }

                

        double startArc = startAngle + cornerAngle;

        double endArc = endAngle - cornerAngle;

        

        CGPoint center = CGPointMake(imgSize.width*0.5, imgSize.height*0.5);

        

        CGMutablePathRef path = CGPathCreateMutable();

//      [path setLineJoinStyle: NSRoundLineJoinStyle];

//      [path setLineJoinStyle: NSBevelLineJoinStyle];

 

        CGPathMoveToPoint(path, NULL, center.x + cos(startAngle)*cornerCenterRadius, center.y + sin(startAngle)*cornerCenterRadius);

        

        double startArcDegrees = 180.0/M_PI*startArc;

        double endArcDegrees = 180.0/M_PI*endArc;

        double startAngleDegrees = 180.0/M_PI*startAngle;

        double endAngleDegrees = 180.0/M_PI*endAngle;

        

        if (!fullCircle && (cornerRadius > 0.0))

        {

                CGPoint cc = CGPointMake(center.x + cos(startArc)*cornerCenterRadius, center.y + sin(startArc)*cornerCenterRadius);

                CGPathAddArc(path, NULL, cc.x, cc.y, cornerRadius, startAngleDegrees - 90.0, startArcDegrees, NO);

        }

        

        CGPathAddArc(path, NULL, center.x, center.y, cornerRadius, startArcDegrees, endArcDegrees, NO);

 

        if (!fullCircle && (cornerRadius > 0.0))

        {

                CGPoint cc = CGPointMake(center.x + cos(endArc)*cornerCenterRadius, center.y + sin(endArc)*cornerCenterRadius);

                CGPathAddArc(path, NULL, cc.x, cc.y, cornerRadius, endAngleDegrees, endArcDegrees + 90, NO);

        }

        

 

        if (innerRadius > 0.0)

        {

                if (fullCircle)

                {

                        CGPathCloseSubpath(path);

                        CGPathMoveToPoint(path, NULL, center.x + cos(endArc)*innerRadius, center.y + sin(endArc)*innerRadius);

                }

        

                CGPathAddArc(path, NULL, center.x, center.y, innerRadius, endArcDegrees, startArcDegrees, YES);

 

 

        }

        else if (!fullCircle)

                CGPathAddLineToPoint(path, NULL, center.x, center.y);

 

        CGPathCloseSubpath(path);

 

        if (CGColorGetAlpha([fillColor CGColor]))

        { // this should be == 0.0f but need to make sure

                [fillColor set];

                CGContextAddPath(context, path);

                CGContextDrawPath(context, kCGPathFill);

        }

 

        if (CGColorGetAlpha([borderColor CGColor]))

        {

                [borderColor set];

                CGContextSetLineWidth(context, bw);

                CGContextAddPath(context, path);

                CGContextDrawPath(context, kCGPathStroke);

        }

        

}

 

- (CGSize) updatedTextureSize

{

        CGSize texSize = CGSizeMake(ceil(2.0*outerRadius+2.0*texturePadding), ceil(2.0*outerRadius+2.0*texturePadding));

        return texSize;

}

 

- (void) setFillColor:(UIColor *)color

{

        [fillColor autorelease];

        fillColor = [color retain];

        requiresUpdate = YES;

}

 

 

- (void) setBorderColor:(UIColor *)color

{

        [borderColor autorelease];

        borderColor = [color retain];

        requiresUpdate = YES;

}

 

- (void) setOuterRadius:(double)rad

{

        outerRadius = rad;

        requiresUpdate = YES;

}

 

- (void) setInnerRadius:(double)rad

{

        innerRadius = rad;

        requiresUpdate = YES;

}

 

- (void) setBorderWidth:(double)rad

{

        borderWidth = rad;

        requiresUpdate = YES;

}

 

- (void) setCornerRadius:(double)rad

{

        cornerRadius = rad;

        requiresUpdate = YES;

}

 

- (void) setStartAngle:(double)rad

{

        startAngle = rad;

        requiresUpdate = YES;

}

 

- (void) setEndAngle:(double)rad

{

        endAngle = rad;

        requiresUpdate = YES;

}

 

@synthesize innerRadius, outerRadius, startAngle, endAngle, borderWidth, cornerRadius, fillColor, borderColor;

 

@end

 

#pragma mark -

 

@implementation GLString

 

+ (UIFont*) defaultFont

{

        UIFont*         font = [UIFont systemFontOfSize: [UIFont systemFontSize]];

        return font;

}

 

 

#pragma mark -

#pragma mark Initializers

 

// designated initializer

- (id) initWithString:(NSString *)aString withFont: (UIFont*) aFont withTextColor:(UIColor *)text withBoxColor:(UIColor *)box withBorderColor:(UIColor *)border

{

        if (!(self = [super init]))

                return nil;

 

        string = aString;

        

        font = [aFont retain];

 

        self.textColor = text;

        self.boxColor = box;

        self.borderColor = border;

        staticFrame = NO;

        marginSize.width = 4.0f; // standard margins

        marginSize.height = 2.0f;

 

        return self;

}

 

// basic methods that pick up defaults

- (id) initWithString:(NSString *)astring;

{

        return [self initWithString: astring withFont: [GLString defaultFont] withTextColor:[UIColor colorWithRed:1.0f green:1.0f blue:1.0f alpha:1.0f] withBoxColor:[UIColor colorWithRed:1.0f green:1.0f blue:1.0f alpha:0.0f] withBorderColor:[UIColor colorWithRed:1.0f green:1.0f blue:1.0f alpha:0.0f]];

}

 

- (id) initWithString:(NSString *)aString withFont:(UIFont *)aFont

{

        return [self initWithString: aString withFont: aFont withTextColor: nil withBoxColor: nil withBorderColor: nil];

}

 

- (CGSize) frameSize

{

        if (NO == staticFrame)

        { // find frame size if we have not already found it

                frameSize = [string sizeWithFont: font]; // current string size

                frameSize.width += marginSize.width * 2.0f; // add padding

                frameSize.height += marginSize.height * 2.0f;

        }

        return frameSize;

}

 

- (CGSize) updatedTextureSize

{

        if (NO == staticFrame)

        { // find frame size if we have not already found it

                frameSize = [string sizeWithFont: font]; // current string size

                frameSize.width += marginSize.width * 2.0f; // add padding

                frameSize.height += marginSize.height * 2.0f;

        }

        return [super updatedTextureSize];

}

 

- (void) doQuartzDrawingInContext: (CGContextRef) context sized: (CGSize) imgSize // generates the texture without drawing texture to current context

{

        

        [super doQuartzDrawingInContext: context sized: imgSize];

        

        [textColor set]; 

        [string drawAtPoint: CGPointMake(marginSize.width+texturePadding, marginSize.height+texturePadding) withFont: font]; // draw at offset position

}

 

 

- (void) setTextColor:(UIColor *)color // set default text color

{

        [textColor autorelease];

        textColor = [color retain];

        requiresUpdate = YES;

}

 

 

#pragma mark Margin Size

 

// these will force the texture to be regenerated at the next draw

- (void) setMargins:(CGSize)size // set offset size and size to fit with offset

{

        marginSize = size;

        if (NO == staticFrame) { // ensure dynamic frame sizes will be recalculated

                frameSize.width = 0.0f;

                frameSize.height = 0.0f;

        }

        requiresUpdate = YES;

}

 

- (CGSize) marginSize

{

        return marginSize;

}

 

 

#pragma mark Frame

 

 

- (BOOL) staticFrame

{

        return staticFrame;

}

 

- (void) useStaticFrame:(CGSize)size // set static frame size and size to frame

{

        requiresUpdate = requiresUpdate || !staticFrame || !CGSizeEqualToSize(frameSize,size);

        frameSize = size;

        staticFrame = YES;

}

 

- (void) useDynamicFrame

{

        if (staticFrame) { // set to dynamic frame and set to regen texture

                staticFrame = NO;

                frameSize.width = 0.0f; // ensure frame sizes will be recalculated

                frameSize.height = 0.0f;

                requiresUpdate = YES;

        }

}

 

#pragma mark String

 

- (void) setString:(NSString *)theString // set string after initial creation

{

        [string autorelease];

        string = [theString copy];

        if (NO == staticFrame) { // ensure dynamic frame sizes will be recalculated

                frameSize.width = 0.0f;

                frameSize.height = 0.0f;

        }

        requiresUpdate = YES;

}

 

- (void) setFont: (UIFont*) aFont

{

        [font release];

        font = [aFont retain];

        if (NO == staticFrame) { // ensure dynamic frame sizes will be recalculated

                frameSize.width = 0.0f;

                frameSize.height = 0.0f;

        }

        requiresUpdate = YES;

}

 

@synthesize textColor;

 

@end