There are a couple things that need to be set up on your computer in order to start using DirectFont.

• DirectX 7.0a. This is a must for this tutorial. The DirectFont DLL references DirectX objects, so you need to have this installed on your system.
• You need a font collection created by the DirectFont EXE. Refer the the first part of this tutorial for how to create one.
• You need a working DirectX app to test this out. In this tutorial, I will assume that you already have the backbuffer, primary surface, sprites, and game loop needed for the basic DirectX app (if not, check out Lucky's DirectX tutorial for a working sample).

• The DirectFont component is bundled in a ActiveX DLL. This is a DLL that you can reference in your projects (under the Project->Reference menu item of VB, and look for DirectFontDLL, or else browse the Windows system directory). It is not a regular DLL which exposes functions, it instead exposes a Visual Basic object (in this case, the object is named DirectFont). NOTE: I'm not sure how this work with VC++ (if anyone tries, let me know), or if it will even work at all.
• Just as when you reference the DirectX DLL itself (like you all have to do for any DirectX app) and then are able to Dim variables of the DirectDraw, DirectInput, or DirectSound class, so too can you do with DirectFont. There are two methods with which to create a DirectFont instance (Method 1 is actually faster code, since in Method 2, VB checks the object's type every time it is referenced):

• DirectFont is a regular object just like DirectDraw is. Make sure to set it to Nothing before your app closes (stick it in the same function as you put all your other termination code).

• When working with the DirectFont object, you interact through it's exposed methods (these are methods that I made public when creating the DLL).
• The following is a list of the exposed methods. They are envoked as any other methods are invoked (either called directly or using the Call keyword).

First you have to instantiate a DirectFont object. The best place to do this is the same place you instantiate your othere DirectX objects (most likely in your Form_Load event). To do this, you can use one of the methods used in a previous section (but I would suggest the first method).

This is pretty self explanatory...we're just creating a new instance. One really weird problem I've found, is that you have to instatiate your DirectFont object before your DirectX object. Get more information on this in the Tips and Tricks section below.

Next you have to initialize the object. In this step, I usually stick the two methods together since it makes sense to do so, however, if you are using mulitple collections for your one app, you might want to stick the LoadCollection call in a seperate function that determines which collection to load.

In line 3, moBackBufferSurface is the DirectDraw surface that I am blitting my characters to, and moDirectDraw is my instance of DirectDraw that I am passing to DirectFont to use. I usually pass it an instance of DirectDraw, so it doesn't have to create it's own (however, I left the functionality in there in case someone wanted it). I didn't specify the pbBltFast parameter, so I am letting it use it's default...BltFast.

In line 4, we load the collection. The only parameter specified is collection file's location. I've simply left my collection exposed in the applications directory, but your can store it your own Binary File Format (see one of Lucky's tutorials on how to do that), extract it to a temp file, and then load it, then remove the temp file.

Now we actually use the DirectFont object. Right before our Blit loop, we determine what font we are to use (based on the particular screen, let's say), and then we set our current font. It goes something like this...

In line 6, we select our font. In my app that I was testing this out with, I was using the text to display a FPS counter. So I created a collection called fpstext.fnt (as in line 4), which contained one definition...FPSText. So here is where I specify the name. Now yes, it would be better programming practice to stick "FPSText" into a constant and use that contstant, but that would involve more HTML ;). The second parameter (although I really didn't need to specify it since it was optional) tells DirectFont to use the transparency in the definition. This will most often be the case (that's why it has a default value of True). The last parameter tells it to use a zoom of 50%. This will shrink the character in half when blitted. However, since I used BltFast earlier, this parameter is ignored when I do the actual blitting.

Here's the method you've all be waiting for. Somewhere in our Blit loop stick this line to draw the text to the screen.

Line 8 is the one which does all the work. The first and second parameter specify the starting coordinate for the string...in our case, start the top left corner of the string at (50,100). The third parameter is our actual string. In this case it concatenates the integer FPS counter with the string " FPS" and sends that to the method. The end result would be something like "64 FPS" in the letters of our font definition at coordinates (50,100). Pretty simple, eh?

And finally clean up. These lines would go in with all of your other cleanup code (unaquiring DirectInput objects, setting all DirectX objects to nothing, etc.)

And that's it..not bad for 11 lines of code. I was able to implement a graphical FPS counter that didn't lock up the surface every time I drew it to the screen, and it took me only a few minutes to add the logic.

• You must instantiate your DirectFont object before your DirectX object. I don't know why...but if you don't you'll get an automation error when it tries to create DirectFont. One problem that some people might have, is that they decalre their DirectX object using second method I mentioned above. This might not work, since you lose control over the order of instantiation. If you use this method, and it's not working for you, try the way I recommended (late-binding). Then just instantiate the DirectFont first...simple.
• DirectFont works just like any other blits. Be conscious of the order of blitting. If you do a moDirectFont.DrawText() first, then you're sprites and backgrounds will overwrite the text. I suggest you make it the very last operation in your render loop.
• You might have noticed that I don't pay attention to return codes in the above code. That is because I knew it was working. When you are developing your app, pay attention to the return values...they let you know what's going on. Also, if there are errors encountered by DirectFont, it will right a log file (called DirectFont.log) to the directory the DLL is in. Watch out though...if you are in a render loop, and there is an error every time, it writes them all, so that file might get pretty big.
• Zooming only works if the you have initialized this object to use a regular Blit, and not a BltFast. If you are have the font currently set to use BltFast, any zooming information will be ignored.