* k8 ~: `% |8 e# IIn this article were going to demonstrate how to display text on a SDL Surface in much the same way as we would draw a sprite. % j4 {( L/ q4 F, P# @2 h8 c
, p, V2 X/ m2 ^$ A9 N% S
CREDIT WHERE CREDIT IS DUE: ! P5 Z4 Z. |9 J7 RThe code for this How-To was kindly donated to us by VDM of www.ubuntuforums.org who is currently acting as an adviser for us on this project. $ j" z/ ?* ^6 Z2 ^# U- W1 Q# a
% U8 t4 b/ H/ \( h. g3 N) c1 y) U ! Q" x: S8 D- l' o; V: tIntroduction" m$ n" {& L/ i! u
A lot of the time its much nicer to display text in a font that is themed the same as your game. This means you are faced with using a specially designed True Type Font or you can create one on a bitmap. Its often better to create a bitmap font because it can be more pleasing to the eye and so add to you games look and feel value. 5 z4 w* y5 P! L% m2 W6 w
6 D: i, t3 x. c9 m DHandling the fonts using a class # M& ]/ ~3 k; V' [% hAs we have said before in previous articles, C++ classes handle this kind of job really well, so we're going to stick with the paradigm and create a class that will do the following: C& `- h7 \1 [% M7 K) e. U# q 8 f/ K8 {( G: @8 u+ l9 THandle the loading of the font bitmap& D, h' D; a$ X: g" l) Q3 {: |
Exclusively deal with any information about the font ) Z% J5 c3 U; a1 n x0 EDeal with drawing/blitting the font to a Surface" f) S$ b K8 v
) d, }) H$ I* U/ ~9 c6 k c 9 V2 u% Z0 O, f5 o4 }class Font $ z1 F' z) K! E; Y* G& l- [{ . l0 r* O/ E" U2 \1 A SDL_Surface* m_pFontList; // this is our surface to store the bitmap font K! V" E4 ?. J
public:2 _, t* k2 o/ U2 Y0 r/ Y
Font(std::string src_file);0 E1 g2 m9 d! A0 |, k% z
virtual ~Font(void); : N5 D( a5 b, Z2 ` int ShowText(std::string text, int type, int pos_x, int pos_y, SDL_Surface* pScreen); % _% c! ~9 A: ]};* ~2 b/ t+ j9 m
, J6 m0 H- {$ M6 L$ UFont(): constructs the class object and loads the specified file into memory. N$ x, c. C! z, r4 ]~Font(): destructs the class but currently contains no code. Its still worth having one for possible future changes2 j8 a) Q" o: T4 Q3 X
ShowText(): handles translating and drawing a specified string onto our surface _$ P* |3 H; z3 J0 D$ G8 ?
/ U% Y7 Z5 ^$ i4 P! y
Loading the font surface/ g# ?! M) \7 V8 Y1 K7 i
This is the easy part! we use the IMG_Load() which we have decided to 'nest' inside thae arguments of our SDL_DisplayFormatAlpha() function. SDL_DisplayFormatAlpha() is the same as the SDL_DisplayFormat() we have used previously but also provides an alpha channel which will be handy to have in future How-Tos. ' ^* m u: Q" z& P S/ L/ [, O) h$ d1 t* X
Heres the code: 6 Q, `5 W2 C* B @( v# n: B5 b1 C ! t" f' `6 X9 l3 Q8 o: |
2 K" J8 x& q, |Font::Font(std::string src_file)3 R9 ^2 Y9 D' U% V# R
{ 0 E5 z. p7 L9 L5 p/ J m_pFontList = SDL_DisplayFormatAlpha(IMG_Load(src_file.c_str())); ) B4 L6 z: P6 ~0 h( ^5 |} . j3 d0 [5 H0 x* u) p: u5 v % I7 b! X! p- N0 U! JLets go loopy!# H+ @3 Q$ C8 w* H) U
Now comes the complex part of our Font class, we need to loop through every letter of the string and process which bitmapped letter to draw: $ R$ G! ]; L& w1 T8 F: c) M
& a) X* Q- k5 Y. P% L' S2 v! @1 F/ E/ p0 N9 H2 |3 n$ Z8 k+ t" _7 _: y
int Font::ShowText(std::string text, int type, int pos_x, int pos_y, SDL_Surface* pScreen)' H! F6 F+ S/ D1 ~
{ , w) m6 u/ P6 r$ | /* TODO: We need to calculate the fonts height into the pos_y thing. */! I: L" Z b4 r6 j8 @ ^5 |$ V% S3 R
// Also, id like to see this stuff gathered from an ini file.. m3 E' T7 q/ ^
// That way we can alter fonts without the need for recompilcation- Y' O6 C/ k* Z& Q; \4 r9 i
if(!pScreen) return 1; * B) ^9 O7 y( T, \, Q3 J2 t O" k // src_rect is the location of the character we need to fetch. . U, S( P# _( g/ [1 i // rect will be the destenation+ \- }! F- s# F, ^ v+ |
SDL_Rect rect, src_rect; / }- a/ U, _ U! W- T; n
rect.x = pos_x;" B, a" l; ~* h9 U5 A; B9 U: G
rect.y = pos_y;/ g/ H8 i* K0 [5 u6 u
SDL_Rect tmp_rect; : M. R# c6 T8 g9 P6 A- O tmp_rect.y = 0*type; . n2 b/ V$ U& m9 ? P% C, A2 f for(int i=0; i < text.size(); i++) { 7 i% R* U, Q3 A( D( j. _7 a5 h m! Q tmp_rect.y = 0; // set right y axe % ~" @1 @; Q9 z0 r switch(text) { 7 I J9 Z* |- h+ Y" q; h case 0x20: 3 B% w1 s/ |3 j2 n rect.x += 10;5 j/ f& }9 b/ c
break; # @) m$ S z# [0 a case 0x21: // !: C9 v$ K* h5 B: P9 Z! C$ C
tmp_rect.x = 4;, }; s* \& Q2 s; W8 M: w: j" p' A
tmp_rect.w = 6;- L1 C# S) }1 j
tmp_rect.h = 19;8 j* k2 B$ B! F9 `; A, ^! W8 K2 b
tmp_rect.y = 0; D/ s* f0 I. x, s* _, ^* q- A! @
SDL_BlitSurface( m_pFontList, &tmp_rect, pScreen, &rect);. ^* |# \" `9 c3 i/ D
rect.x += tmp_rect.w; / }" G% G8 d3 l break; & {6 r0 U2 M8 |7 E" ~# n* A3 D + b* r% ^" ]) c7 j0 UYou'll notice that I didn't put the whole thing up for viewing! If would like to see it in its entirety you can download the source code and look at that! " O3 H* h! ~8 M4 p & W6 J3 g1 l/ X3 iyou can see from the code snippet that we use a switch to test the current letter and then act upon what we find. This involves setting the values of a SDL_Rect and passing it to the SDL_BlitSurface() function which, if you have read the earlier How-Tos, is exactly the same method we have used to draw sprites and background images. 2 Y& }% h( u3 E) @0 B; ]$ V! Q ) ]' p u1 Z# ^( x/ ]- ]
VDM and myself both agree that this could be done more elegantly by using some form of initialization file hat could be loaded at the start instead of setting the values in code. Perhaps that an idea for another How-To! ;-D 4 J3 B; o" `! Q+ b
- g! O2 J) p9 M2 j: p3 W, S
Click Here To Download the code sdl-fontfun.tar.gz , t: E1 K) I9 `4 K e& T9 L
# H( E, @! h7 k# x( Q. M4 X* w3 `7 pTo compile and run the code: # L! J9 D, b$ J
+ I' \1 T+ d) x
7 y* b! u1 b1 ?0 u7 E) c% N
g++ -o sdl-funfonts font.cpp sdlfontsfun.cpp `sdl-config --cflags --libs` -lSDL_image - p: @+ V/ C; I./sdl-funfonts/ m3 p& q6 U& m; U4 m, y# ^$ g
' ?; k; H! p; ]6 f$ \6 OFinal thoughts) G" `/ Y0 i6 G
Thats the end of this How-To, we both hope this sheds some light on the game development process. If you have any comments or contribution please feel free to contact us on the ubuntu forums.