addons/Font/source/IoFont.c

   1
   2 //metadoc Font copyright Steve Dekorte, 2004
   3 //metadoc Font license BSD revised
   4 //metadoc Font category Graphics
   5 /*metadoc Font description
   6 The Font object can be used to load and render TypeTrype fonts. Example use;
   7 <code>
   8 // within a GLUT display callback...
   9
  10 timesFont = Font clone open(\"times.ttf\")
  11 if (timesFont error, write(\"Error loading font: \", timesFont error, \"\n\"); return)
  12 timesFont setPointSize(16)
  13 glColor(0,0,0,1)
  14 timesFont draw(\"This is a test.\")
  15 </code>
  16
  17 <b>Rendering fonts using OpenGL textures</b>
  18 <p>
  19 Smaller fonts (those having a point size around 30 or smaller, depending on the font) will automatically be cached in and rendered from a texture. This technique is very fast and should support rendering speeds as fast (or faster than) those of typical desktop font rendering systems. Larger font sizes(due to texture memory constraints) will be rendered to a pixelmap when displayed. Thanks to Mike Austin for implementing the font texturing system.
  20 */
  21
  22
  23 #include "IoFont.h"
  24 #include "List.h"
  25 #include "IoState.h"
  26 #include "IoNumber.h"
  27 #include "IoSeq.h"
  28 #include "GLFont.h"
  29
  30
  31 #include "FreeTypeErrorCodes.h"
  32 #include <freetype/ftglyph.h>
  33 #include <math.h>
  34
  35 #define DATA(self) ((IoFontData *)IoObject_dataPointer(self))
  36
  37 IoTag *IoFont_newTag(void *state)
  38 {
  39         IoTag *tag = IoTag_newWithName_("Font");
  40         IoTag_state_(tag, state);
  41         IoTag_cloneFunc_(tag, (IoTagCloneFunc *)IoFont_rawClone);
  42         IoTag_freeFunc_(tag, (IoTagFreeFunc *)IoFont_free);
  43         IoTag_markFunc_(tag, (IoTagMarkFunc *)IoFont_mark);
  44         return tag;
  45 }
  46
  47 IoFont *IoFont_proto( void *state )
  48 {
  49         IoObject *self = IoObject_new(state);
  50         IoObject_tag_(self, IoFont_newTag(state));
  51
  52         IoObject_setDataPointer_(self, calloc(1, sizeof(IoFontData)));
  53         DATA(self)->path = IOSYMBOL(".");
  54         DATA(self)->font = GLFont_new();
  55         DATA(self)->isProto = 1;
  56         IoState_registerProtoWithFunc_(state, self, IoFont_proto);
  57
  58         {
  59                 IoMethodTable methodTable[] = {
  60                 {"open", IoFont_open},
  61
  62                 {"setPath", IoFont_setPath},
  63                 {"path", IoFont_path},
  64
  65                 {"setPixelSize", IoFont_setPixelSize},
  66                 {"pixelSize", IoFont_pixelSize},
  67
  68                 {"drawString", IoFont_drawString},
  69                 {"widthOfString", IoFont_lengthOfString},
  70                 {"widthOfCharacter", IoFont_lengthOfCharacter},
  71                 {"pixelHeight", IoFont_fontHeight},
  72                 {"isTextured", IoFont_isTextured},
  73                 {"error", IoFont_error},
  74                 {"stringIndexAtWidth", IoFont_stringIndexAtWidth},
  75                 {NULL, NULL},
  76                 };
  77                 IoObject_addMethodTable_(self, methodTable);
  78         }
  79         GLFont_init();
  80         return self;
  81 }
  82
  83 IoFont *IoFont_rawClone(IoFont *proto)
  84 {
  85         IoObject *self = IoObject_rawClonePrimitive(proto);
  86         IoObject_setDataPointer_(self, cpalloc(IoObject_dataPointer(proto), sizeof(IoFontData)));
  87         DATA(self)->font = GLFont_new();
  88         DATA(self)->isProto = 0;
  89         return self;
  90 }
  91
  92 IoFont *IoFont_new(void *state)
  93 {
  94         IoObject *proto = IoState_protoWithInitFunction_(state, IoFont_proto);
  95         return IOCLONE(proto);
  96 }
  97
  98 /* -------------------------------------------------------------------------- */
  99
 100 void IoFont_free( IoFont *self )
 101 {
 102         GLFont_free( DATA(self)->font );
 103         if (DATA(self)->isProto) { GLFont_done(); }
 104         free(DATA(self));
 105 }
 106
 107 void IoFont_mark( IoFont *self )
 108 {
 109         IoObject_shouldMark( (IoObject *)DATA(self)->path );
 110 }
 111
 112 /* -------------------------------------------------------------------------- */
 113
 114 IoObject *IoFont_clone(IoFont *self, IoObject *locals, IoMessage *m)
 115 {
 116         IoFont *newObject = IoFont_new(IOSTATE);
 117         DATA(newObject)->path = DATA(self)->path;
 118         return newObject;
 119 }
 120
 121 IoObject *IoFont_setPath(IoFont *self, IoObject *locals, IoMessage *m)
 122 {
 123         /*doc Font setPath(aString)
 124         Sets the Font path. Returns self.
 125         */
 126
 127         DATA(self)->path = IOREF(IoMessage_locals_seqArgAt_(m, locals, 0));
 128         return self;
 129 }
 130
 131 IoObject *IoFont_path(IoFont *self, IoObject *locals, IoMessage *m)
 132 {
 133         /*doc Font path
 134         Returns the Font path.
 135         */
 136         return DATA(self)->path;
 137 }
 138
 139 IoObject *IoFont_setPixelSize(IoFont *self, IoObject *locals, IoMessage *m)
 140 {
 141         /*doc Font setPixelSize(aNumber)
 142         Sets the size of the font in pixels. Returns self.
 143         */
 144
 145         int size = IoMessage_locals_intArgAt_(m, locals, 0);
 146         GLFont_setPixelSize(DATA(self)->font, size);
 147         return self;
 148 }
 149
 150 IoObject *IoFont_pixelSize(IoFont *self, IoObject *locals, IoMessage *m)
 151 {
 152         /*doc Font pixelSize
 153         Returns the font's pixelSize.
 154         */
 155
 156         return IONUMBER(GLFont_pixelSize( DATA(self)->font));
 157 }
 158
 159 void IoFont_checkError(IoFont *self, IoObject *locals, IoMessage *m)
 160 {
 161         const char *e = GLFont_error(DATA(self)->font);
 162
 163         if (e != NULL)
 164         {
 165                 IoState_error_(IOSTATE, m, "Font %s", e);
 166         }
 167 }
 168
 169 IoObject *IoFont_open(IoFont *self, IoObject *locals, IoMessage *m)
 170 {
 171         /*doc Font open(optionalPath)
 172         Opens the font. Sets path using optionalPath if supplied. Returns self.
 173         */
 174
 175         if (IoMessage_argCount(m) > 0)
 176         {
 177                 DATA(self)->path = IOREF(IoMessage_locals_seqArgAt_(m, locals, 0));
 178         }
 179
 180         GLFont_loadFont( DATA(self)->font, CSTRING(DATA(self)->path) );
 181         IoFont_checkError(self, locals, m);
 182         return self;
 183 }
 184
 185 IoObject *IoFont_lengthOfString(IoFont *self, IoObject *locals, IoMessage *m)
 186 {
 187         /*doc Font widthOfString(aString)
 188         Returns a Number with the width that aString would render
 189         to with the receiver's current settings.
 190         */
 191
 192         IoSymbol *text = IoMessage_locals_seqArgAt_(m, locals, 0);
 193         int startIndex = 0;
 194         int max = IoSeq_rawSize(text);
 195         int endIndex = max;
 196
 197         if (IoMessage_argCount(m) == 2)
 198         {
 199                 startIndex = IoNumber_asInt(IoMessage_locals_numberArgAt_(m, locals, 1));
 200                 if (startIndex > max) startIndex = max;
 201         }
 202
 203         if (IoMessage_argCount(m) > 2)
 204         {
 205                 endIndex = IoNumber_asInt(IoMessage_locals_numberArgAt_(m, locals, 2));
 206                 if (startIndex > max) endIndex = max;
 207         }
 208
 209         return IONUMBER( GLFont_lengthOfString( DATA(self)->font, CSTRING(text), startIndex, endIndex) );
 210 }
 211
 212 IoObject *IoFont_lengthOfCharacter(IoFont *self, IoObject *locals, IoMessage *m)
 213 {
 214         /*doc Font lengthOfCharacter(aNumber)
 215         Returns the width of the character specified by aNumber in the receiver's font.
 216         */
 217
 218         unsigned char c = IoNumber_asInt(IoMessage_locals_numberArgAt_(m, locals, 0));
 219         return IONUMBER( GLFont_lengthOfCharacter_( DATA(self)->font, c) );
 220 }
 221
 222 IoObject *IoFont_fontHeight(IoFont *self, IoObject *locals, IoMessage *m)
 223 {
 224         /*doc Font fontHeight
 225         Returns the height of the font measured in pixels.
 226         */
 227
 228         return (IoObject*)IONUMBER( GLFont_fontHeight( DATA(self)->font ) );
 229 }
 230
 231 IoObject *IoFont_stringIndexAtWidth(IoFont *self, IoObject *locals, IoMessage *m)
 232 {
 233         /*doc Font stringIndexAtWidth(aString, startIndex, width)
 234         Returns the max index of the character in String (starting at startIndex)
 235         that fits within width.
 236         */
 237
 238         IoSymbol *text = IoMessage_locals_seqArgAt_(m, locals, 0);
 239         int startIndex;
 240         int width;
 241         //IOASSERT(IoMessage_argCount(m) == 2, "requires 3 arguments");
 242         startIndex = IoNumber_asInt(IoMessage_locals_numberArgAt_(m, locals, 1));
 243         if (startIndex > (int)IoSeq_rawSize(text)) startIndex = (int)IoSeq_rawSize(text);
 244
 245         width = IoNumber_asInt(IoMessage_locals_numberArgAt_(m, locals, 2));
 246
 247         return IONUMBER(GLFont_stringIndexAtWidth(DATA(self)->font, CSTRING(text), startIndex, width));
 248 }
 249
 250 IoObject *IoFont_drawString(IoFont *self, IoObject *locals, IoMessage *m)
 251 {
 252         /*doc Font drawString(aString, optionalStartIndex, optionalEndIndex)
 253         Draws aString using the optional start and end indexes, if supplied. Returns self.
 254 <p>
 255 Note; Fonts are draw as RGBA pixel maps. These blending options are recommended:
 256 <code>
 257 glEnable(GL_BLEND)
 258 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
 259 </code>
 260         */
 261
 262         IoSymbol *textString = IoMessage_locals_seqArgAt_(m, locals, 0);
 263         int startIndex = 0;
 264         int endIndex;
 265
 266         if (IoMessage_argCount(m) > 1)
 267         {
 268                 startIndex = IoNumber_asInt(IoMessage_locals_numberArgAt_(m, locals, 1));
 269                 if (startIndex > (int)IoSeq_rawSize(textString)) startIndex = (int)IoSeq_rawSize(textString);
 270         }
 271
 272         if (IoMessage_argCount(m) > 2)
 273         {
 274                 endIndex = IoNumber_asInt(IoMessage_locals_numberArgAt_(m, locals, 2));
 275         }
 276         else
 277         {
 278                 endIndex = IoSeq_rawSize(textString);
 279         }
 280
 281         GLFont_drawString(DATA(self)->font, CSTRING(textString) , startIndex, endIndex);
 282         IoFont_checkError(self, locals, m);
 283         return self;
 284 }
 285
 286 IoObject *IoFont_isTextured(IoFont *self, IoObject *locals, IoMessage *m )
 287 {
 288         /*doc Font isTextured
 289         Returns true if the font is being cached in and rendered from a texture, false otherwise.
 290         */
 291
 292         return IOBOOL(self, GLFont_isTextured(DATA(self)->font));
 293 }
 294
 295 IoObject *IoFont_error(IoFont *self, IoObject *locals, IoMessage *m)
 296 {
 297         /*doc Font error
 298         Returns the current error string or nil if there is no error.
 299         */
 300
 301         const char *e = GLFont_error(DATA(self)->font);
 302         return strlen(e) ? (IoObject *)IOSYMBOL((char *)e) : IONIL(self);
 303 }