Advanced 3D Game Programming with DirectX 9.0 by Peter Walsh
ISBN:1556229682
Wordware Publishing © 2003 (525 pages) Designed for programmers who are new to graphics and game programming, this book covers Direct 3D, DirectInput, and DirectSound, as well as artificial intelligence, networking, multithreading, and scene management. Companion Web Site
Table of Contents Advanced 3D Game Programming Using DirectX 9.0 Introduction Chapter 1
- Windows
Chapter 2
- Getting Started with DirectX
Chapter 3
- Communicating with DirectInput
Chapter 4
- DirectSound
Chapter 5
- 3D Math Foundations
Chapter 6
- Artificial Intelligence
Chapter 7
- UDP Networking
Chapter 8
- Beginning Direct3D
Chapter 9
- Advanced 3D Programming
Chapter 10 - Advanced Direct3D Chapter 11 - Scene Management Appendix
- An STL Primer
Index List of Figures List of Tables List of Code Examples
Advanced 3D Game Programming Using DirectX 9.0 Peter Walsh
1
Wordware Publishing, Inc. Library of Congress Cataloging-in-Publication Data Walsh, Peter (Peter Andrew), 1980Advanced 3D game programming with DirectX 9.0 / by Peter Walsh. p. cm. ISBN 1-55622-968-2 (pbk.) 1. Computer games–Programming. 2. DirectX. I. Title. QA76.76.C672W382 2003 794.8'167768–dc21 2003007140 CIP Copyright © 2003 Wordware Publishing, Inc. All Rights Reserved 2320 Los Rios Boulevard Plano, Texas 75074 No part of this book may be reproduced in any form or by any means without permission in writing from Wordware Publishing, Inc. 1-55622-968-2 10 9 8 7 6 5 4 3 2 1 0403 DirectX is a registered trademark of Microsoft Corporation in the United States and/or other countries. All brand names and product names mentioned in this book are trademarks or service marks of their respective companies. Any omission or misuse (of any kind) of service marks or trademarks should not be regarded as intent to infringe on the property of others. The publisher recognizes and respects all marks used by companies, manufacturers, and developers as a means to distinguish their products. All inquiries for volume purchases of this book should be addressed to Wordware Publishing, Inc., at the above address. Telephone inquiries may be made by calling: (972) 423-0090 Dedications To my beautiful fiancée Lisa Sullivan I love you with all my heart. Peter To my parents, Manny and Maria
2
Adrian Original edition for DirectX version 7.0 written by Adrian Perez with Dan Royer. Revised and updated by Peter Walsh. Acknowledgments Like Adrian says below, this book, like any other, was not just the work of one (or two or three) people; there have been so many people over the years who have helped me in one way or another, and the result of all these efforts contributed to the knowledge contained in this book. I will try to thank everyone I can. My update of this book would not have occurred without the help of Tracy Williams, who has helped me many times with my books. Not only did she get me going on my first book, but she got me hooked up with Wordware for this book, my third. Of course, I must thank Jim Hill, Wes Beckwith, and Tim McEvoy of Wordware for being such great people to work with. Thanks to Phil Taylor on the DirectX team at Microsoft for agreeing to do the tech check and also to Wolfgang Engel and Bruno Sousa for their technical support. Of course, thank you to my wonderful fiancee Lisa for helping to keep me motivated while working on the book, when I just wanted to give up and party! Where would I be without thanking all my friends and family, who keep me sane during the many months that I spent researching and writing these massive books. So thank you Jon-Paul Keatley, Stewart Wright, Andrew McCall, Todd Fay, Mike Andrews, Laz Allen, and all my other friends around the world that I don't have room to list! Also, who would I be writing a book and not mentioning my soonto-be family-in-law? So thank you Liam and Ann Sullivan for giving me permission to marry your beautiful daughter (also to Joanne, Pauline, Liam Jr., and the rest of the family). Of course, thanks to my parents Simon and Joy Walsh for being so supportive during my younger years and to this day. The worst thing about writing acknowledgments is that you always forget someone who helped you until the day the book goes to print. So thank you to everyone else I forgot—please accept my apologies; my poor brain is worn out after all this work! Peter Walsh This book couldn't have been completed without the help and guidance of a whole lot of people. I'll try to remember them all here. First, thanks to Wes Beckwith and Jim Hill at Wordware Publishing. They were extremely forgiving of my hectic schedule, and they helped guide me to finishing this book. I also must thank Alex Dunne for letting me write an article in 1998 for Game Developer magazine. If I hadn't written that article, I never would have written this book. Everything I know about the topics in this book I learned from other people. Some of these people were mentors, others were bosses, and still others were professors and teachers. Some were just cool people who took the time to sit and talk with me. I can't thank them enough. Paul Heckbert, Tom
3
Funkhouser, Eric Petajan, Charles Boyd, Mike Toelle, Kent Griffin, David Baraff, Randy Pausch, Howie Choset, Michael Abrash, Hugues Hoppe, and Mark Stehlik: You guys rock. Thank you. Thanks to Microsoft, ATI, nVidia, id Software, and Lydia Choy for helping me with some of the images used in the text. Many people helped assure the technical correctness and general sanity of this text. Ian Parberry and his class at University of North Texas were immensely helpful: Thanks, guys. Michael Krause was an indispensable help in assuring the correctness of the DirectX chapters. Bob Gaines, Mikey Wetzel, and Jason Sandlin from the DirectX team at Microsoft helped make sure Chapters 2, 3, 4, 8, and 10 were shipshape: Mad props to them. David Black was kind enough to look over Chapter 11 and help remove some errors and clarify a few points. Finally, I need to thank all of the people who helped me get this thing done. I know I won't be able to remember all of them, but here's a short list: Manual and Maria Perez, Katherin Peperzak, Lydia Choy (again), Mike Schuresko, Mike Breen (and the rest of the Originals), Vick Mukherjee, Patrick Nelson, Brian Sharp, and Marcin Krieger. Adrian Perez About the author Peter Walsh is a professional game programmer at Visual Science Ltd., where he has worked on a number of titles including the Formula 1 series of games, Harry Potter and the Chamber of Secrets, and others for Electronic Arts, the world's leading publisher of computer games. He has studied for a degree in computer games development at Abertay University in Dundee, Scotland, and has worked with ICCAVE, a think tank for the next generation of gaming technology. The complete source code in C++, including a game demonstrating techniques covered in this book, can be downloaded from http://www.wordware.com/files/dx9.
Introduction A wise man somewhere, somehow, at some point in history, may have said the best way to start a book is with an anecdote. I would never question the words of a wise man who may or may not have existed, so here we go. When I was a freshman in high school back in 1993, I took the required biology class that most kids my age end up having to take. It involved experiments, lab reports, dissecting of various animals, and the like. One of my lab partners was a fellow named Chris V. We were both interested in computers and quickly became friends, to the point where talking about biology in class was second to techno-babble.
4
One night, in the middle of December, Chris called me up. The lab report that was due the next day required results from the experiment we had done together in class, and he had lost his copy of our experiment results. He wanted to know if I could copy mine and bring them over to his place so he could finish writing up the lab. Of course, this was in those heinous pre-car days, so driving to his house required talking my parents into it, finding his address, and various other hardships. While I was willing to do him the favor, I wasn't willing to do it for free. So I asked him what he could do to reciprocate my kind gesture. "Well," he said, "I guess I can give you a copy of this game I just got." "Really? What's it called?" I said. "Doom. By the Wolf 3D guys." "It's called Doom? What kind of name is that??" After getting the results to his house and the game to mine, I fired the program up on my creaky old 386 DX-20 clone, burning rubber with a whopping 4 MB of RAM. As my space marine took his first tenuous steps down the corridors infested with hellspawn, my life changed. I had done some programming before in school (Logo and Basic), but after I finished playing the first time, I had a clear picture in my head of what I wanted to do with my life: I wanted to write games, something like Doom. I popped onto a few local bulletinboards and asked two questions: What language was the game written in, and what compiler was used? Within a day or so, I purchased Watcom C 10.0 and got my first book on C programming. My first C program was "Hello, World." My second was a slow, crash-happy, non-robust, wireframe spinning cube. I tip my hat to John Carmack, John Romero, and the rest of the team behind Doom; my love for creating games was fully realized via their masterpiece. It's because of them that I learned everything that I have about this exceptionally interesting and dynamic area of computer acquired programming. The knowledge that I have is what I hope to fill these pages with, so other people can get into graphics and game programming. I've found that the best way to get a lot of useful information down in a short amount of space is to use the tried-and-true FAQ (frequently asked questions) format. I figured if people needed answers to some questions about this book as they stood in their local bookstore trying to decide whether or not to buy it, these would be them.
Who are you? What are you doing here? Well I, being Peter rather than Adrian, am a professional games programmer and have been for a quite a few years. I started out like most people these days, getting extremely interested in how games worked after Doom came out. After teaching myself programming, I moved on to study for a degree in computer games development at Abertay University in Dundee, Scotland. After that I went on to work for a short while with IC-CAVE, which is a think tank for the next generation of gaming technology. Over
5
the years I've worked on games like F1 Career Challenge, Harry Potter and the Chamber of Secrets, SHOX, and the upcoming Medal of Honor: Rising Sun. I've developed games for the PC, Game Boy, Dreamcast, PS2, Game Cube, and Xbox. I've also written two other books over the last two years on DirectX programming. I've also read so many programming books that I reckon I have personally wiped out half of the Amazon rainforest. So hopefully all that material will help me write this book in a way that avoids all the pitfalls that other authors have fallen into. I really hope you learn a lot from this book. If you have any questions along the way that you just can't get to the bottom of, please email me at
[email protected]. Unfortunately, after printing that email in a previous book it was bombarded by junk mail from spammers and became almost unusable. However, Hotmail has gotten better lately, so hopefully your questions will get through to me!
Why was this book written? I've learned from many amazingly brilliant people, covered a lot of difficult ground, and asked a lot of dumb questions. One thing that I've found is that the game development industry is all about sharing. If everyone shares, everyone knows more stuff, and the net knowledge of the industry increases. This is a good thing because then we all get to play better games. No one person could discover all the principles behind computer graphics and game programming themselves, and no one can learn in a vacuum. People took the time to share what they learned with me, and now I'm taking the time to share what I've learned with you.
Who should read this book? This book was intended specifically for people who know how to program already but have taken only rudimentary stabs at graphics/game programming or never taken any stab at all, such as programmers in another field or college students looking to embark on some side projects.
Who should not read this book? This book was not designed for beginners. I'm not trying to sound arrogant or anything; I'm sure a beginner will be able to trudge through this book if he or she feels up to it. However, since I'm so constrained for space, often- times I need to breeze past certain concepts (such as inheritance in C++). If you've never programmed before, you'll have an exceedingly difficult time with this book.
What are the requirements for using the code? The code was written in C++, using Microsoft Visual C++ 6.0. The .DSPs and .DSWs are provided on the downloadable files (http://www.wordware.com/files/dx9); the .DSPs will work with versions previous to 6.0, and the .DSWs will work with 6.0 and up. If you choose to use a different compiler, getting the source code to work should be a fairly trivial task. I specifically wrote this code to use as little non-
6
standard C++ as possible (as far as I know, the only non-standard C++ I use is nameless structures within unions).
Why use Windows? Why not use Linux? I chose to use Win32 as the API environment because 90 percent of computer users currently work on Windows. Win32 is not an easy API to understand, especially after using DOS coding conventions. It isn't terribly elegant either, but I suppose it could be worse. I could choose other platforms to work on, but doing so reduces my target audience by a factor of nine or more.
Why use Direct3D? Why not use OpenGL? For those of you who have never used it, OpenGL is another graphics API. Silicon Graphics designed it in the early '90s for use on their high-end graphics workstations. It has been ported to countless platforms and operating systems. Outside of the games industry in areas like simulation and academic research, OpenGL is the de facto standard for doing computer graphics. It is a simple, elegant, and fast API. Check out http://www.opengl.org for more information. But it isn't perfect. First of all, OpenGL has a large amount of functionality in it. Making the interface so simple requires that the implementation take care of a lot of ugly details to make sure everything works correctly. Because of the way drivers are implemented, each company that makes a 3D card has to support the entire OpenGL feature set in order to have a fully compliant OpenGL driver. These drivers are extremely difficult to implement correctly, and the performance on equal hardware can vary wildly based on driver quality. In addition, DirectX has the added advantage of being able to move quickly to accommodate new hardware features. DirectX is controlled by Microsoft (which can be a good or bad thing, depending on your view of it), while OpenGL extensions need to be deliberated by committees. My initial hope was to have two versions of the source code—one for Windows and Direct3D and the other for Linux and OpenGL. This ended up not being possible, so I had to choose one or the other; I chose Direct3D.
Why use C++? Why not C, ASM, or Java? I had a few other language choices that I was kicking around when planning this book. Although there are acolytes out there for Delphi, VB, and even C#, the only languages I seriously considered were C++, Java, and C. Java is designed by Sun Microsystems and an inherently object-oriented language, with some high-level language features like garbage collection. C is about as low level as programming gets without dipping into assembly. It has very few if any high-level constructs and doesn't abstract anything away from the programmer. C++ is an interesting language because it essentially sits directly between the functionality of the other two languages. C++ supports COM better than C does (this is more thoroughly discussed in Chapter 1).
7
Also, class systems and operator overloading generally make code easier to read (although, of course, any good thing can and will be abused). Java, although very cool, is an interpreted language. Every year this seems to be less important: JIT compilation gets faster and more grunt work is handed off to the APIs. However, I felt C++ would be a better fit for the book. Java is still a very young language and is still going through a lot of change.
Do I need a 3D accelerator? That depends. Technically, no, you can get by without any accelerator at all, using Direct3D's software rasterizer. However, it's extremely slow, far from real time for anything but trivially simple scenes. It's almost impossible to buy a computer these days without some sort of 3D acceleration, and an accelerator capable of handling all the code in this book can be purchased for under $100.
How hardcore is the C++ in this book? Some people see C++ as a divine blade to smite the wicked. They take control of template classes the likes of which you have never seen. They overload the iostream operators for all of their classes. They see multiple inheritance as a hellspawn of Satan himself. I see C++ as a tool. The more esoteric features of the language (such as the iostream library) I don't use at all. Less esoteric features (like multiple inheritance) I use when it makes sense. Having a coding style you stick to is invaluable. The code for this book was written over an eleven-month period, plus another three for the revision, but I can pick up the code I wrote at the beginning and still grok it because I commented and used some good conventions. If I can understand it, hopefully you can too.
What are the coding conventions used in the source? One of the greatest books I've ever read on programming was Code Complete (Microsoft Press). It's a handbook on how to program well (not just how to program). Nuances like the length of variable names, design of subroutines, and length of files are covered in detail in this book; I strongly encourage anyone who wants to become a great programmer to pick it up. You may notice that some of the conventions I use in this book are similar to the conventions described in Code Complete; some of them are borrowed from the great game programmers like John Carmack, and some of them are borrowed from source in DirectX, MFC, and Win32. I've tried really hard to make the code in this book accessible to everyone. I comment anything I think is unclear, I strive for good choice in variable names, and I try to make my code look clean while still trying to be fast. Of course, I can't please everyone. Assuredly, there are some C++ coding standards I'm probably not following correctly. There are some pieces of code that would get much faster with a little obfuscation.
8
If you've never used C++ before or are new to programming, this book is going to be extremely hard to digest. A good discussion on programming essentials and the C++ language is C++ Primer (Lippman et al.; Addison-Wesley Publishing).
Class/Structure Names MFC names its classes with a prefixed C. As an example, a class that represents the functionality of a button is called CButton. I like this fine, but due to namespace clashing, I instead prefix my own classes with a lowercase c for classes, a lowercase s for structs, a lowercase i for interfaces, and a lowercase e for enumerations (cButton or sButton). There is one notable exception. While most classes are intended to hide functionality away and act as components, there are a few classes/structures that are intended to be instantiated as basic primitives. So for basic mathematic primitives like points and matrices, I have no prefix, and I postfix with the dimension of the primitive (2D points are point2, 3D points are point3, etc.). This is to allow them to have the same look and feel as their closest conceptual neighbor, float. For the same reason, all of the mathematic primitives have many overloaded operators to simplify math-laden code.
Variable Names Semi-long variable names are a good thing. They make your code self- commenting. One needs to be careful though: Make them too long, and they distract from both the code itself and the process of writing it. I use short variables very sporadically; int i, j, k pop up a lot in my code for loops and whatnot, but besides that I strive to give meaningful names to the variables I use. Usually, this means that they have more than one word in them. The system I use specifies lowercase for the first word and initial cap for each word after that, with no underscores (an example would be int numObjects). If the last letter of a word is a capital letter, an underscore is placed to separate it from the next word (example: class cD3D_App). A popular nomenclature for variables is Hungarian notation, which we touch on in Chapter 1. I'm not hardcore about it, but generally my floats are prefixed with "f," my ints with "i," and my pointers with "p" (examples: float fTimer; int iStringSize; char* pBuffer). Note that the prefix counts as the first word, making all words after it caps. (I find pBuffer much more readable than pbuffer.) I also use prefixes to define special qualities of variables. Global variables are preceded with a "g_" (an example would be int g_hInstance); static variables are preceded with an "s_" (static float s_fTimer); and member variables of classes are preceded with an "m_" (int m_iNumElements).
Companion Files The companion files can be downloaded from the following web site:
9
http://www.wordware.com/files/dx9 These files include the source code discussed in the book along with the game Mobots Attack!. Each chapter (and the game) has its own workspace so you can use them independently of each other.
Chapter 1: Windows Overview Welcome, one and all, to the first stage of the journey into the depths of advanced 3D game development with DirectX 9.0. Before you can start exploring the world of 3D game programming, you need a canvas to work on. Basic operations like opening and closing a program, handling rudimentary input, and painting basic primitives must be discussed before you can properly understand more difficult topics. If you're familiar with the Windows API, you should breeze through this chapter; otherwise, hold on to your seat! In this chapter you are going to learn about: The theory behind Windows and developing with the Win32 API How Win32 game development differs from standard Windows programming Messages and how to handle them The infamous message pump Other methods of Windows programming such as MFC COM, or the component object model And much more!
A Word about Windows Windows programs are fundamentally different in almost every way from DOS programs. In traditional DOS programs, you have 100 percent of the processor time, 100 percent control over all the devices and files in the machine. You also need an intimate knowledge of all of the devices on a user's machine (you probably remember old DOS games, which almost always required you to input DMA and IRQ settings for sound cards). When a game crashed, you didn't need to worry too much about leaving things in a state for the machine to piece itself together; the user could just reboot. Some old 320x200x256 games would crash without even changing the video mode back to normal, leaving the user screen full of oversized text with the crash information. In Windows, things are totally different. When your application is running, it is sharing the processor with many other tasks, all running concurrently (at the same time). You can't hog control of the sound card, the video card, the hard disk, or any other system resource for that matter. The input and output is abstracted away, and you don't poll the keyboard or mess with interrupts; Windows manages all that for you. This is both a good and bad thing. On one hand, Windows applications have a consistent look and feel. Unless you want to get picky, almost any window you create is automatically familiar to Windows users. They already know how to use menus and toolbars, so if you build your application with the basic
10
Windows constructs, they can pick up the user interface quickly. Also, a lot of mundane GUI tasks are completely handled by the Windows API, such as displaying complex property pages, freeing you to write the interesting code. Aside
"Reinventing the wheel," or rewriting existing code, can make sense sometimes, especially when writing games. However, not on the scale of operating systems; nobody wants to reimplement the functionality of the Windows API.
On the other hand, you have to put a lot of faith into Windows and other applications. Until DirectX came around, you needed to use the default Windows drawing commands (called the GDI). While the GDI can automatically handle any bit depth and work on any monitor, it's not the speediest thing in the world. (In fact it is probably the slowest!) For this reason, many DOS developers swore off ever working in Windows. Pretty much the best you could do with graphics was rendering onto a bitmap that was then drawn into a window, which is pretty slow. You used to have to give up a lot when writing a Windows application. However, there are a lot of things that Windows can do that would be a nightmare to code in the old world of DOS. You can play sound effects using a single line of code (the PlaySound function), query the time stamp counter, use a robust TCP/IP network stack, get access to virtual memory, and the list goes on. Even though you have to take a few speed hits here and there, the advantages of Windows far outweigh the disadvantages. I'll be using the Win32 environment to write all of the applications for this book. Win32 is not a programming language; it is an application programming interface (API). In other words, it is a set of C functions that an application uses to make a Windows-compliant program. It abstracts away a lot of difficult operations like multitasking and protected memory, as well as providing interfaces to higherlevel concepts. Supporting menus, dialog boxes, and multimedia have well-established, fairly easy-touse (you may not believe me about this!) library functions written for that specific task. Windows is an extremely broad set of APIs. You can do just about anything, from playing videos to loading web pages. And for every task, there are a slew of different ways to accomplish it. There are some seriously large books devoted just to the more rudimentary concepts of Windows programming. Subsequently, the discussion here will be limited to what is relevant to allow you to continue on with the rest of the book. Instead of covering the tomes of knowledge required to set up dialogs with tree controls, print documents, and read/write keys in the registry, I'm going to deal with the simplest case: creating a window that can draw the world, passing input to the program, and having at least the beginnings of a pleasant relationship with the operating system. If you need any more info, there are many good resources out there on Windows programming.
Hungarian Notation All of the variable names in Windows land use what is called Hungarian notation. The name came from its inventor, Charles Simonyi, a now-legendary Microsoft programmer who happened to be Hungarian.
11
Hungarian notation is the coding convention of just prefixing variables with a few letters to help identify their type. Hungarian notation makes it easier to read other peoples' code and easy to ensure the correct variables are supplied to functions in the right format. However, it can be really confusing to people who haven't seen it before. Table 1.1 gives some of the more common prefixes used in most of the Windows and DirectX code that you'll see in this book.
Table 1.1: Some common Hungarian notation prefixes b
(example: bActive)
Variable is a BOOL, a C precursor to the Boolean type found in C++. BOOLs can be TRUE or FALSE.
l
(example: lPitch)
Variable is a long integer.
dw
(example: dwWidth)
Variable is a DWORD, or unsigned long integer.
w
(example: wSize)
Variable is a WORD, or unsigned short integer.
sz
(example:
Variable is a pointer to a string terminated by a zero (a standard C-
szWindowClass)
style string).
(example: lpData)
Variable is a pointer (lp is a carryover from the far pointers of the
p or lp
16-bit days; it means long pointer). A pointer-pointer is prefixed by pp or lplp, and so on.
h
(example:
Variable is a Windows handle.
hInstance)
General Windows Concepts Notepad.exe is probably the best example of a simple Windows program. It allows basic text input, lets you do some basic text manipulation like searching and using the clipboard, and also lets you load, save, and print to a file. The program appears in Figure 1.1.
12
Figure 1.1: Notepad.exe— as basic as a window gets The windows I show you how to create will be similar to this. A window such as this is partitioned into several distinct areas. Windows manages some of them, but the rest your application manages. The partitioning looks something like Figure 1.2.
Figure 1.2: The important GUI components of a window The main parts are: Title
This area appears in most windows. It gives the name of the window and provides access
Bar
to the system buttons that allow the user to close, minimize, or maximize an application. The only real control you have over the title bar is via a few flags in the window creation process. You can make it disappear, make it appear without the system icons, or make it thinner.
13
Menu
The menu is one of the primary forms of interaction in a GUI program. It provides a list of
Bar
commands the user can execute at any one time. Windows also controls this piece of the puzzle. You create the menu and define the commands, and Windows takes care of everything else.
Resize
Resize bars allow the user to modify the size of the window on screen. You have the
Bars
option of turning them off during window creation if you don't want to deal with the possibility of the window resizing.
Client
The client area is the meat of what you deal with. Windows essentially gives you a
Area
sandbox to play with in the client area. This is where you draw your scene. Windows can draw on parts of this region too. When there are scroll bars or toolbars in the application, they are intruding in the client area, so to speak.
Message Handling in Windows Windows also have something called focus. Only one window can have focus at a time. The window that has the focus is the only window that the user can interact with. The rest appear with a different color title bar, in the background. Because of this, only one application gets to know about the keyboard state. How does your application know this? How does it know things like when it has focus or when the user clicks on it? How does it know where its window is located on the screen? Well, Windows "tells" the application when certain events happen. Also, you can tell other windows when things happen (in this way, different windows can communicate with each other). Hold on though… How does Windows "tell" an application anything? This can be a very foreign concept to people used to console programming, but it is paramount to the way Windows works. The trick is, Windows (and other applications) share information by sending packets of data back and forth called messages. A message is just a structure that contains the message itself, along with some parameters that contain information about the message. The structure of a Windows message appears below: typedef struct tagMSG { HWND hwnd; UINT message; WPARAM wParam; LPARAM lParam;
14
DWORD time; POINT pt; } MSG; hwnd
Handle to the window that should receive the message
message
The identifier of the message. For example, the application receives a msg object when the window is resized, and the message member variable is set to the constant WM_SIZE.
wParam
Information about the message; dependent on the type of message
lParam
Additional information about the message
time
Specifies when the message was posted
pt
Mouse location when the message was posted
Explaining Message Processing What is an HWND? It's basically just an integer, representing a handle to a window. When a Windows application wants to tell another window to do something, or wants to access a volatile system object like a file on disk, Windows doesn't actually let it fiddle with pointers or give it the opportunity to trounce on another application's memory space. Everything is done with handles to objects. It allows the application to send messages to the object, directing it to do things. A good way to think of a handle is like a bar code. That is, a handle is a unique identifier that allows you, and Windows, to differentiate between different objects such as windows, bitmaps, fonts, and so on. Each window in Windows exists in a hierarchy and each has an identifier, or handle. A window handle is an integer describing a window; there can be up to 16,384 windows open simultaneously (214). When you tell Windows "I want the client rectangle for window x," Windows finds the window corresponding to handle x. It fetches the client rectangle of the window and passes it back to the application. If the window does not exist (for example if you give a bogus window handle), then an error is returned. Note
The Win32 API predated the current OOP frenzy in the programming world, and thus doesn't take advantage of some newer programming concepts like exception handling. Every function in Windows instead returns an error code (called an HRESULT) that tells the caller how the function did. A non-negative HRESULT means the function
15
succeeded. If the function returns a negative number, an error occurred. The FAILED() macro returns true if an HRESULT is negative. There are a myriad of different types of errors that can result from a function; two examples are E_FAIL (generic error) and E_NOTIMPL (the function was not implemented). An annoying side effect of having everything return an error code is that all the calls that retrieve information need to be passed a pointer of data to fill (instead of the more logical choice of just returning the requested data). Messages can tell a window anything from "Paint yourself" to "You have lost focus" or "User doubleclicked at location (x, y)." Each time a message is sent to a window, it is added to a message queue deep inside Windows. Each window has its own associated local message queue. A message queue ensures that each message gets processed in the order it gets received, even if it arrives while the application is busy processing other messages. In fact, when most Windows applications get stuck in an infinite loop or otherwise stop working, you'll notice because they'll stop processing messages, and therefore don't redraw or process input. So how does an application process messages? Windows defines a function that all programs must implement called the window procedure (or WndProc for short). When you create a window, you give Windows your WndProc function in the form of a function pointer. Then, when messages are processed, they are passed as parameters to the function, and the WndProc deals with them. So, for example, when theWndProc function gets passed a message saying "Paint yourself!" that is the signal for the window to redraw itself. When you send a message, Windows examines the window handle you provide, using it to find out where to send the message. The message ID describes the message being sent, and the parameters to the ID are contained in the two other fields in a message, wParam and lParam. Back in the 16-bit days, wParam was a 16-bit (word sized) integer and lParam was a 32-bit (long sized) integer, but with Win32 they're both 32 bits long. The messages wait in a queue until the application receives them. The window procedure should return 0 for any message it processes. All messages it doesn't process should be passed to the default Windows message procedure, DefWindowProc(). Windows can start behaving erratically if DefWindowProc doesn't see all of your non-processed messages. Don't worry if you're not getting all of this just yet; it will become clearer over the course of this book.
Hello World—Windows Style To help explain these ideas, let me show you a minimalist Win32 program and analyze what's going on. This code was modified from the default "Hello, World" code that Visual C++ 6.0 will automatically generate for you, but some of the things were removed, leaving this one of the most stripped-down Windows programs you can write.
16
Listing 1.1: One of the simplest possible Windows programs
/******************************************************************* *
Advanced 3D Game Programming using DirectX 9.0
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
Title: HelloWorld.cpp
*
Desc: Simple windows app
* copyright (c) 2002 by Peter A Walsh and Adrian Perez ******************************************************************/ #include "stdafx.h"
#define MAX_LOADSTRING 100
// Global Variables: HINSTANCE hInst;
// current instance
char szTitle[] = "Hello, World!";
// The title bar text
char szWindowClass[] = "Hello, World!"; // The title bar text
// Forward declarations of functions included in this code module: ATOM
MyRegisterClass(HINSTANCE hInstance);
BOOL
InitInstance(HINSTANCE, int);
LRESULT CALLBACK
WndProc(HWND, UINT, WPARAM, LPARAM);
LRESULT CALLBACK
About(HWND, UINT, WPARAM, LPARAM);
int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR
lpCmdLine,
int
nCmdShow)
{ // TODO: Place code here. MSG msg;
// Initialize global strings
17
MyRegisterClass(hInstance);
// Perform application initialization: if (!InitInstance (hInstance, nCmdShow)) { return FALSE; }
// Main message loop: while (GetMessage(&msg, NULL, 0, 0)) { TranslateMessage(&msg); DispatchMessage(&msg); } return msg.wParam; }
// // FUNCTION: MyRegisterClass() // // PURPOSE: Registers the window class. // //COMMENTS: // // This function and its usage is only necessary if you want this code // to be compatible with Win32 systems prior to the 'RegisterClassEx' // function that was added to Windows 95. It is important to call this // function so that the application will get 'well formed' small icons // associated with it. // ATOM MyRegisterClass(HINSTANCE hInstance)
18
{ WNDCLASSEX wcex; wcex.cbSize
= sizeof(WNDCLASSEX);
wcex.style
= CS_HREDRAW | CS_VREDRAW;
wcex.lpfnWndProc
= (WNDPROC)WndProc;
wcex.cbClsExtra
= 0;
wcex.cbWndExtra
= 0;
wcex.hInstance
= hInstance;
wcex.hIcon
= LoadIcon(hInstance, (LPCTSTR)IDI_APPLICATION);
wcex.hCursor
= LoadCursor(NULL, IDC_ARROW);
wcex.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH); wcex.lpszMenuName = NULL; wcex.lpszClassName = szWindowClass; wcex.hIconSm
= LoadIcon(wcex.hInstance,
(LPCTSTR)IDI_APPLICATION); return RegisterClassEx(&wcex); }
// //
FUNCTION: InitInstance(HANDLE, int)
// //
PURPOSE: Saves instance handle and creates main window
// //
COMMENTS:
// //
In this function, we save the instance handle in a global variable
and
//
create and display the main program window.
// BOOL InitInstance(HINSTANCE hInstance, int nCmdShow) {
19
HWND hWnd;
hInst = hInstance; // Store instance handle in our global variable
hWnd = CreateWindow( szWindowClass,
// Name of the window class to use for this
window // registered in MyRegisterClass szTitle,
// Title of the application
WS_OVERLAPPEDWINDOW, // Style that Windows should make our window with // (this is the 'default' window style for windowed apps) 20,
// Starting X of the window
20,
// Starting Y of the window
640,
// Width of the window
480,
// Height of the window
NULL,
// Handle of our parent window (Null, since we have none)
NULL,
// Handle to our menu (Null, since we don't have one)
hInstance, // Instance of our running application NULL);
// Pointer to window-creation data (we provide none)
if (!hWnd) { return FALSE; }
ShowWindow(hWnd, nCmdShow); UpdateWindow(hWnd);
return TRUE; }
20
// // FUNCTION: WndProc(HWND, unsigned, WORD, LONG) // // PURPOSE: Processes messages for the main window. // // WM_PAINT
- Paint the main window
// WM_DESTROY - post a quit message and return // // LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) { PAINTSTRUCT ps; HDC hdc; char szHello[] = "Hello, you crazy world you!";
switch (message) { case WM_PAINT: hdc = BeginPaint(hWnd, &ps); // TODO: Add any drawing code here... RECT rt; GetClientRect(hWnd, &rt); DrawText(hdc, szHello, strlen(szHello), &rt, DT_CENTER | DT_VCENTER | DT_SINGLELINE ); EndPaint(hWnd, &ps); break; case WM_DESTROY: PostQuitMessage(0); break; default: return DefWindowProc(hWnd, message, wParam, lParam);
21
} return 0; }
It's easy to get worried when you think this is one of the simplest Windows programs you can write, and it's still over 100 lines long. The good thing is that the code above is more or less common to all Windows programs. Most Windows programmers don't remember the exact order everything goes in; they just copy the working Windows initialization code from a previous application and use it like it is their own!
Explaining the Code Every C/C++ program has its entry point in main(), where it is passed control from the operating system. In Windows, things work a little differently. There is some code that the Win32 API runs first, before letting your code run. The actual stub for main() lies deep within the Win32 DLLs where you can't touch it. However, this application starts at a different point: a function called WinMain(). Windows does its setup work when your application is first run, and then calls WinMain(). This is why when you debug a Windows app "WinMain" doesn't appear at the bottom of the call stack; the internal DLL functions that called it are. WinMain is passed the following parameters (in order): The instance of the application (another handle, this one representing an instantiation of a running executable). Each process has a separate instance handle that uniquely identifies the process to Windows. This is different from window handles, as each application can have many windows under its control. You need to hold on to this instance, as certain Windows API calls need to know what instance is calling them. Think of an instance as just a copy, or even as an image, of the executable in memory. Each executable has a handle so that Windows can tell them apart, manage them, and so on. An HINSTANCE of another copy of your application currently running. Back in the days before machines had much memory, Windows would have multiple instances of a running program share memory. These days each process is run in its own separate memory space, so this parameter is always NULL. It remains this way so that legacy Windows applications still work. A pointer to the command line string. When the user drags a file onto an executable in Explorer (not a running copy of the program), Windows runs the program with the first parameter of the command line being the path and filename of file dragged onto it. This is an easy way to do dragand-drop. The hard way involves OLE/COM, but let's keep OLE under a restraining order. It is useful, but at the price of being a seriously ugly piece of work. A set of flags describing how the window should initially be drawn (such as fullscreen, minimized, etc.).
22
The conceptual flow of the function is to do the following: WinMain Register the application class with Windows Create the main window while( Someone hasn't told us to exit ) Process any messages that Windows has sent us MyRegisterClass takes the application instance and tells Windows about the application (registering it, in essence). InitInstance creates the primary window on the screen and starts it drawing. Then the code enters a while loop that remains in execution until the application quits. The function GetMessage looks at the message queue. It always returns 1 unless there is a specific system message in the queue: This is the "Hey you! Quit! Now!!" message and has the message ID WM_QUIT. If there is a message in the queue, GetMessage will remove it and fill it into the message structure, which is the "msg" variable above. Inside the while loop, you first take the message and translate it using a function called TranslateMessage. This is a convenience function. When you receive a message saying a key has been pressed or released, you get the specific key as a virtual key code. The actual values for the IDs are arbitrary, but the namespace is what you care about: When the letter "a" is pressed, one of the message parameters is equivalent to the #define VK_A. Since that nomenclature is a pain to deal with if you're doing something like text input, TranslateMessage does some housekeeping, and converts the parameter from "VK_A" to "(char)'a' ". This makes processing regular text input much easier. Keys without clear ASCII equivalents, such as Page Up and Left Arrow, keep their virtual key code values (VK_PRIOR and VK_LEFT respectively). All other messages go through the function and come out unchanged. The second function, DispatchMessage, is the one that actually processes it. Internally, it looks up which function was registered to process messages (in MyRegisterClass) and sends the message to that function. You'll notice that the code never actually calls the window procedure. That's because Windows does it for you when you ask it to with the DispatchMessage function. Think of this while loop as the central nervous system for any Windows program. It constantly grabs messages off the queue and processes them as fast as it can. It's so universal it actually has a special name: the message pump. Whenever you see a reference to a message pump in a text, or optimizing message pumps for this application or that, that's what it is in reference to.
Registering the Application MyRegisterClass() fills a structure that contains the info Windows needs to know about your application before it can create a window, and passes it to the Win32 API. This is where you tell Windows what to make the icon for the application that appears in the taskbar (hIcon, the large version, and hIconSm, the smaller version). You can also give it the name of the menu bar if you ever decide to use one. (For now
23
there is none, so it's set to 0.) You need to tell Windows what the application instance is (the one received in the WinMain); this is the hInstance parameter. You also tell it which function to call when it processes messages; this is the lpfnWndProc parameter. The window class has a name as well, lpszClassName, that is used to reference the class later in the CreateWindow function. Warning
A window class is completely different from a C++ class. Windows predated the popularity of the C++ language, and therefore some of the nomenclature has a tendency to clash.
Initializing the Window InitInstance creates the window and starts the drawing process. The window is created with a call to CreateWindow, which has the following prototype: HWND CreateWindow( LPCTSTR lpClassName, LPCTSTR lpWindowName, DWORD dwStyle, int x, int y, int nWidth, int nHeight, HWND hWndParent, HMENU hMenu, HANDLE hInstance, LPVOID lpParam ); lpClassName
A null-terminated string giving the class name for the window class that was registered with RegisterClass. This defines the basic style of the window, along with which WndProc will be handling the messages (you can create more than one window class per application).
lpWindowName
The title of the window. This will appear in the title bar of the window and in the taskbar.
dwStyle
A set of flags describing the style for the window (such as having thin borders,
24
being unresizable, and so on). For these discussions windowed applications will all use WS_OVERLAPPEDWINDOW (this is the standard-looking window, with a resizable edge, a system menu, a title bar, etc.). However, full-screen applications will use the WS_POPUP style (no Windows features at all, not even a border; it's just a client rectangle).
x, y
The x and y location, relative to the top left corner of the monitor (x increasing right, y increasing down), where the window should be placed.
nWidth,
The width and height of the window.
nHeight
hWndParent
A window can have child windows (imagine a paint program like Paint Shop Pro, where each image file exists in its own window). If this is the case and you are creating a child window, pass the HWND of the parent window here.
hMenu
If an application has a menu (yours doesn't), pass the handle to it here.
hInstance
This is the instance of the application that was received in WinMain.
lpParam
Pointer to extra window creation data you can provide in more advanced situations (for now, just pass in NULL).
The width and height of the window that you pass to this function is the width and height for the entire window, not just the client area. If you want the client area to be a specific size, say 640 by 480 pixels, you need to adjust the width and height passed to account for the pixels needed for the title bar, resize bars, etc. You can do this with a function called AdjustWindowRect (discussed later in the chapter). You pass a rectangle structure filled with the desired client rectangle, and the function adjusts the rectangle to reflect the size of the window that will contain the client rectangle, based on the style you pass it (hopefully the same style passed to CreateWindow). A window created with WS_POPUP has no extra Windows UI features, so the window will go through unchanged. WS_OVERLAPPEDWINDOW has to add space on each side for the resize bar and on the top for the title bar. If CreateWindow fails (this will happen if there are too many windows or if it receives bad inputs, such as an hInstance different from the one provided in MyRegisterClass), you shouldn't try processing any messages for the window (since there is no window!) so return false. This is handled in WinMain by
25
exiting the application before entering the message pump. Normally, before exiting, you'd bring up some sort of pop-up alerting the user to the error, instead of just silently quitting. Otherwise, call ShowWindow, which sets the show state of the window just created (the show state was passed to as the last formal parameter in WinMain), and Update- Window, which sends a paint message to the window so it can draw itself. Warning
CreateWindow calls the WndProc function several times before it exits! This can sometimes cause headaches in getting certain Windows programs to work. Before the function returns and you get the window handle back, WM_CREATE, WM_MOVE, WM_SIZE, and WM_PAINT (among others) are sent to the program through the WndProc. If you're using any components that need the HWND of a program to perform work (a good example is a DirectX window, whose surface must resize itself whenever it gets a WM_SIZE message), you need to tread very carefully so that you don't try to resize the surface before it has been initialized. One way to handle this is to record your window's HWND inside WM_CREATE, since one of the parameters that gets passed to the WndProc is the window handle to receive the message.
You may wonder, when an event such as an error occurs, how would you alert the user? Unfortunately, you no longer have the printf and getchar commands to print out error messages, so instead you have to create dialogs that present information such as why the program failed, to the user. Creating complex dialogs with buttons and edit boxes and whatnot are generally not needed for creating games (usually you create your own interface inside the game); however, there are some basic dialogs that Windows can automatically create, such as the infamous pop-up window you see when you attempt to exit any sort of document editing software that says "Save SomeFile.x before exiting?" and has two buttons marked "Yes" and "No." The function you use to automate the dialog creation process is called MessageBox. It is one of the most versatile and useful Windows functions. Take a look at its prototype in the following: int MessageBox( HWND hWnd, LPCTSTR lpText, LPCTSTR lpCaption, UINT uType ); hWnd
Handle to the owner of the window (this is generally the application's window handle).
26
lpText
Text for the inside of the message box.
lpCaption
Title of the message box.
uType
A set of flags describing the behavior of the message box. The flags are described in Table 1.2.
The function displays the dialog on the desktop and does not return until the box is closed.
Table 1.2: A set of the common flags used with MessageBox MB_OK
The message box has just one button marked OK. This is the default behavior.
MB_ABORTRETRYIGNORE
Three buttons appear—Abort, Retry, and Ignore.
MB_OKCANCEL
Two buttons appear—OK and Cancel.
MB_RETRYCANCEL
Two buttons appear—Retry and Cancel.
MB_YESNO
Two buttons appear—Yes and No.
MB_YESNOCANCEL
Three buttons appear—Yes, No, and Cancel.
MB_ICONEXCLAMATION,
An exclamation mark icon is displayed.
MB_ICONWARNING
MB_ICONINFORMATION,
An information icon (a lowercase i inscribed in a circle)
MB_ICONASTERISK
is displayed.
MB_ICONQUESTION
A question mark icon is displayed.
27
MB_ICONSTOP,
A stop sign icon is displayed.
MB_ICONERROR, MB_ICONHAND
The return value of MessageBox depends on which button was pressed. Table 1.3 gives the possible return values. Note that this is one of the rare Windows functions that does not return an HRESULT.
Table 1.3: Return values for MessageBox IDABORT
The Abort button was pressed.
IDCANCEL
The Cancel button was pressed.
IDIGNORE
The Ignore button was pressed.
IDNO
The No button was pressed.
IDOK
The OK button was pressed.
IDRETRY
The Retry button was pressed.
IDYES
The Yes button was pressed.
WndProc—The Message Pump WndProc is the window procedure. This is where everything happens in a Windows application. Since this application is so simple, it will only process two messages (more complex Windows programs will need to process dozens upon dozens of messages). The two messages that probably every Win32 application handles are WM_PAINT (sent when Windows would like the window to be redrawn) and WM_DESTROY (sent when the window is being destroyed). An important thing to note is that any message you don't process in the switch statement goes into DefWindowProc, which defines the default
28
behavior for every Windows message. Anything not processed needs to go into DefWindowProc for the application to behave correctly. System messages, such as the message received when the window is being created and destroyed, are sent by Windows internally. You can post messages to your own application (and other applications) with two functions: PostMessage and SendMessage. PostMessage adds the message to the application's message queue to be processed in the message pump. SendMessage actually calls the WndProc with the given message itself. One extremely important point to remember when you're doing Windows programming is that you don't need to memorize any of this. Very few, if any, people know all the parameters to each and every one of the Windows functions; usually it's looked up in MSDN, copied from another place, or filled in for you by a project wizard. So don't worry if you're barely following some of this stuff. One of the most useful investments I ever made was to purchase a second monitor. That way I can program on my main screen with MSDN up on the other, which means I don't have to keep task switching between applications. One thing you might notice is that for a program that just says "Hello, World!" there sure is a lot of code. Most of it exists in all Windows programs. All applications need to register themselves, they all need to create a window if they want one, and they all need a window procedure. While it may be a bit on the long side, the program does a lot. You can resize it, move it around the screen, have it become occluded by other windows, minimize, maximize, and so on. Windows users automatically take this functionality for granted, but there is a lot of code taking place out of sight.
Manipulating Window Geometry Since for now the application's use of Windows is so restricted, you only need to concern yourself with two basic Windows structures that are used in geometry functions: POINT and RECT. In Windows, there are two coordinate spaces. One is the client area coordinate space. The origin (0,0) is the top left corner of the window (known as client space). Coordinates relative to the client area don't need to change when the window is moved around the screen. The other coordinate space is the desktop coordinate space. This space is absolute, and the origin is the top left corner of the screen (also known as screen space). Windows uses the POINT structure to represent 2D coordinates. It has two long integers, one for the horizontal component and one for the vertical:
typedef struct tagPOINT { LONG x; LONG y; } POINT;
29
Since all windows are rectangular, Windows has a structure to represent a rectangle. You'll notice that essentially the structure is two points end to end, the first describing the top left corner of the rectangle, the other describing the bottom right. typedef struct _RECT { LONG left; LONG top; LONG right; LONG bottom; } RECT; left
Left side of the window.
top
Top of the window.
right
Right side of the window (width is right-left).
bottom
Bottom side of the window (height is bottom-top).
To get the client rectangle of a window you can use the function GetClient- Rect. The left and top members are always zero, and the right and bottom give you the width and height of the window. BOOL GetClientRect( HWND hWnd, LPRECT lpRect ); hWnd
Handle to the window you want information about.
lpRect
Pointer to a RECT structure you would like filled with the client rectangle.
Once you have the client rectangle, you often need to know what those points are relative to the desktop coordinate space. ClientToScreen, which has the following prototype, provides this functionality: BOOL ClientToScreen( HWND hWnd, LPPOINT lpPoint
30
); hWnd
Handle to the window the client point is defined in.
lpPoint
Pointer to the client point; this point is changed to screen space.
To change the rectangle you get through GetClientRect to screen space, you can use the ClientToScreen function on the bottom and right members of a rectangle. Slightly inelegant, but it works. One thing that can mess up window construction is determining the width and height of the window. You could say you want a client rectangle that is 800 pixels by 600 pixels (or some other resolution), but you call CreateWindow giving the dimensions of the whole window, including any resize, title bar, and menu bars. Luckily, you can convert a rectangle representing the client rectangle to one representing the window dimensions using AdjustWindowRect. It pushes all of the coordinates out to accommodate the window style dwStyle, which should be the same one used in CreateWindow for it to work correctly. For non-pop-up windows, this will make the top and left coordinates negative. BOOL AdjustWindowRect( LPRECT lpRect, DWORD dwStyle, BOOL bMenu ); lpRect
Pointer to the RECT structure to be adjusted.
dwStyle
Style of the intended window, this defines how much to adjust each coordinate. For example, WS_POPUP style windows aren't adjusted at all.
bMenu
Boolean that is TRUE if the window will have a menu. If, like in this case, there is no menu then you can just pass FALSE for this parameter.
Windows has a full-featured graphics library that performs operations on a handle to a graphics device. The package is called the GDI, or Graphical Device Interface. It allows users to draw, among other things, lines, ellipses, bitmaps, and text (I'll show you its text painting ability in a later chapter). The sample program uses it to draw the "Hello, World!" text on the screen. I'll show you more of the GDI's functions later in the book.
Important Window Messages Most of the code in this book uses Windows as a jumping-off point—a way to put a window up on the screen that allows you to draw in it. I'll only be showing you a small subset of the massive list of window
31
messages in Windows, which is a good thing since they can get pretty mind-numbing after a while. Table 1.4 describes the important messages and their parameters.
Table 1.4: Some important window messages WM_CREATE
Sent to the application when Windows has completed creating its window but before it is drawn. This is the first time the application will see what the HWND of its window is.
WM_PAINT
Sent to the application when Windows wants the window to draw itself. Parameters: (HDC) wParam A handle to the device context for the window that you can draw in.
WM_ERASEBKGND
Called when the background of a client window should be erased. If you process this message instead of passing it to DefWindowProc, Windows will let you erase the background of the window (later, I'll show you why this can be a good thing). Parameters: (HDC) wParam A handle to the device context to draw in.
WM_DESTROY
Sent when the window is being destroyed.
WM_CLOSE
Sent when the window is being asked to close itself. This is where you can, for example, ask for confirmation before closing the window.
WM_SIZE
Sent when the window is resized. When the window is resized, the top left location stays the same (so when you resize from the top left, both a WM_MOVE and a WM_SIZE message are sent). Parameters: wParam Resizing flag. There are other flags, but the juicy one is SIZE_MINIMIZED; it's sent when the window is minimized.
32
LOWORD(lParam) New width of the client area (not total window). HIWORD(lParam) New height of the client area (not total window).
WM_MOVE
Sent when the window is moved. Parameters: (int) (short) LOWORD (lParam) New upper left x coordinate of client area. (int) (short) HIWORD (lParam) New upper left y coordinate of client area.
WM_QUIT
Last message the application gets; upon its receipt the application exits. You never process this message, as it actually never gets through to WndProc. Instead, it is caught in the message pump in WinMain and causes that loop to drop out and the application to subsequently exit.
WM_KEYDOWN
Received every time a key is pressed. Also received after a specified time for auto-repeats. Parameters: (int) wParam The virtual key code for the pressed key. If you call TranslateMessage on the message before processing it, if it is a key with an ASCII code equivalent (letters, numbers, punctuation marks) it will be equivalent to the actual ASCII character.
WM_KEYUP
Received when a key is released. Parameters: (int) wParam The virtual key code for the released key.
WM_MOUSEMOVE
MouseMove is a message that is received almost constantly. Each time the mouse moves in the client area of the window, the application gets notified of the new location of the mouse cursor relative to the origin of the client area. Parameters: LOWORD(lParam)
33
The x-location of the mouse, relative to the upper left corner of the client area. HIWORD(lParam) The y-location of the mouse, relative to the upper left corner of the client area. wParam Key flags. This helps you tell what the keyboard state is for special clicks (such as Alt-left click, for example). Test the key flags to see if certain flags are set. The flags are: MK_CONTROL: Indicates the Control key is down. MK_LBUTTON: Indicates the left mouse button is down. MK_MBUTTON: Indicates the middle mouse button is down. MK_RBUTTON: Indicates the right mouse button is down. MK_SHIFT: Indicates the Shift key is down.
WM_LBUTTONDOWN
This message is received when the user presses the left mouse button in the client area. You only receive one message when the button is pressed, as opposed to receiving them continually while the button is down. Parameters: LOWORD (lParam) The x-location of the mouse, relative to the upper left corner of the client area. HIWORD (lParam) The y-location of the mouse, relative to the upper left corner of the client area. wParam Key flags. This helps you tell what the keyboard state is for special clicks (such as Alt-left click, for example). Test the key flags to see if certain flags are set. The flags are: MK_CONTROL: Indicates the Control key is down. MK_MBUTTON: Indicates the middle mouse button is down. MK_RBUTTON: Indicates the right mouse button is down. MK_SHIFT: Indicates the Shift key is down.
WM_MBUTTONDOWN
You receive this message when the user presses the middle mouse button in the client area. You only receive one message when the button is pressed, as opposed to receiving them continually while the button is down. Parameters: LOWORD (lParam) The x-location of the mouse, relative to the upper left
34
corner of the client area. HIWORD (lParam) The y-location of the mouse, relative to the upper left corner of the client area. wParam Key flags. This helps you tell what the keyboard state is for special clicks (such as Alt-left click, for example). Test the key flags to see if certain flags are set. The flags are: MK_CONTROL: If set, Control key is down. MK_LBUTTON: If set, left mouse button is down. MK_RBUTTON: If set, right mouse button is down. MK_SHIFT: If set, Shift key is down.
WM_RBUTTONDOWN
You receive this message when the user presses the right mouse button in the client area. You only receive one message when the button is pressed, as opposed to receiving them continually while the button is down. Parameters: LOWORD(lParam) The x-location of the mouse, relative to the upper left corner of the client area. HIWORD(lParam) The y-location of the mouse, relative to the upper left corner of the client area. wParam Key flags. This helps you tell what the keyboard state is for special clicks (such as Alt-left click, for example). Test the key flags to see if certain flags are set. The flags are: MK_CONTROL: Indicates the Control key is down. MK_LBUTTON: Indicates the left mouse button is down. MK_MBUTTON: Indicates the middle mouse button is down. MK_SHIFT: Indicates the Shift key is down.
WM_LBUTTONUP
Received when the user releases the left mouse button in the client area. Parameters: The parameters are the same as for WM_LBUTTONDOWN.
WM_MBUTTONUP
Received when the user releases the middle mouse button in the client area. Parameters:
35
The parameters are the same as for WM_MBUTTONDOWN.
WM_RBUTTONUP
Received when the user releases the right mouse button in the client area. Parameters: The parameters are the same as for WM_RBUTTONDOWN.
WM_MOUSEWHEEL
Most new mice come equipped with a z-axis control, in the form of a wheel. It can be spun forward and backward and clicked. If it is clicked, it generally sends middle mouse button messages. However, if it is spun forward or backward, the following parameters are passed. Parameters: (short) HIWORD(wParam) The amount the wheel has spun since the last message. A positive value means the wheel was spun forward (away from the user). A negative value means the wheel was spun backward (towards the user). (short) LOWORD(lParam) The x-location of the mouse, relative to the upper left corner of the client area. (short) HIWORD(lParam) The y-location of the mouse, relative to the upper left corner of the client area. LOWORD(wParam) Key flags. This helps you tell what the keyboard state is for special clicks (such as Alt-left click, for example). Test the key flags to see if certain flags are set. The flags are: MK_CONTROL: Indicates the Control key is down. MK_LBUTTON: Indicates the left mouse button is down. MK_MBUTTON: Indicates the middle mouse button is down. MK_RBUTTON: Indicates the right mouse button is down. MK_SHIFT: Indicates the Shift key is down.
MFC As you have probably guessed already, programming Windows applications isn't the easiest thing in the world. People tend to fear difficult things, blowing them up in their mind, making them many times worse than they actually are. While it is ugly code, a lot of the stuff required to make Windows work is used in every application and should be abstracted away. While there are many libraries on the market to do this, the predominant one is the one made by Microsoft, called MFC.
36
MFC, or the Microsoft Foundation Classes, is a system of classes designed to encapsulate the Win32 API. It tries to create simple ways to do the most common tasks in Windows programs. Your application derives from CWinApp, your window from CWnd, your dialogs from CDialog, etc. This makes applications much easier to write, as a lot of the muscle work required in Windows is taken care of for you. MFC is a fantastic tool for making quick front ends to existing code. However, things aren't as great as they first appear. First of all, MFC is geared towards document view type applications (like WordPad). It has loads of code to support docking toolbars, handle modeless dialogs, and work with the GDI. Unfortunately, those things aren't of much use if all you want to do is make 3D games. Another inherent MFC problem is the size and speed penalties. The added functionality given by MFC comes at a price: The DLLs are fairly large, and unless they're already loaded in memory, they can hit your application in load time. Finally, MFC isn't the perfect bedfellow for DirectX. The programming models with which both APIs are designed are different. For example, windowed Direct3D applications need to know when the window it is drawing is moved or resized. However, getting notified of such changes isn't an instant event in MFC, particularly if the DirectX window is a document window that can move relative to its parent window. These hurdles are not insurmountable; they're just kind of a pain. Most of your applications will run in full-screen mode anyway and don't need the GUI bells and whistles that MFC provides. MFC won't be in any of the code that I show you, so there is no point in going into any more detail about it. However, if you seriously start developing a 3D game, you'll need utilities to help manage your data. When the day comes that you need to build those utilities, crack open a good book on MFC and you'll have stuff up and running in no time. One of the best books on MFC is Professional MFC with Visual C++ by Mike Blaszczak, published by Wrox Press.
Class Encapsulation So, now that you can create a window, I'm going to show you how to design a framework that will sit beneath the Direct3D and other game code and simplify the programming tasks needed in all of the other applications you'll be building in the book. You'll also learn how to hide that code so that you never need to look at it again. As a first step, let's look at a list of benefits that could be gained from the encapsulation. In no particular order, it would be good if the application had: The ability to control and reimplement the construction and destruction of the application object. The ability to automatically create standard system objects (right now just the application window, but later on Direct3D, DirectInput, and so on), and facilities to create your own. The ability to add objects that can listen to the stream of window messages arriving to the application and add customized ways to handle them. A simple main loop that runs repeatedly until the application exits.
37
The way I'll do this is with two classes. One of them will abstract the Windows code that needs to be run; it is called cWindow. It will be used by a bigger class that is responsible for actually running the application. This class is called cApplication. Each new application that you create (with a couple of exceptions) will be subclassed from cApplication. Whenever something goes wrong during the execution that requires the application to exit, the infrastructure is designed so that an error can be thrown. The entire application is wrapped around a try/catch block, so any errors are caught in WinMain, and the application is shut down. A text message describing the error can be passed in the thrown exception, and the string is popped up using a message box before the application exits. I chose to do this because it can be easier than the alternative of having every single function return an error code, and having each function check the result of each function it calls. Exceptions get thrown so rarely that the added complexity that error codes add seems pretty unnecessary really. With exception handling, the code is nice and clean. The error that almost all of the code in this book throws is called cGameError, and is defined in Listing 1.2. Listing 1.2: The cGameError object and eResult enumeration
class cGameError { string m_errorText; public: cGameError( char* errorText ) { DP1("***\n*** [ERROR] cGameError thrown! text: [%s]\n***\n", errorText ); m_errorText = string( errorText ); }
const char* GetText() { return m_errorText.c_str(); } };
38
enum eResult { resAllGood
= 0,
// function passed with flying colors
resFalse
= 1,
// function worked and returns 'false'
resFailed
= -1,
// function failed miserably
resNotImpl
= -2,
// function has not been implemented
resForceDWord = 0x7FFFFFFF };
The window abstraction, cWindow, is fairly straightforward. MyRegister- Class is replaced with cWindow::RegisterClass, MyInitInstance is now cWindow::InitInstance, and WndProc is now a static function cWindow::WndProc. The function is static because non-static class functions have a hidden first variable passed in (the this pointer) that is not compatible with the WndProc function declaration. Later on I'll define a child class for you that allows the creation of full-screen ready windows. In practice, this is the same as a normal window; the only change is that WS_POPUP is used as the window style instead of WS_OVERLAPPED-WINDOW. The message pump that you'll come to know and love (although probably hate at the start!) is encapsulated in two functions. HasMessages() checks the queue and sees if there are any messages waiting to be processed, returning true if there are any. Pump() processes a single message, sending it off to WndProc using TranslateMessage/DispatchMessage. When Pump receives the WM_QUIT message, which again is a notification from Windows that the application should exit, it returns resFalse. Special care needs to be taken to handle thrown exceptions that happen during the window procedure. You see, between the execution of DispatchMessage and WndProc, the call stack meanders into some kernel DLL functions. If a thrown exception flies into them, bad stuff happens (anything from your program crashing to your machine crashing). To handle this, any and all exceptions are caught in the WndProc and saved in a temporary variable. When Pump finishes pumping a message, it checks the temporary variable to see if an error was thrown. If there is an error waiting, Pump rethrows the error and it rises up to WinMain. class cWindow { protected:
int m_width, m_height;
39
HWND m_hWnd; std::string m_name; bool m_bActive; static cWindow* m_pGlobalWindow;
public:
cWindow( int width, int height, const char* name = "Default window name" ); ~cWindow();
virtual LRESULT WndProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam );
virtual void RegisterClass( WNDCLASSEX* pWc = NULL ); virtual void InitInstance(); HWND GetHWnd(); bool IsActive(); bool HasMessages(); eResult Pump(); static cWindow* GetMainWindow(); };
inline cWindow* MainWindow(); m_width,
Width and height of the client rectangle of the window. This is different from
m_height
the width and height of the actual window.
40
m_hWnd
Handle to the window. Use the public function GetHWnd to get access to it outside the class.
m_name
The name of the window used to construct the window class and window.
m_bActive
Boolean value; TRUE if the window is active (a window is active if it is currently in the foreground).
m_pGlobalWindow
Static variable that points to the single instantiation of a cWindow class for an application. Initially set to NULL.
cWindow(…)
Constructs a window object. You can only create one instance of this object; this is verified by setting the m_pGlobalWindow object.
~cWindow()
The destructor destroys the window and sets the global window variable to NULL so that it cannot be accessed any longer.
WndProc()
Window procedure for the class. Called by a hidden function inside Window.cpp.
RegisterClass(…)
Virtual function that registers the window class. This function can be overloaded in child classes to add functionality, such as a menu or different WndProc.
InitInstance()
Virtual function that creates the window. This function can be overloaded in child classes to add functionality, such as changing the window style.
GetHWnd()
Returns the window handle for this window.
IsActive()
Returns true if the application is active and in the foreground.
41
HasMessages()
True if the window has any messages in its message queue waiting to be processed. Uses PeekMessage with PM_NOREMOVE.
Pump()
Pumps the first message off the queue and dispatches it to the WndProc. Returns resAllGood, unless the message gotten off the queue was WM_QUIT, in which case it returns resFalse.
GetMainWindow()
Public function; used by the global function MainWindow to gain access to the only window object.
MainWindow()
Global function that returns the single instance of the cWindow class for this program. Any piece of code can use this to query information about the window. For example, any code can get the hWnd for the window by calling MainWindow()->GetHWnd().
Finally, there is the Big Kahuna—cApplication. Child classes will generally only reimplement SceneInit and DoFrame. However, other functions can be reimplemented if added functionality, like the construction of extra system objects, is needed. The game presented in Chapter 11 will use several other system objects that it will need to construct. class cApplication { protected:
string m_title; int
m_width;
int
m_height;
bool
m_bActive;
static cApplication*
m_pGlobalApp;
virtual void InitPrimaryWindow(); virtual void InitGraphics(); virtual void InitInput();
42
virtual void InitSound(); virtual void InitExtraSubsystems();
public:
cApplication(); virtual ~cApplication();
virtual void Init();
virtual void Run(); virtual void DoFrame( float timeDelta ); virtual void DoIdleFrame( float timeDelta ); virtual void ParseCmdLine( char* cmdLine );
virtual void SceneInit(); virtual void SceneEnd();
void Pause(); void UnPause();
static cApplication* GetApplication();
static void KillApplication(); };
inline cApplication* Application();
HINSTANCE AppInstance();
cApplication* CreateApplication();
43
m_title
Title for the application. Sent to the cWindow when it is constructed.
m_width, m_height
Width and height of the client area of the desired window.
m_bActive
True if the application is active and running. When the application is inactive, input isn't received and the idle frame function is called.
m_pGlobalApp
Static pointer to the single global instance of the application.
InitPrimaryWindow(…)
Virtual function to initialize the primary window for this application. If bExclusive is true, a pop-up window is created in anticipation of fullscreen mode. If it is false, a regular window is made.
InitGraphics()
This function will be discussed in Chapter 2.
InitInput()
This function will be discussed in Chapter 3.
InitSound()
This function will be discussed in Chapter 4.
InitExtraSubsystems(…)
Virtual function to initialize any additional subsystems the application wants before the scene is initialized.
cApplication()
Constructor; fills in default values for the member variables.
~cApplication()
Shuts down all of the system objects.
Init()
Initializes all of the system objects (which I'll show you in Chapter 4).
Run()
Main part of the application. Displays frames as fast as it can until the WM_QUIT message arrives.
44
DoFrame(…)
This function is called every frame by Run. In it, the subclassing application should perform all game logic and draw the frame. timeDelta is a floating-point value representing how much time elapsed since the last frame. This is to aid in making applications perform animations at constant speed independent of the frame rate of the machine.
DoIdleFrame(…)
This function is called by Run if the application is currently inactive. Most of the applications that I'll show you won't need this function, but it exists for completeness.
ParseCmdLine(…)
Virtual function to allow subclasses to view the command line before anything is run.
SceneInit()
Virtual function; overload this to perform scene-specific initialization. Called after the system objects are created.
SceneEnd()
Virtual function; overload to perform scene-specific shutdown code.
Pause()
Pause the application.
UnPause()
Un-pause the application.
GetApplication()
Public accessor function to acquire the global application pointer.
KillApplication()
Kills the application and invalidates the global application pointer.
Application()
Global inline function to simplify access to the global application pointer. Equivalent to cApplication::GetApplication().
AppInstance()
Global inline function to acquire the HINSTANCE of this application.
45
CreateApplication()
This global function is undefined and must be declared in all further applications. It creates an application object for the code inside GameLib to use. If an application subclasses cApplication with a class cMyApplication, CreateApplication should simply return (new cMyApplication).
The WinMain for the application is abstracted away from child applications, hidden inside the GameLib code. Just so you don't miss it, the code for it appears in Listing 1.3. Listing 1.3: WinMain
int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR
lpCmdLine,
int
nCmdShow)
{
cApplication* pApp;
g_hInstance = hInstance; try { pApp = CreateApplication();
pApp->ParseCmdLine( lpCmdLine );
pApp->Init(); pApp->SceneInit(); pApp->Run(); } catch( cGameError& err ) {
46
/** * Knock out the graphics before displaying the dialog, * just to be safe. */ if( Graphics() ) { Graphics()->DestroyAll(); } MessageBox( NULL, err.GetText(), "Error!", MB_OK|MB_ICONEXCLAMATION ); // Clean everything up delete pApp; return 0; }
delete pApp; return 0; }
COM: The Component Object Model Component-based software development is big business. Instead of writing one deeply intertwined piece of software (called monolithic software development), a team writes a set of many smaller components that talk to one another. This ends up being an advantage because if the components are modular enough, they can be used in other projects without a lot of headache. Not only that, but the components can be updated and improved independently of each other. As long as the components talk to each other the same way, no problems arise. To aid in component-based software design, Microsoft created a scheme called the Component Object Model, or COM for short. It provides a standard way for objects to communicate with other objects and expose their functionality to other objects that seek it. It is language independent, platform independent,
47
and even machine independent (a COM object can talk to another COM object over a network connection). In this section we cover how COM objects are used in component-based software. As the knowledge required to construct your own COM objects is not necessary for this book, you may want to look in some other books devoted to COM if you need more information. A COM object is basically a block of code that implements one or more COM interfaces. (I love circular definitions like this. Look up "worrier" in the dictionary; it's defined as "someone who worries.") A COM interface is just a set of functions. Actually, it's implemented the same way that almost all C++ compilers implement virtual function tables. In C++, COM objects just inherit one or more abstract base classes, which are called COM interfaces. Other classes can get a COM object to do work by calling functions in its interfaces, but that's it. There are no other functions besides the ones in the interfaces, and no access to member variables outside of Get/Set functions existing in the interfaces. All COM interfaces derive, either directly or indirectly, from a class called IUnknown. In technical terms, this means the first three entries in the vTable of all COM interfaces are the same three functions of IUnknown. The interface is provided in the following: typedef struct interface interface IUnknown { virtual HRESULT QueryInterface( REFIID idd, void** ppvObject) = 0; virtual ULONG AddRef( void)= 0; virtual ULONG Release( void) = 0; }; AddRef and Release implement reference counting for us. COM objects are created outside of your control. They may be created with new, malloc, or a completely different memory manager. Because of this you can't simply delete the interface when you're done with it. Reference counting lets the object perform its own memory management. The reference count is the number of other pieces of code that are referencing an object. When you create a COM object, the reference count will most likely be 1, since you're the only one using it. When another piece of code in a different component wants an interface, generally you call AddRef() on the interface to tell the COM object that there is an additional piece of code using it. When a piece of code is done with an interface, it calls Release(), which decrements the reference count. When the reference count reaches 0, it means that no objects are referencing the COM object and it can safely destroy itself. Warning
If you don't release your COM objects when you're done with them, they won't destroy themselves. This can cause annoying resource leaks in your application.
48
QueryInterface is the one function that makes COM work. It allows an object to request another interface from a COM object it has an interface for. You pass QueryInterface an interface ID, and a pointer to a void pointer to fill with an interface pointer if the requested interface is supported. As an example, let's consider a car. You create the car object and get an interface pointer to an iCarIgnition interface. If you want to change the radio station, you can ask the owner of the iCarIgnition interface if it also supports the iCarRadio interface. Listing 1.4: Querying for interfaces
ICarRadio* pRadio = NULL; HRESULT hr = pIgnition->QueryInterface( IID_ICarRadio, (VOID**)&pRadio ); if( !pRadio || FAILED( hr ) ) { /* handle error */ }
// Now pRadio is ready to use.
This is the beauty of COM. The object can be improved without needing to be recompiled. If you decide to add support for a CD player in your car, all a piece of code needs to do is run QueryInterface for an iCarCDPlayer interface. Getting COM to work like this forces two restrictions on the design of a system. First up, all interfaces are public. If you poke through the DirectX headers, you'll find the definitions for all of the DirectX interfaces. Any COM program can use any COM object, as long as it has the interface definition and the IDs for the COM interfaces. A second, bigger restriction is that COM interfaces can never change. Once they are publicly released, they can never be modified in any way (not even fairly harmless modifications, like appending functions to the end of the interface). If this wasn't enforced, applications that used COM objects would need to be recompiled whenever an interface changed, which would defeat COM's whole purpose. To add functionality to a COM object, you need to add new interfaces. For instance, say you wanted to extend iCarRadio to add bass and treble controls. You can't just add the functions. Instead, you have to
49
put the new functions into a new interface, which would most likely be called iCarRadio2. Any applications that didn't need the new functionality, or ones that predated the addition of the iCarRadio2 interface, wouldn't need to worry about anything and would continue working using the iCarRadio interface. New applications could take advantage of the new functions by simply using QueryInterface to acquire an iCarRadio2 interface. The one last big question to address is how COM objects get created. With DirectX, you don't need to worry about a lot of the innards of COM object creation, but I'll give you a cursory overview. You create a COM object by providing a COM object ID and an interface ID. Internally, the COM creation functions consult the registry, looking for the requested object ID. If the COM object is installed on your system, there will be a registry entry tying an object ID to a DLL. The DLL is loaded by your application, the object is constructed using a DLL-side class factory (returning an IUnknown interface), and then the interface is Query- Interface'd for the provided interface ID. If you look up the object ID for Direct3D in the registry, you'll find it sitting there, tied to d3d9.dll. Note
The registry is a location for Windows to put all sorts of information pertaining to your machine. Versions previous to Windows 95 stored this information in .ini files.
So what are these object and interface IDs, and how are they given out? Well, all COM object creators couldn't be in constant communication, making sure the IDs they chose weren't already in use by someone else, so the creators of COM use what are called globally unique identifiers (GUIDs for short). These are 16-byte numbers that are guaranteed to be unique over time and space. (They're made up of an extremely large timestamp in addition to hardware factors like the ID of the network card of the machine that created it.) That way, when an interface is created, a GUID can be generated for it automatically that is guaranteed to not be in use (using a program called GUIDGEN that comes with Visual C++).
Conclusion So now you know quite a lot about the inner workings of Windows applications and are well on your way to coming to grips with creating a DirectX game. Although we only scratched the surface of Windows, that is pretty much all you really need to know when using DirectX. In the next chapter you'll see how to start actually using DirectX in your application. So with that in mind…turn the page and don't even think about taking a break!
Chapter 2: Getting Started with DirectX Overview Now that you know enough about Windows, it's time to get down and dirty with DirectX. This chapter shows you everything you need to know to get started with Direct3D. In later chapters I'll show you DirectSound, DirectInput, and DirectPlay, but for now let's stick with getting the graphics going!
50
I remember when I first started programming protected mode DOS using Watcom 10.0. My first stabs at graphics programming were extremely basic, using the provided graphics library that came with the Watcom SDK. My first graphics program did nothing more than draw a single point in the center of the screen, but let me tell you, that was one magical program. Sure, I could get the computer to do fairly uninteresting stuff like print text and read in text, but now I could actually make pictures. Getting your first graphics program working, even if it just draws one dot on the screen, is an amazingly cool, almost religious experience. In this chapter I'm going to cover: An overview of DirectX The components that make up DirectX How to initialize Direct3D Surfaces and how to use them Moving to full-screen graphics Setting pixels and rendering rectangles And tons more!
What Is DirectX? Shortly after the release of Windows 95, Microsoft made a push to end DOS's reign as the primary game platform on the PC. Developers weren't swooned by the added abilities that Win32 programming gives you (a robust TCP/IP stack, multitasking, access to system information). They wanted the total control they had in DOS. Besides that, graphics in Windows at that time were done with WinG or even the Windows GDI. While WinG was pretty cool (and written by all-around cool guy Chris Hecker), it didn't have the feature set that games of the time needed, especially when it came to things like fullscreen rendering. The GDI was designed to work on a myriad of different configurations, different resolutions, different bit depths—it was not designed to be fast. Microsoft's answer to game developers was The Game SDK, which was really the first version of DirectX. Finally, developers could write fast games and still get the advantages of using the Win32 API, like multi-threading support, a TCP/IP stack, and countless UI features. With version 2.0, the SDK's name was changed to DirectX. This was because Microsoft realized that game developers weren't the only people who wanted the graphics and audio acceleration provided by the SDK; developers of everything from video playback programs to presentation software wanted faster graphics.
Installation Installing DirectX is a straightforward process. The only real decision you need to make is choosing between the retail and debug builds. The retail builds are stripped of lots of sanity checks and are also compiled to run faster. If you just plan on running other DirectX applications and not writing your own, the retail builds will be fine. The debug builds are designed to help out coders while they're getting their DirectX applications up and running. For example, when you try to do something using DirectX and it fails, chances are the debug builds will print something to the debug window as to why it failed (which is often something easily fixed,
51
like "dwSize parameter not set"). The tradeoff, however, is that they run slightly slower than the retail builds. I recommend that while you are learning you use the debug version of the software; it will save you many headaches later. The other piece of software you'll most likely need to install is the latest version of your video card's drivers if your video card predates the release of DirectX 9.0. You can pick them up off your video card manufacturer's web site or the Microsoft Windows update site. Having the newest possible versions of drivers is important, especially for recently released cards.
Setting up VC++ After you have gotten DirectX installed, you might want to take one of the samples (like boids, for instance) and try to compile it. To get it working you'll need to do a couple of things. Visual C++ needs to know where the headers and library files for DirectX are so it can correctly compile and link your application. You only need to set this up once, since all projects use the same include and lib directories. To specify the directories, select Options from the Tools menu. In the Options dialog box, select the Directories tab. For include directories, you should enter DX 9.0 SDK Install Path\include. For lib directories, enter DX 9.0 SDK Install Path\Lib. DX 9.0 SDK Install Path is just the directory where you installed the DirectX SDK on your hard disk. The other trick is that the directories need to appear at the top of the list, so that they get searched first. When the compiler searches for d3d9.h, for example, it should find DX 9.0 SDK Install Path\include\d3d9.h (the 9.0 version of the header) first, and not use DEVSTUDIO\VC98\include\ d3d.h (the 3.0 version of the header). Figures 2.1 and 2.2 show what the include and lib directory listings should look like.
Figure 2.1: The include directory listing
52
Figure 2.2: The library directory listing If the directories aren't set up correctly, you'll see some telltale signs in the errors the compiler produces. For example, if you get an error like this: e:\book\chapter 10\gamelib\dxhelper.h(89) : error C2065: '_D3DSURFACE_DESC : undeclared identifier This means that it can't find the header with the D3DSURFACE_DESC structure, which was defined after DirectX 7.0. The headers that come with Visual C++ are from version 3.0, and the compiler is incorrectly trying to use the old versions of the headers. The other thing you need when building a DirectX application is to have the right libraries listed for the linking step. Most of the applications you write will need the following libraries linked in: winmm.lib
The windows multimedia library, which has timeGetTime
dxguid.lib
Has the GUIDs for all of the DirectX COM objects
d3d9.lib
Direct3D
d3dx9.lib
Useful D3DX utility extensions
dsound.lib
DirectSound
dinput9.lib
DirectInput
Figure 2.3 shows an example of one of the Chapter 10 programs and the first few libraries it links in (it links in several more than can fit in the window).
53
Figure 2.3: Linking in libraries If you don't include the libraries correctly, you'll see errors such as these: GameLib.lib(GraphicsLayer.obj) : error LNK2001: unresolved external symbol _IID_IDirect3D9 GameLib.lib(GraphicsLayer.obj) : error LNK2001: unresolved external symbol _IID_IDirect3DRefDevice GameLib.lib(GraphicsLayer.obj) : error LNK2001: unresolved external symbol _IID_IDirect3DRGBDevice GameLib.lib(GraphicsLayer.obj) : error LNK2001: unresolved external symbol _IID_IDirect3DHALDevice GameLib.lib(GraphicsLayer.obj) : error LNK2001: unresolved external symbol _IID_IDirect3DTnLHalDevice Fixing this would just be a case of linking in dxguid.lib.
What Happened to DirectDraw?! If you have any previous experience with DirectX graphics, then you will have probably heard of terms such as DirectDraw, Direct3D, Immediate Mode, and Retained Mode. If not, then don't worry; I'll explain them in a moment. Version 8.0 of DirectX was described by Microsoft as the single most significant upgrade to DirectX since its initial release all those years ago and version 9.0 continues to build on it. Version 8.0 is to DirectX what Windows 95 was to 3.11. So let me begin with a short introduction into the way things used to be, so that if you come across these terms you will know what is going on. Graphical output on the PC can be roughly divided into two groups: 2D and 3D, with the latter obviously being far more complex. The implementation of DirectX graphics pretty much followed this train of thought. You had DirectDraw, which looked after 2D graphics, and Direct3D, which looked after 3D. Direct3D was further split into two groups—Immediate Mode, which provided a low-level interface to the
54
3D graphics hardware that was generally considered very complex but fast. Retained Mode provided a higher-level, easy to use interface to the hardware, but it was bloated, inflexible, and slow. As the development of DirectX continued, a number of patterns started to become clear: The development of DirectDraw had all but come to an end as of DirectX 5.0. There was just nothing left to do with it, and most resources were being focused on Direct3D. The learning curve for DirectDraw was too steep; it was too complicated and required too many tedious steps to set up in code. The theoretical split between Direct3D and DirectDraw was becoming a performance bottleneck. Direct3D Retained Mode was a complete failure with almost no commercial take-up, and its support was pretty much dropped from DirectX 6.0. Direct3D Immediate Mode was too complicated, although it did improve significantly with the release of DirectX 5.0. To fix these issues, Microsoft took some bold steps in version 8.0 and then 9.0 and completely reorganized Direct3D and DirectDraw. They made the following changes: DirectDraw was completely removed as a separate entity and integrated entirely with Direct3D. Direct3D Retained Mode was ripped out and was not replaced. Direct3D Immediate Mode remains, but is now much more simplified, faster, and just all around more elegant. Vertex and pixel shaders were introduced, which allow you to implement advanced visual effects and move away from a fixed function pipeline. In version 9.0 a high-level shader language was introduced, which makes shader programming much more intuitive. The result of all these changes is that the graphics section of DirectX is now called DirectX Graphics, although I will be referring to it as Direct3D, since that is where all the functionality is now implemented. The setup portion of code for Direct3D has dropped from a staggering 1,000-plus lines to about 200, which is nice, although it leaves poor authors like myself with little to write about! Don't forget that although throughout the book I'll be referring to DirectX Graphics as Direct3D, I am not necessarily talking about 3D graphics, since Direct3D now handles the 2D stuff as well. For instance, in the next section I talk heavily about 2D graphics. OK, so now that you've had your history lesson, let's look at Direct3D in a little more detail.
Direct3D For a lot of people, Direct3D can be really confusing. It uses a lot of paradigms you may have never seen before. It forces your code to behave nicely with other applications that can be simultaneously using system resources. Diving into the code that makes Direct3D work will be confusing enough, so to start out I'm just going to talk about the concepts behind the code, which will hopefully make the rocky road ahead a little less painful.
55
Don't let anyone else tell you otherwise: Direct3D is hard. If you don't get this stuff immediately, it doesn't mean you're slow and it doesn't mean you're not ready for Windows programming; it means you're normal. DirectX wasn't designed to be easy to use. It was designed to be fast while allowing Windows to maintain some semblance of control over the system. DirectX has gotten much better in recent versions, but it still isn't a trivial thing to pick up. Direct3D is a set of interfaces and functions that allow a Windows application to talk to the video card(s) in a machine. Only the most basic 2D graphics functions are handled by Direct3D. There are some 2D graphics libraries, such as the GDI, that can do things like draw rounded rectangles, ellipses, lines, thick lines, n-sided polygons, and so forth. Direct3D cannot do any of this. Any raster operations need to be developed by you, the game programmer. What Direct3D does do is provide a transparent layer of communication with the hardware on the user's machine. Supported Direct3D functions, like blitting images (which I'll discuss later in the chapter), are implemented by the video card's super-fast internal hardware if the card can handle it. If no hardware is available, Direct3D will transparently emulate the hardware capabilities with hand-optimized assembly routines. Aside
If you want raster operations like drawing lines and don't want to use Direct3D, the web is rife with shareware and freeware libraries to do this for you. Search and you shall find.
2D Graphics—A Primer The way your computer represents images on the screen is as a rectangle of values. Each value is called a pixel, short for picture element. If the image is m pixels wide and n pixels high, then there are m*n pixels in the image. Each pixel may be anywhere from 1 bit to 4 bytes in size, representing different kinds of color information. The total memory taken up by an image can generally be found as the width of the image times the height of the image times the number of bytes per pixel. Color on computers is dealt with the same way it is drawn on monitors. Computer screens have three cathode ray tubes shining light onto the phosphorous screen dozens of times a second. The rays shine on red, green, and blue phosphors. By controlling how much red, green, and blue light hits each area of the monitor, the color that results from the phosphors changes. A white pixel, when examined very closely, is actually three smaller pixels: one red, one green, and one blue. You've probably noticed this if you've ever gotten drops of water on your monitor, which magnify what is under them. I wouldn't do this on purpose by the way—try a magnifying glass instead. There are two main ways that color images are represented on computers. In the first, called paletted images, there exists a table of color values (usually with 256 entries) and an image where each pixel is a character indexing into the list. This restricts the image to having 256 unique colors. Before a few years ago, all games used 256-color images for all of their graphics, and before then even fewer colors
56
were used (16 in high-resolution VGA, 4 in EGA and CGA). See Figure 2.4 for a diagram of what this looked like.
Figure 2.4: The workings of paletted images Nowadays every PC you can buy has hardware that can render images with thousands or millions of individual colors. Rather than have an array with thousands of color entries, the images instead contain explicit color values for each pixel. A 16-bit display is named since each pixel in a 16-bit image is taken up by 16 bits (2 bytes): 5 bits of red information, 6 bits of green information, and 5 bits of blue information. Incidentally, the extra bit (and therefore twice as much color resolution) is given to green because your eyes are more sensitive to green. A 24-bit display, of course, uses 24 bits, or 3 bytes per pixel, for color information. This gives 1 byte, or 256 distinct values each, for red, green, and blue. This is generally called true color, because 2563 (16.7 million) colors is about as much as your eyes can discern, so more color resolution really isn't necessary, at least for computer monitors. Finally, there is 32-bit color, something seen on most new graphics cards. Many 3D accelerators keep 8 extra bits per pixel around to store transparency information, which is generally referred to as the alpha channel, and therefore take up 4 bytes, or 32 bits, of storage per pixel. Rather than reimplement the display logic on 2D displays that don't need alpha information, these 8 bits are usually just wasted. Almost universally, all computer images have an origin located at the top left corner of the image. The top left corner pixel is referenced with the x,y pair (0,0). The value of x increases to the right; y increases down. This is a departure from the way people usually think of Cartesian coordinates, where the origin is usually in the lower left or center. Figure 2.5 shows the coordinate convention your images will use.
57
Figure 2.5: Coordinate setup of an image Each horizontal row of pixels is called a scan line. The image is stored in memory by attaching each scan line from the top to the bottom end-to-end into a single large one-dimensional array. That way, accessing pixel (x,y)on the screen requires you to move across to the correct scan line (the scan line number is y; each scan line is width pixels across) and then move across the scan line to the correct pixel. pixel(x,y)=width*y+x There is one special image in memory that describes the pixels that the monitor will draw. Back in the DOS days, if you put the machine into 320x200x256 color mode and then set *(0xa0000) = 15, a white pixel would appear in the top left corner of the screen (palette entry 15 is white by default). The pointer 0xa0000 pointed to the start of the 64KB block of video memory on VGA cards. A graphics application takes this block of memory and fills it with whatever it would like to show up on the screen. There's a problem, however. The screen isn't updated instantly. It's a physical device, and as such moves eons slower than the CPU. The actual electron gun that lights the screen is internally flying across each scan line of the monitor, reading from the screen's image data and displaying the appropriate colors on the screen. When it reaches the end of a scan line, it moves diagonally down and to the left to the start of the next scan line. When it finishes the last scan line, it moves diagonally up and to the left back to the start of the first scan line. The movement from the bottom right to the top left corners is called the vertical blank or vertical retrace (shown in Figure 2.6) and it takes a long time in terms of processor speed. I'm talking years here.
58
Figure 2.6: The vertical blank Keep this in mind when rendering your images. If you update the screen image at an arbitrary time, the electron gun may be in the middle of the screen. So for that particular frame, the top half of the screen will display the old image, and the bottom half will display the new image. That's assuming you can change the image quickly enough. If you don't, pieces of new image may be smattered all over the screen, creating a horrible, ugly mess. This effect is known as tearing. Because of this, every game under the sun uses a trick called double buffering. During rendering, the final image is rasterized into a secondary, off-screen buffer. Then the application waits around for the vertical blank to begin. When this occurs it is safe to copy the off-screen image to the on-screen image buffer. The off-screen buffer is generally referred to as the back buffer, while the visible image buffer is referred to as the primary surface. You can be fairly sure that the memory copy will finish before the vertical blank does, so when the electron gun starts drawing again, it's using the new image. While it's drawing the new image, you start rendering the next image into your back buffer, and the cycle continues. Note
Actually, applications can go a step further and use triple or even quadruple buffering. This is useful to help smooth out jerky frame rates but requires a lot of precious video memory (especially at high resolutions).
Surfaces 2D images in Direct3D are wrapped by objects called surfaces. Internally, a surface is just a structure that manages image data as a contiguous block of memory. Because of this you see the concept of a surface being used in lots of places in DirectX to take care of different types of data, from vertex buffers to sound buffers. The structure keeps track of the vital statistics of the surface, such as its height, width, and format of the pixel. You create them using the Direct3D object and use the IDirect3DSurface9 interface to play with them.
59
One of the features that surfaces implement is locking. This is because of the asynchronous (multiple things happening in parallel) nature of many video cards. Instead of having to wait for every operation to finish, you can tell the hardware to do something for you, and it will perform the task in the background while you are attending to other tasks. When multiple things are accessing the same piece of memory at the same time, caution must be taken. For example, imagine you draw an image to a surface and request Direct3D to copy the pixels to the screen (using a blit, or bit block transfer, which I'll discuss shortly). The task gets queued with the other tasks the card is currently doing and will be finished eventually. However, without memory protection, you could quickly copy another image onto the bits of the surface before the blit gets executed. When the card got around to performing the blit, it would be blitting a different image! This is a horrible problem. Depending on how much load was on the video card (and whether or not it operates asynchronously; some cards do not), sometimes the surface will be replaced before it is copied, sometimes it won't, sometimes it may even be in the process of being replaced when the card gets to it. For this reason, you do not have continual access to the raw bits of data that make up your image at all times. The solution DirectX uses is a fairly common concurrency paradigm called a lock. When you acquire a lock to a surface, you have exclusive access to it until you are finished with it. If you request a lock on a surface and another piece of code is using it, you won't be able to get it until the other process releases its lock on the surface. When you successfully complete a lock, you are given a pointer to the raw bits, which you may modify at your leisure, while being confident that no other programs will mess with your memory. In the previous example, Direct3D would lock the surface when you requested the blit and unlock it once the blit had completed. If you tried to mangle the bits of the image, your code would not be able to get a pointer to the image data (one of the things you receive when you engage a lock) until the lock had been released by Direct3D. Surfaces, along with having the raw bits to image data, contain a lot of information about the pixels they contain. The width, height, format of the pixel, type of surface, etc., are stored in the surface. There is another important variable that a surface contains that I should mention, called the pitch. Some hardware devices require that image rows begin aligned to 4-pixel boundaries, or 10-pixel boundaries, or any other possible value. If you tried to make an image with an odd width, the card would not be able to handle it. Because of this, Direct3D uses the concept of a pitch in addition to the width. The pitch of an image is similar to the width; however, it may be a bit bigger to accommodate the way the display adapter works. The address of the pixel directly below the top left corner of a Direct3D surface is not surface_width * bytes_per_pixel. Rather, it is pixel * surface_pitch. The surface pitch is always measured in bytes; it doesn't vary in relation to the number of bits per pixel. See Figure 2.7.
60
Figure 2.7: The extra issue of dealing with image pitch Note
This is very important so don't forget it: The pitch of a surface is always measured in bytes and has nothing to do with the number of bits per pixel you are currently working with.
Complex Surfaces Surfaces can be attached to other surfaces in something called a surface chain. This concept is used to represent MIP maps, cubic environment maps (both discussed in Chapter 10), and flipping chains. Flipping chains allow an easier way for the hardware to implement double buffering if two (or more) surfaces exist in the chain. One of them is actually the screen image, the pixels the electron gun will use to display the image on the monitor. The other is the back buffer, the buffer you render the scene into. When you're done rendering, you can flip the surfaces, which will actually swap the addresses of the buffers internally on the video card. Then the back buffer becomes the screen image, and the screen image becomes the back buffer. The next time the application starts rendering a frame, it will be rendering into what once was the screen image, while what once was the back buffer is currently being drawn to the screen by the monitor. Warning
If you're counting on the results from the previous frame when rendering the current frame, be wary. The bits you get when you're using double buffering with a flipping chain isn't the state of the frame buffer at the end of the previous frame; it's the frame buffer from two frames ago!
Describing Surfaces When you create surfaces or request information about surfaces, the capabilities and vital statistics for the surface are inscribed in a structure called the surface description. The surface description is represented by the D3DSURFACE_DESC structure and has the following definition:
61
typedef struct _D3DSURFACE_DESC { D3DFORMAT
Format;
D3DRESOURCETYPE
Type;
DWORD
Usage;
D3DPOOL
Pool;
UINT
Size;
D3DMULTISAMPLE_TYPE
MultiSampleType;
DWORD
MultiSampleQuality;
UINT
Width;
UINT
Height;
} D3DSURFACE_DESC;
Table 2.1: The D3DSURFACE_DESC structure Format
A member of the D3DFORMAT enumeration identifying the format for the surface that you want to use. This can be set to any of the following values, although you don't have to worry about most of them for now. I have bolded the most important flags that you will probably come across. D3DFMT_UNKNOWN—The surface format is not known. D3DFMT_R8G8B8—Standard 24-bit RGB (red, green, blue) format D3DFMT_A8R8G8B8—Standard 32-bit ARGB (alpha, red, green, blue) format D3DFMT_X8R8G8B8—32-bit RGB format D3DFMT_R5G6B5—Standard 16-bit RGB format D3DFMT_X1R5G5B5—15-bit RGB format D3DFMT_A1R5G5B5—16-bit ARGB format D3DFMT_A4R4G4B4—16-bit ARGB format D3DFMT_R3G3B2—8-bit RGB format D3DFMT_A8—8-bit alpha-only surface D3DFMT_A8R3G3B2—16-bit ARGB format D3DFMT_X4R4G4B4—16-bit RGB format
62
D3DFMT_A8P8—16-bit AP surface format (8 bits alpha, 8 bits palette) D3DFMT_P8—8-bit palettized surface D3DFMT_L8—8-bit luminance-only surface D3DFMT_A8L8—16-bit AL surface (8 bits alpha, 8 bits luminance) D3DFMT_A4L4—8-bit AL surface (4 bits alpha, 4 bits luminance) D3DFMT_V8U8—16-bit bump map format D3DFMT_L6V5U5—16-bit bump map surface with luminance D3DFMT_X8L8V8U8—32-bit bump map surface with luminance (8 bits each) D3DFMT_Q8W8V8U8—32-bit bump map surface D3DFMT_V16U16—32-bit bump map only surface format D3DFMT_W11V11U10—32-bit bump map only surface format D3DFMT_UYVY—PC98 compatible UYVY format D3DFMT_YUY2—PC98 compatible YUY2 format D3DFMT_DXT1—DXT1 compressed surface D3DFMT_DXT2—DXT2 compressed surface D3DFMT_DXT3—DXT3 compressed surface D3DFMT_DXT4—DXT4 compressed surface D3DFMT_DXT5—DXT5 compressed surface D3DFMT_D16_LOCKABLE—16-bit lockable depth buffer D3DFMT_D32—32-bit depth buffer D3DFMT_D15S1—16-bit depth buffer with a 1-bit stencil buffer D3DFMT_D24S8—32-bit depth buffer with an 8-bit stencil buffer D3DFMT_D16—Standard 16-bit depth buffer D3DFMT_D24X8—24-bit depth buffer on a 32-bit surface D3DFMT_D24X4S4—32-bit depth buffer with a 4-bit stencil buffer D3DFMT_VERTEXDATA—The surface contains vertex buffer data
63
D3DFMT_INDEX16—The surface contains 16-bit index buffer data D3DFMT_INDEX32—The surface contains 32-bit index buffer data
Type
A member of the D3DRESOURCETYPE enumeration, identifying the type of surface. The possible values for Type are listed below. Again, don't worry too much about what they mean just yet—I'll cover everything important throughout the book. For now just specify the D3DRTYPE_SURFACE identifier. D3DRTYPE_SURFACE—The object you are creating will be a surface. D3DRTYPE_VOLUME—The object you are creating will be a volume. D3DRTYPE_TEXTURE—The object will be a standard texture. D3DRTYPE_VOLUMETEXTURE—The object will be a volume texture. D3DRTYPE_CUBETEXTURE—The object will be a cubic texture. D3DRTYPE_VERTEXBUFFER—The object will be a vertex buffer. D3DRTYPE_INDEXBUFFER—The object will be an index buffer.
Usage
This specifies how the surface will be used. If you are creating an off-screen surface to hold an image, set this to NULL. If the surface will be used as a render target (e.g., a back buffer), specify D3DUSAGE_RENDERTARGET. Or, if you want to create a depth or stencil buffer, which I'll cover in later chapters, specify D3DUSAGE_DEPTHSTENCIL.
Pool
A member of the D3DPOOL enumeration identifying where in memory you want the new surface to reside. The possible values for the D3DPOOL enumeration are shown below, but you will almost always want to specify D3DPOOL_MANAGED for this variable.
64
D3DPOOL_DEFAULT—Direct3D will automatically place the surface in the memory (system, video, AGP, etc.) that is best suited to hold it. D3DPOOL_MANAGED—The surface will be copied into video memory as it is needed automatically and is backed up by system memory so the image is unaffected by device loss, which I will talk about shortly. D3DPOOL_SYSTEMMEM—The surface will reside in system memory, which is usually not accessible by the display adapter. D3DPOOL_SCRATCH—Resources are kept in system RAM and therefore do not need to be randomized when a device is lost.
Size
The size of the surface in bytes
MultiSampleType
Member of the D3DMULTISAMPLE_TYPE enumeration identifying the number of multisample levels that the device supports. Just assume this to be NULL for now.
MultiSample
This is the quality that you want for multisampling. Set this to an index
Quality
between 0 and one less than the value returned from IDirect3D9::CheckDeviceMultiSampleType.
Width
The width, in pixels, of the surface
Height
The height, in pixels, of the surface
Don't worry, I'm not expecting you to get this yet. At the moment I am throwing a lot of information at you. The important thing to do is to keep your head above the mud and keep reading. So now that you've seen how surfaces are described, let's look at an actual Direct3D surface.
The IDirect3DSurface9 Interface A Direct3D surface is represented with a COM interface. Since more and more features have been added through the different versions of DirectX, new COM interfaces have been made (remember that you can never change COM interfaces once they're published). The current version of the Direct3D surface interface is called IDirect3DSurface9. Unlike previous versions of this interface, which used to
65
be called IDirectDrawSurface8, IDirect3DSurface9 has only six member functions; they are listed in Table 2.2.
Table 2.2: IDirect3DSurface9 methods GetContainer
Gets a pointer to a parent texture if one exists.
GetDesc
Retrieves a D3DSURFACE_DESC structure, which is filled with information describing the surface.
LockRect
The all-important function that is used to lock a surface so that you can access it. The function gets you a D3DLOCKED_RECT structure, which contains the pitch of the surface as well as a pointer to the start of the image data.
UnlockRect
Unlocks a previously locked surface.
GetDC
Gets a device context for a surface so that you can use it with standard Windows GDI functions.
ReleaseDC
Releases the handle to the device context back to Windows. Call this when you are done making GDI calls with this surface. You should not keep the DC handle for longer than you need to.
Surface Operations These days Direct3D only has a few facilities to help you play with surfaces. The main one is blitting. Blit (or bit block transfer) is the short name for physically copying the contents of one image on top of another image. The 2D games of yore focused intently on blitting; games lived and died by the speed of their blitting engine. When you saw Mario running about the screen, you were actually looking at two small square images, one representing the head and shoulders and one representing the body, that were copied onto the screen, one on top of the other, to look like an Italian plumber doing his best to fulfill his archaic gender role and save Princess Toadstool. Back in the pre-Direct3D days, people generally did blitting themselves, without the help of Windows. In the simplest case (no scaling, no transparency), it was just a matter of doing some memcpy's to overwrite a section of one surface's contents with a section of another's. However, in the brave new
66
world of hardware accelerated video cards, this is not the best thing to do. Most (if not all) modern video cards support many basic 2D operations (like blitting) in hardware, making them orders of magnitude faster than the fastest memcpy you could ever write. In order to transparently use whatever hardware is currently supported on the machine, you tell Direct3D what you want to do, and Direct3D translates your commands to whatever hardware is available. If no hardware acceleration is available, Direct3D does all the work itself, using heavily optimized code, which is just as good if not better than anything you or I would be able to write. While 2D games may employ blits all over the place, calling hundreds or thousands of them per frame, 3D applications don't really need them. You'll just be using blitting in a couple of places, oftentimes making only one blit per frame. Because of this I'm not going to go into the myriad of effects, specializations, optimizations, and so forth that deal with image blitting. Warning
Direct3D cannot blit between two surfaces that have different pixel formats, according to the spec. However, there are some new tools with Direct3D 9.0 that allow you to get around this problem easily, specifically in the D3DX library, which I'll talk about later.
In the past blitting was an integral part of surfaces. There used to be an actual function called IDirectDrawSurface7::Blt(). However, for some reason or another, an incredible amount of functionality was removed from surfaces during the unification of Direct3D and DirectDraw, and the blitting technology is now implemented in functions external to the object. It seems like a step backward from object orientation, but I'm sure Microsoft had its reasons. These days if you want to copy one surface to another you use the DirectX utility function D3DXLoadSurfaceFromSurface(), which I have prototyped for you below: HRESULT D3DXLoadSurfaceFromSurface( LPDIRECT3DSURFACE9 pDestSurface, CONST PALETTEENTRY* pDestPalette, CONST RECT* pDestRect, LPDIRECT3DSURFACE9 pSrcSurface, CONST PALETTEENTRY* pSrcPalette, CONST RECT* pSrcRect, DWORD Filter, D3DCOLOR ColorKey ); The term loading is the Microsoft lingo for filling a surface with data. As you will see later, you can also load a surface from a file, from a memory resource, or from just about anywhere. Okay, now let's take a
67
moment to look at the function. Don't get too overwhelmed with it just yet—it is much simpler than it seems. The parameters are shown in Table 2.3.
Table 2.3: The parameters to D3DXLoadSurfaceFromSurface() pDestSurface
Pointer to the destination IDirect3DSurface9 surface, which will be filled with the new image.
pDestPalette
This can hold a pointer to a PALETTEENTRY palette for the destination surface if the surface is palettized. However, these days palettized surfaces are rare so you will probably just want to go ahead and set this to NULL.
pDestRect
This parameter takes the address of a destination rectangle within the surface that you want to fill with the source image. Depending on flags specified in the Filter parameter, the image will either be cropped or scaled to fit this rectangle. If you want to use the entire surface as the destination, you can specify NULL for this parameter.
pSrcSurface
Takes the address of the source IDirect3DSurface9 surface that you want to copy.
pSrcPalette
Similarly to the pDestPalette parameter, this parameter takes the address of the palette for the source surface if it is palettized. You will usually set this parameter to NULL.
pSrcRect
This is the address of a RECT rectangle that contains the dimensions of the area within the source surface that you want to copy. If you want to copy the entire source surface then set this parameter to NULL.
Filter
This is an interesting parameter that you can set to change the way that the image is copied if the dimensions of the destination rectangle do not match the source. I have listed the important flags in the following: D3DX_FILTER_NONE—No filter will be applied and the image will be cropped (have its edges chopped off) to make it fit the destination rectangle. D3DX_FILTER_POINT—A point filter will be applied to scale the source image
68
to fit the destination. Point filtering is very fast but results in a blocky image. D3DX_FILTER_LINEAR—A linear filter is used to scale the image. Linear filtering is slightly slower than point filtering, although the results, which are smoothly scaled, are orders of magnitude better. D3DX_FILTER_TRIANGLE—This is the highest quality, and slowest, of the scaling filters. The performance tradeoff generally does not justify its use over linear filtering—the results are often indistinguishable.
ColorKey
A D3DCOLOR value, which specifies the color that you want to be used as a color key. Unfortunately, this is not a proper implementation of color keying; instead, the pixels within the source image that match the color key are just turned to black on the destination image. If you want true color key support, I'm afraid you are going to have to program it yourself.
Don't worry about this too much just yet—all the pieces of the puzzle will fall into place in your mind as you progress through the book. You will probably use D3DXLoadSurfaceFromSurface() as your primary tool when copying surfaces. There is, however, one exception, and that is when you are copying from a back buffer onto the primary surface, which I will cover shortly.
Surfaces and Memory Surfaces can exist in system RAM or in the video card's memory. Where you should put the surface depends on what you want to do with it. Blits between system RAM and video RAM are slow because the data needs to be transferred over the system bus. The bus usually runs at a lower clock rate than the system RAM or the video card, causing both of them to sit around waiting for the bits to be sent. In general, surfaces that get blitted on top of each other should be in the same region of memory if possible. For example, say you are composing a scene with hundreds of blitted images like in a complex 2D game. Since you probably won't be able to fit all of the surfaces in video memory, you need to plan to have at least a few of them in system memory. The blind algorithm would be to blit each of the surfaces onto the back buffer. The surfaces in video memory would blit much faster, because they not only don't need to go over the bus, they can be blitted by the 2D hardware. Conversely, the system memory surfaces can hurt the application greatly.
Modifying the Contents of Surfaces
69
Applications that wish to perform their own raster functions on surfaces, such as plotting pixels or drawing triangles with custom rasterizers, must first lock the surface before being able to modify the pixels of the image. Warning
To prevent other programs from modifying a locked surface, Direct3D may acquire a win16mutex. This can cause problems if you try to, for example, step through code between lock/unlock calls using a debugger like Visual C++. Luckily, these problems only crop up on Win9x; Win2K and WinXP use the NT kernel and therefore aren't affected by this problem. With DirectX 9.0 now fully integrated into Win2K I suggest that you use that platform for your development. Not only is it a better system, but you can usually recover from crashed programs easily and without restarting your PC.
To lock a surface you use the IDirect3DSurface9::LockRect() function, which I have prototyped in the following: HRESULT LockRect( D3DLOCKED_RECT* pLockedRect, CONST RECT* pRect, DWORD Flags );
Table 2.4: LockRect parameters pLockedRect
A pointer to a D3DLOCKED_RECT structure, which will be filled with information about the locked surface. The D3DLOCKED_RECT structure has the following members: typedef struct _D3DLOCKED_RECT { INT
Pitch;
void*
pBits;
} D3DLOCKED_RECT;
pRect
Takes the address of a RECT structure that is filled with the dimensions of the surface that you want to lock. If you want to lock the entire surface, set this parameter to NULL.
Flags
This can be set to flags that change the behavior of the surface in rare situations.
70
Usually you will just set this parameter to NULL. If you want more information on the other flags, see DirectX 9.0 C++ Documentation/DirectX Graphics/ Reference/C++ Reference/IDirect3DSurface9/LockRect in the online documentation.
Since locking a surface causes most of the critical components of Windows to start getting into a traffic jam, I cannot overstate the importance of unlocking a surface when you are done with it. If you do not, Windows will grind to a halt and eventually stall. To unlock a surface, use the function IDirect3DSurface9::UnlockRect, which looks like this: HRESULT UnlockRect(); As you can see, it does not take any parameters. Call this function as soon as you are finished updating the contents of the surface.
Drawing on Surfaces with GDI In past versions of DirectX it was incredibly easy to use the Windows GDI to draw onto a Direct3D surface. However, rather inexplicably, Microsoft removed all interoperability between surfaces and the GDI in version 8.0. So unless you wanted to manually program your own routines to copy GDI data to Direct3D surfaces, you were kind of stuck. Luckily in version 9.0 they have restored this functionality with the IDirect3DSurface9::GetDC() method. I'm not going to go into how to use the GDI since this book is about DirectX, but it is not difficult. Once you acquire a DC handle for the surface you can use it with the GDI as if it is any normal device context. If you're interested in learning more about the GDI, then I would suggest reading the latest version of Charles Petzold's book Programming Windows or my book, The Zen of Direct3D Game Programming. Anyway, the GDI is so slow that you would be better off just rewriting your own optimized rectangle, line, or circle functions yourself rather than resorting to the monstrous GDI.
The Direct3D Device Object The Direct3D device object provides a line of communication between your software and the video card in the host machine. Typically, since only one video card exists in a machine, you only have to concern yourself with one device object. However, in the case of a machine with more than one graphics card, or a graphics card with more than one monitor attached, there can be multiple Direct3D device objects to choose from. In this case you may have to be careful which object you create. For example, if the user had an old dinosaur 3DFX card (which worked alongside a 2D card) and you wrongly chose the primary Direct3D object instead of the object corresponding to the 3DFX card, you wouldn't be able to access its 3D capabilities. This is due to the fact that when you build Direct3D code in Chapter 8, it is built on top of the 2D technology. However, these days this is not so much of an issue since there are almost no separate add-on cards left on the market. Instead, 3D functionality is built right into the primary display
71
adapter. If you have one of these older cards, it is definitely time to get out of the Stone Age and go out and purchase a new one, especially if you are interested in development. The Direct3D object lets you do things you could never do with only the standard Windows API. For example, you can change the bit depth and the resolution of the display to any mode the card supports. You can ask the object for a list of available resolutions and select from among them. The Direct3D device object is created by the Direct3D object, which I will show you shortly.
Windowed vs. Full-screen The two main modes of operation of Direct3D are windowed rendering and full-screen rendering. In windowed rendering, your application draws its graphics to the client rectangle of a regular old window, sharing space with other running applications. When your window is resized, you need to take care to resize your internal structures to adapt to the new size. The same applies when the window is moved around the screen. In addition, windowed rendering makes use of a Direct3D concept called a clipper. A clipper object keeps track of any windows that are on top of your window, so that when you draw your surface to the screen only the pixels that actually belong to the application's client rectangle are drawn. Luckily the process of handling clipping is completely handled by Direct3D, so you never have to touch it. Figure 2.8 shows the kind of issue I'm talking about. If you just drew arbitrarily to the client rectangle, you would overwrite the top left part of the Notepad application floating over the window.
Figure 2.8: You can't draw just anywhere!
The Direct3D Object The IDirect3D9 interface is the first interface that you will interact with when you are using DirectX Graphics. It does basically nothing except for creating the Direct3D device object, which I talked about previously. It is the device that is used to interact with the graphics hardware. Well, I kind of lied;
72
IDirect3D9 does have some functionality, but to tell you the truth in all the time I have used Direct3D, I have rarely used any of its functionality since most of it is replicated in the device object anyway. IDirect3D9 is created with the Direct3DCreate9() function, which I will show you shortly. Now, before I bring all this stuff together, let me take a moment to show you how to create surfaces.
Creating Direct3D Surfaces Creating surfaces used to be a total pain before version 9.0 came out. You had to fill out massive annoying structures that contained an unbelievable amount of entries and substructures. Couple that with poor, badly structured documentation, and it was no wonder that so many people found the learning curve for DirectX Graphics so steep. Luckily these days all that is gone and all you have to do is make a simple call to a function called IDirect3DDevice9::CreateOffscreenPlain- Surface(). HRESULT CreateOffscreenPlainSurface ( UINT Width, UINT Height, D3DFORMAT Format, D3DPOOL Pool, IDirect3DSurface9** ppSurface HANDLE* pHandle );
Table 2.5: CreateOffscreenPlainSurface parameters Width
The width that you want the new surface to be, in pixels.
Height
The height that you want the new surface to be, in pixels.
Format
A member of the D3DFORMAT enumerated type, specifying the format for the surface. You can see the full list of possible values for this parameter earlier in the chapter in the table for D3DSURFACE_DESC structure. However, you will usually want to set this to D3DFMT_ A8R8G8B8 for 32-bit surfaces. For more information, see DirectX 9.0 C++ Documentation/DirectX Graphics/Direct3D C++ Reference/Enumerated Types/D3DFORMAT.
73
Pool
The type of surface pool to use
ppSurface
Takes the address of a pointer that will be filled with the address of the newly created surface.
pHandle
Reserved. Set this parameter to NULL.
So if you wanted to create a simple 32-bit ARGB, 640x480 surface, you could use the following code: Listing 2.1: Creating a new image surface
HRESULTr=0; LPDIRECT3DSURFACE9 pSurface = 0;
r = g_pDevice->CreateOffscreenPlainSurface( 640, 480, D3DFMT_A8R8G8B8, D3DPOOL_MANAGED, &pSurface, NULL );
if( FAILED(r)) { // Error }
// Success!
When you are finished with a surface that uses a large amount of resources, don't forget to release it using the IDirect3DSurface9::Release() function, like this: pSurface->Release(); pSurface = 0;
More on Direct3D Devices There are two pieces of code running in Direct3D applications. The first is the extremely thin layer that takes requests to blit surfaces, for example, and converts those into hardware instructions for the video
74
card to perform. This thin layer that wraps the hardware, abstracting it away, is called the hardware abstraction layer (HAL). In the event that a desired effect in Direct3D is not supported by the HAL, usually it is handled by a larger piece of code that emulates what the hardware would do, actually performing the work with the CPU. This layer is called the hardware emulation layer (HEL). The HEL can be considerably slower than the HAL, both because it isn't asynchronous and because it needs to use the CPU to do its dirty work, which isn't specialized for graphics operations. Any piece of hardware that can accelerate 3D graphics will support the subset of Direct3D (which, essentially, is just surface blits and filled blits). If you plan on using more esoteric features, you should check the device capabilities. This can be done using IDirect3DDevice9::GetDeviceCaps(). There isn't space to cover the function or the structure of capability bits it fills up because it is literally massive. However, if you are feeling motivated, you can check this bad boy out in DirectX 9.0 C++ Documentation/ DirectX Graphics/Reference/Direct3D C++ Reference/Interfaces/IDirect3DDevice9/GetDeviceCaps in the online documentation.
Implementing Direct3D with cGraphicsLayer To implement Direct3D I'm going to create a class called cGraphicsLayer. Like cApplication, it is a class that can only have one instance. In creating this class, there are several abilities that it should possess: Initialization of full-screen Direct3D should be automatic. It should be easy to get access to the Direct3D objects if need be, but that need should arise as rarely as possible. You should be able to initialize Direct3D with the primary display adapter. Let's dive into the code. First, have a look at the header file DxHelper.h, which helps simplify some of the programming tasks. Listing 2.2: DxHelper.h
/******************************************************************* *
Advanced 3D Game Programming using DirectX 9.0
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
Desc: Sample application for Direct3D *
* copyright (c) 2003 by Peter A Walsh and Adrian Perez * See license.txt for modification and distribution information ******************************************************************/
75
#ifndef _D3DHELPER_H #define _D3DHELPER_H
#include <memory.h>
/** * This class takes care of the annoying gruntwork * of having to zero-out and set the size parameter * of our Windows and DirectX structures. */ template struct sAutoZero : public T { sAutoZero() { memset( this, 0, sizeof(T) ); dwSize = sizeof(T); } };
/** * The Right Way to release our COM interfaces. * If they're still valid, release them, then * invalidate them and null them. */ template inline void SafeRelease( T& iface ) { if( iface ) { iface->Release(); iface = NULL;
76
} } #endif // _D3DHELPER_H
The interface for the graphics layer appears in GraphicsLayer.h, which is given in Listing 2.3. Listing 2.3: GraphicsLayer.h
/******************************************************************* *
Advanced 3D Game Programming using DirectX 9.0
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
Desc: Sample application for Direct3D
* * (C) 2003 by Peter A Walsh and Adrian Perez * See license.txt for modification and distribution information ******************************************************************/
#ifndef _GRAPHICSLAYER_H #define _GRAPHICSLAYER_H
#include <list> #include <string> using std::string; using std::list;
#include "GameTypes.h" #include "DxHelper.h"
#include
class cApplication;
77
class cGraphicsLayer {
protected:
HWND
m_hWnd;
LPDIRECT3D9
m_pD3D;
LPDIRECT3DDEVICE9
// The handle to the window // The IDirect3D9 interface
m_pDevice;
// The IDirect3DDevice9 interface
LPDIRECT3DSURFACE9 m_pBackSurf;
RECT
// Pointer to the back buffer
m_rcScreenRect; // The dimensions of the screen
cGraphicsLayer( HWND hWnd );
// Constructor
static cGraphicsLayer* m_pGlobalGLayer; // Pointer to main global gfx object
public:
void DestroyAll(); ~cGraphicsLayer();
/** * Initialization calls. */
void InitD3DFullScreen( GUID* pGuid, int width, int height, int bpp );
/** * This function uses Direct3DX to write text to the back buffer. * It's much faster than using the GDI */
78
void DrawTextString( int x, int y, DWORD color, const char * str );
//==========-------------------------- Accessor functions // Gets a pointer to the IDirect3D9 LPDIRECT3D9 GetD3D() { return m_pD3D; } // Gets a pointer to the device LPDIRECT3DDEVICE9 GetDevice() { return m_pDevice; } // Gets a pointer to the back buffer LPDIRECT3DSURFACE9 GetBackBuffer() { return m_pBackSurf; } // Gets the screen width int Width() const { return m_rcScreenRect.right; } // Gets the screen height int Height() const { return m_rcScreenRect.bottom; } // Presents the back buffer to the primary surface void Flip(); // Gets a pointer to the main gfx object static cGraphicsLayer* GetGraphics() { return m_pGlobalGLayer; }
79
// Initializes this object static void Create( HWND hWnd,
// handle to the window
short width, short height, // width and height GUID* pGuid );
// Device guid
}; inline cGraphicsLayer* Graphics() { return cGraphicsLayer::GetGraphics(); } #endif //_GRAPHICSLAYER_H
GraphicsLayer.cpp is pretty long, so I'll show it to you step by step. There are a few functions that don't deal with initialization, which I'll list here. The first is a helper function used to draw text onto a Direct3D surface (such as the back buffer). It uses the D3DX utility COM object ID3DXFont to display the text. Listing 2.4: cGraphicsLayer::DrawTextString
void cGraphicsLayer::DrawTextString( int x, int y, DWORD color, const char * str ) {
HRESULTr=0;
if( !m_pBackSurf ) return;
// Get a handle for the font to use HFONT hFont = (HFONT)GetStockObject( SYSTEM_FONT );
LPD3DXFONT pFont = 0;
80
// Create the D3DX Font r = D3DXCreateFont( m_pDevice, hFont, &pFont ); if( FAILED(r)) return;
// Rectangle where the text will be located RECT TextRect={x,y,0,0};
// Inform font it is about to be used pFont->Begin();
// Calculate the rectangle the text will occupy pFont->DrawText( str, -1, &TextRect, DT_CALCRECT, 0 );
// Output the text, left aligned pFont->DrawText( str, -1, &TextRect, DT_LEFT, color );
// Finish up drawing pFont->End();
// Release the font pFont->Release();
}
The other function not covered by the initialization code is Flip(). It is called when you are finished rendering the frame to the back buffer. Flipping is accomplished with a call to IDirect3DDevice9::Present(), which takes no parameters. Listing 2.5: cGraphicsLayer::Flip
void cGraphicsLayer::Flip()
81
{
HRESULTr=0;
// Make sure the device has been created. assert( m_pDevice );
// Blit the back buffer to the primary surface r = m_pDevice->Present( NULL, NULL, NULL, NULL ); if( FAILED(r)) { OutputDebugString( "Flipping Failed!\n" ); }
}
Creating the Graphics Layer In a moment I'm going to dive into the code that initializes Direct3D for full-screen rendering. The way the code actually gets called is in cApplication::InitGraphics. That code calls the static function cGraphicsLayer:: Create, which appears in the following listing. Listing 2.6: cGraphicsLayer::Create
void cGraphicsLayer::Create(HWND hWnd, short width, short height, GUID* pGuid ) { new cGraphicsLayer( hWnd ); // construct the object.
// Init Direct3D and the device for fullscreen operation Graphics()->InitD3DFullScreen( pGuid, width, height, 32 ); }
82
Now that you know how the initialization code will be called, let's dive in and see how it works.
Full-screen Initialization Initializing Direct3D for full-screen mode is easier than windowed mode. The set and order of things to do is fairly consistent, so it's easy to hide it away into an initialization function. I'll go through the process step by step.
Step 1: Create the Direct3D object. The first step in Direct3D initialization is to create an instance of the Direct3D object and acquire an interface to it. Instead of using the standard COM construction technique, which is a total pain, you can use a pleasantly wrapped-up function called Direct3DCreate9(): IDirect3D9* Direct3DCreate9( UINT SDKVersion );
Table 2.6: Direct3DCreate9 parameters SDKVersion
An identifier specifying the version of Direct3D that you are using. You should always specify D3D_SDK_VERSION for this parameter, which automatically contains the correct version.
// Create the Direct3D object m_pD3D = Direct3DCreate9( D3D_SDK_VERSION ); if( !m_pD3D ) { throw cGameError("Could not create IDirect3D9"); }
Step 2: Set the present parameters. The new word for moving the contents of the back buffer to the primary surface is present. So when you are done messing with the back buffer and want to display it, you present it to the primary surface. Keep that in your head because it pops up a lot in this section. The first thing you need to do when initializing Direct3D is to fill in what are called the present parameters. This is basically just a structure that contains information about the size and bit depth of the back buffer and primary surface, which is
83
important because in version 9.0, Direct3D manages these two surfaces for you. The structure looks like this: typedef struct _D3DPRESENT_PARAMETERS_ { UINT
BackBufferWidth, BackBufferHeight;
D3DFORMAT UINT
BackBufferFormat; BackBufferCount;
D3DMULTISAMPLE_TYPE
MultiSampleType;
DWORD
MultiSampleQuality;
D3DSWAPEFFECT
SwapEffect;
HWND
hDeviceWindow;
BOOL
Windowed;
BOOL
EnableAutoDepthStencil;
D3DFORMAT
AutoDepthStencilFormat;
DWORD
Flags;
UINT
FullScreen_RefreshRateInHz;
UINT
PresentationInterval;
} D3DPRESENT_PARAMETERS;
Table 2.7: D3DPRESENT_PARAMETERS structure members BackBufferWidth
Width of the back buffer, in pixels.
BackBufferHeight
Height of the back buffer, in pixels.
BackBufferFormat
A D3DFORMAT enumeration member specifying the format for the back buffer, which can be any of the flags in Listing 2.1. You will usually set this to D3DFMT_A8R8G8B8 for 32bit surfaces or D3DFMT_R5G6R5 for 16-bit surfaces.
BackBufferCount
The number of back buffers that you want to associate with the primary surface. You normally want this to be 1.
84
MultiSampleType
A member of the D3DMULTISAMPLE_TYPE enumeration, specifying the type of multisampling, if any, that you want to use. Just set this parameter to D3DMULTISAMPLE_NONE.
MultiSampleQuality
Set this value to between 0 and the result of IDirect3D9::CheckDeviceMultiSampleType.
SwapEffect
A D3DSWAPEFFECT enumeration member specifying the semantics that you want to use when presenting the back buffer to the primary surface. You will normally set this to D3DSWAPEFFECT_COPY.
hDeviceWindow
A handle to the window that you want to use as the rendering target.
Windowed
A Boolean value specifying whether the application runs in full-screen or windowed mode. Specify FALSE for full-screen operation.
EnableAutoDepthStencil
A Boolean value specifying whether you want Direct3D to manage the depth and/or stencil buffer for you. This is usually a good thing so you should specify TRUE.
AutoDepthStencilFormat
Takes a member of the D3DFORMAT enumeration that specifies the format of the depth buffer that you want Direct3D to manage. D3DFMT_16 is a good choice; it creates a 16-bit depth buffer for you.
Flags
Set this to its only possible value, D3DPRESENTFLAG_LOCK ABLEBACKBUFFER. If you will not be messing with the back buffer, set this to 0 for a slight performance improvement.
FullScreen_RefreshRateInHz
The refresh rate that you want the monitor to run at. Set this
85
to D3DPRESENT_RATE_DEFAULT to allow Direct3D to use what it thinks is the best rate.
PresentationInterval
Specifies how quickly you want the back buffer to be presented to the primary surface. Specify D3DPRESENT_INTERVAL_IMMEDIATE to allow the process to complete as quickly as possible.
It is not as hard as it looks since most of the entries can be set to default values that you never have to look at again. Have a look at the code snippet below as an example of how to fill in the structure to create a standard, full-screen, 640x480, 32-bit application: Listing 2.7: Filling in the D3DPRESENT_PARAMETERS structure
D3DPRESENT_PARAMETERS d3dpp; ZeroMemory( &d3dpp, sizeof( d3dpp ) );
// The width and height for the initial back buffer d3dpp.BackBufferWidth
= width;
d3dpp.BackBufferHeight
= height;
// Set the flags for the bit depth - only supports 16-, 24-, and 32-bit formats if( bpp == 16 ) d3dpp.BackBufferFormat
= D3DFMT_R5G6B5;
else if( bpp == 24 ) d3dpp.BackBufferFormat
= D3DFMT_X8R8G8B8;
else if( bpp == 32 ) d3dpp.BackBufferFormat
= D3DFMT_A8R8G8B8;
else { OutputDebugString( "Invalid surface format - defaulting to 32bit"); d3dpp.BackBufferFormat
= D3DFMT_A8R8G8B8;
}
86
// Only have one back buffer associated with the primary surface d3dpp.BackBufferCount
= 1;
// No multisampling d3dpp.MultiSampleType
= D3DMULTISAMPLE_NONE;
// The quality of the multisampling d3dpp.MultiSampleQuality
= 0;
// Copy the back buffer to the primary surface normally d3dpp.SwapEffect
= D3DSWAPEFFECT_COPY;
// The handle to the window to render in to d3dpp.hDeviceWindow
= m_hWnd;
// Full-screen operation d3dpp.Windowed
= FALSE;
// Let Direct3D look after the depth buffer d3dpp.EnableAutoDepthStencil
= TRUE;
// Set the depth buffer depth to 16 bits d3dpp.AutoDepthStencilFormat
= D3DFMT_D16;
// Use the default refresh rate d3dpp.FullScreen_RefreshRateInHz = D3DPRESENT_RATE_DEFAULT; // Update the screen as soon as possible (don't wait for vsync) d3dpp.PresentationInterval
= D3DPRESENT_INTERVAL_IMMEDIATE;
// Allow the back buffer to be locked d3dpp.Flags
= D3DPRESENTFLAG_LOCKABLE_BACKBUFFER;
And that's it. After the structure is filled in it is very simple to create the device, which I am just about to show you.
Step 3: Create the device. The Direct3D rendering device is created with a call to IDirect3DDevice9:: CreateDevice(). Recall that the device is Direct3D lingo for the COM object that communicates your rendering requests to the actual physical display adapter in your PC. The function is prototyped in the following: HRESULT CreateDevice( UINT Adapter,
87
D3DDEVTYPE DeviceType, HWND hFocusWindow, DWORD BehaviorFlags, D3DPRESENT_PARAMETERS* pPresentationParameters, IDirect3DDevice9** ppReturnedDeviceInterface );
Table 2.8: CreateDevice parameters Adapter
Integer identifying which display device you want to render with. Specify 0 to use the primary display adapter.
DeviceType
A D3DDEVTYPE enumeration member specifying the type of device that you want to create. Use D3DDEVTYPE_HAL for a hardware accelerated device, D3DDEVTYPE_SW for a software device, or D3DDEVTYPE_REF for a reference device. You'll almost always want to go with a hardware device. Only use reference devices for debugging; they contain all possible hardware features emulated in software, but they are extremely slow.
hFocusWindow
Handle to the window that you want to use as the default rendering target. This should match the handle that you specified in the present parameters structure.
BehaviorFlags
Takes flags that define the behavior of the device; most of these are superfluous and you will probably want to stick with just D3DCREATE_SOFTWARE_VERTEXPROCESSING. If you have a newfangled hardware transform and lighting card you can specify D3DCREATE_HARDWARE_VERTEXPROCESSING.
pPresentationParameters
Address of the D3DPRESENT_PARAMETERS structure that you filled with information about the device.
88
ppReturnedDeviceInterface
Address of a pointer that will be filled with the address of the newly created device.
So if you were going to create a standard hardware accelerated device with software vertex processing you could use the following code: Listing 2.8: Creating the device
// Create the device using hardware acceleration if available r = m_pD3D->CreateDevice( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, m_hWnd, D3DCREATE_SOFTWARE_VERTEXPROCESSING, &d3dpp, &m_pDevice ); if( FAILED(r)) { throw cGameError( "Could not create IDirect3DDevice9" ); }
In previous versions of DirectX you had to program a million other things like creating clippers, setting the cooperative level, setting the screen resolution, and on and on. These days you are lucky because Direct3D does it all for you. That one call to CreateDevice() handles all the grunt work and you can pretty much start rendering as soon as it is created. However, before I start getting ahead of myself, let me show you in the next step a function I created that automates this whole process.
Step 4: Put it together. Now that you know what you need to do, you can write a full-screen initialization routine. It takes as input a GUID to use for the device, a width, a height, and a depth, and then it does the rest. The GUID can be set to NULL to use the primary display device. Listing 2.9: Direct3D full-screen initialization in cGraphicsLayer
void cGraphicsLayer::InitD3DFullScreen (GUID* pGuid, int width, int height, int bpp ) {
89
HRESULTr=0;
// Create the Direct3D object m_pD3D = Direct3DCreate9( D3D_SDK_VERSION ); if( !m_pD3D ) { throw cGameError( "Could not create IDirect3D9" ); }
// Structure to hold the creation parameters for the device D3DPRESENT_PARAMETERS d3dpp; ZeroMemory( &d3dpp, sizeof( d3dpp ) );
// The width and height for the initial back buffer d3dpp.BackBufferWidth
= width;
d3dpp.BackBufferHeight
= height;
// Set the flags for bit depth - only supports 16, 24, and 32 bit formats if( bpp == 16 ) d3dpp.BackBufferFormat
= D3DFMT_R5G6B5;
else if( bpp == 24 ) d3dpp.BackBufferFormat
= D3DFMT_X8R8G8B8;
else if( bpp == 32 ) d3dpp.BackBufferFormat
= D3DFMT_A8R8G8B8;
else { OutputDebugString( "Invalid surface format - defaulting to 32bit" ); d3dpp.BackBufferFormat
= D3DFMT_A8R8G8B8;
}
// Only have one back buffer associated with the primary surface
90
d3dpp.BackBufferCount
= 1;
// No multisampling d3dpp.MultiSampleType
= D3DMULTISAMPLE_NONE;
// The quality of the multisampling d3dpp.MultiSampleQuality
= 0;
// Copy the back buffer to the primary surface normally d3dpp.SwapEffect
= D3DSWAPEFFECT_COPY;
// The handle to the window to render in to d3dpp.hDeviceWindow
= m_hWnd;
// Full-screen operation d3dpp.Windowed
= FALSE;
// Let Direct3D look after the depth buffer d3dpp.EnableAutoDepthStencil
= TRUE;
// Set the depth buffer depth to 16 bits d3dpp.AutoDepthStencilFormat
= D3DFMT_D16;
// Use the default refresh rate d3dpp.FullScreen_RefreshRateInHz = D3DPRESENT_RATE_DEFAULT; // Update the screen as soon as possible (don't wait for vsync) d3dpp.PresentationInterval
= D3DPRESENT_INTERVAL_IMMEDIATE;
// Allow the back buffer to be locked d3dpp.Flags
= D3DPRESENTFLAG_LOCKABLE_BACKBUFFER;
// Create the device using hardware acceleration if available r = m_pD3D->CreateDevice( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, m_hWnd, D3DCREATE_SOFTWARE_VERTEXPROCESSING, &d3dpp, &m_pDevice ); if( FAILED(r)) { throw cGameError( "Could not create IDirect3DDevice9" ); }
// Keep a copy of the screen dimensions
91
m_rcScreenRect.left
= m_rcScreenRect.top = 0;
m_rcScreenRect.right
= width;
m_rcScreenRect.bottom
= height;
// Get a copy of the pointer to the back buffer m_pDevice->GetBackBuffer( 0, D3DBACKBUFFER_TYPE_MONO, &m_pBackSurf );
}
Shutting Down Direct3D After the application has finished its rendering, it must properly shut down Direct3D before terminating the application. This is just a matter of releasing the back buffer, Direct3D device interface, and finally the IDirect3D9 interface. By the way, you should always try to release the interfaces to COM objects in the opposite order of the way they were created. The code to shut down Direct3D appears in cGraphicsLayer::Destroy- All. The destructor calls DestroyAll, but other modules may call it if need be. Listing 2.10: cGraphicsLayer::DestroyAll
void cGraphicsLayer::DestroyAll() {
SafeRelease( m_pBackSurf ); SafeRelease( m_pDevice );
SafeRelease( m_pD3D );
/** * Prevent any further access to the graphics class */
92
m_pGlobalGLayer = NULL; }
Changes to cApplication A new member variable was added to cApplication class to modify the behavior of the graphics layer when it is initialized. The new variable is given below: int
m_bpp;
// Desired depth (may not be possible)
The m_bpp variable is set to be 32 bits by default in the constructor—you can change this if you find it necessary. Using the members in cApplication, cApplication::InitGraphics sets up the graphics subsystem. At the end of the function you can see the cGraphicsLayer::Create function I discussed earlier. At the moment it just sets up Direct3D with the call to cGraphicsLayer::Create, but if you needed to do any other graphics initialization you could put the code here, away from the Direct3D messiness. Listing 2.11: Graphics initialization code
void cApplication::InitGraphics() {
cGraphicsLayer::Create( MainWindow()->GetHWnd(), m_width, m_height, NULL ); }
Application: Direct3D Sample To give an idea of how you might use the graphics layer in a regular application, I'll go through a barebones Direct3D application with just 2D graphics for now. In every frame, it fills the screen with pseudorandom pixels and then uses a color blit to copy a filled rectangle to the screen. It also flashes text around random locations.
93
Warning
Almost all of the sample applications in this book depend on the GameLib library (and the Math3d library, which I'll show you in Chapter 5). To make them compile correctly, make sure that the dependencies are set up correctly (this can be checked by selecting the Project|Dependencies menu option). GameLib, for this sample and any others that use it, should be listed as a dependency of your project.
Since the program is so short, I'll include all of the source code for it. This appears in Listing 2.12. Listing 2.12: DDSample.cpp
/******************************************************************* *
Advanced 3D Game Programming using DirectX 9.0
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
Desc: Sample application for Direct3D
* * copyright (c) 2003 by Peter A Walsh and Adrian Perez * See license.txt for modification and distribution information ******************************************************************/
#include "stdafx.h"
#include <string> using namespace std;
class cD3DSampleApp : public cApplication {
public:
//==========-------------------------- cApplication
virtual void DoFrame( float timeDelta );
94
cD3DSampleApp() : cApplication() { m_title = string( "Direct3D Sample" ); } };
cApplication* CreateApplication() { return new cD3DSampleApp(); }
void cD3DSampleApp::DoFrame( float timeDelta ) {
HRESULT hr; if( !Graphics() ) return;
// Clear the previous contents of the back buffer Graphics()->GetDevice()->Clear( 0, 0, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, D3DCOLOR_XRGB( 0,0,0), 1.0f, 0 );
// Structure to hold information about the locked back buffer D3DLOCKED_RECT LockedRect;
// Get a local pointer to the back buffer LPDIRECT3DSURFACE9 pBackSurf = Graphics()->GetBackBuffer();
// Lock the back buffer pBackSurf->LockRect( &LockedRect, NULL, NULL );
95
// Get a pointer to the back buffer DWORD* pData = (DWORD*)LockedRect.pBits;
// Convert the pitch to work with 32-bit (4 byte) surfaces int Pitch32 = LockedRect.Pitch / 4;
int x, y; DWORD Color;
// Holds the location of the random pixel // Holds the color of the pixels and rectangles
// ------------- PART 1: Draw 10,000 randomly colored pixels for( inti=0;i< 10000 ; i++ ) { // Get a random location for the pixel x = rand()%639; y = rand()%479;
// Get a random color for the pixel Color = D3DCOLOR_XRGB( rand()%255, rand()%255, rand()%255 );
// Set the pixel at x,y to the color pData[ Pitch32*y+x]= Color; }
// ------------- PART 2: Draw 10 random rectangles
RECT Rect; // Structure to hold the dimensions of the rectangles for( intj=0;jGetDevice()->Clear( 1, (D3DRECT*)&Rect, D3DCLEAR_TARGET, Color, 1.0f, 0 ); }
// Unlock the back surface. Very important to do this! pBackSurf->UnlockRect(); pBackSurf = 0; // ------------- PART 3: Output text to the back surface // Tell Direct3D we are about to start rendering through Direct3D Graphics()->GetDevice()->BeginScene();
// Output green text at a random location Graphics()->DrawTextString( rand()%640, rand()%480, D3DCOLOR_XRGB( 0, 255, 0 ), "Advanced Direct3D 9.0" );
// Tell Direct3D we are finished rendering Graphics()->GetDevice()->EndScene();
// Present the back buffer to the primary surface to make it visible Graphics()->Flip();
}
And that is all there is to it. Well I'm glad that part is over—initializing Direct3D is the tedious part that always stands in the way of having fun. But now that that is over I can start to show you some fun stuff. In the next chapter I'm going to show you how to get DirectInput up and running so that we can start to get some much needed input into the application!
97
Slowly the fog is thinning and the knowledge is becoming clearer…
Chapter 3: Communicating with DirectInput Overview Getting input from the user is probably the most important part of any computer game. Without input, no matter how snazzy the graphics or how great the sound, you are effectively just watching a movie. A game needs to get information from the keyboard, mouse, or joystick. In the past, programming these different devices into a usable form meant a lot of effort and hair pulling, particularly with joysticks. To fix this problem Microsoft created DirectInput. DirectInput was created to provide a direct way to communicate with the input devices that exist on users' systems. It supplies the ability to enumerate all the devices connected to a machine and even enumerate the capabilities of a particular device. You can take any input device under the sun; as long as it has a DirectInput driver written for it, your application can talk to it. These days virtually every device has a DirectInput driver. There are a lot of nifty features in DirectInput like force feedback, but I don't have much space to discuss it. This DirectInput discussion will be limited to just mouse and keyboard usage. However, once you understand the concepts that make DirectInput work, getting more complex things done with it won't be difficult. The Win32 API has a full set of window messages that can inform you when keys are pressed, when the mouse moves, etc. There is even rudimentary support for joysticks. So what advantages are there to using DirectInput over the standard API calls? Well, there are several reasons: The Win32 API was not designed for games, or speed. Joystick support under Win32 is flaky at best. Supporting complex joysticks with several axes, 8 to 10 buttons, a point of view hat, etc., just can't be done on Win32. The mouse support is limited to three buttons, two axes, and the mouse wheel if one is present. Many mice on the market today have four, five, or even more buttons. The keyboard support in Win32 was designed for keyboard entry applications. There is a lot of functionality to handle automatically repeating keys, conversion from key codes to ASCII characters, etc., that a game just doesn't need, and ends up wasting valuable processor cycles. The Win32 keyboard handling code captures some keys for you (like Alt) that require special message processing to handle correctly. Message processing isn't the fastest thing in the world. Applications get flooded with mouse message requests, and since you can't render a frame until the message queue is empty, this can slow down the application.
Devices
98
A DirectInput device represents a physical object that can give input to the computer. The keyboard, the mouse, and any joysticks/joypads are examples of devices. You talk to devices through a COM interface, just like with Direct3D. The interface name in DirectX 9.0 is IDirectInputDevice8. Note
You may be wondering why in DirectX 9.0 the device is called IDirectInputDevice8. This is because there have been no updates to this particular interface since the last (eighth) revision of the interface, which coincidentally was DirectX 8.0. The only additions were some behind-the-scenes compatibility changes.
Devices are composed of a set of objects, each one defining a button, axis, POV hat, etc. A device can enumerate the objects it contains using IDirect-InputDevice8::EnumObjects. This is only really useful for joysticks, as keyboards and mice have a standard set of objects. An object is described by a structure called DIDEVICEOBJECT- INSTANCE. The set of DirectInput functionality that I'm going to show you doesn't require you to understand the workings of this structure, but I'll give you a peek at it anyway. The structure has, among other things, a GUID that describes the type of object. The current set of object types appears in Table 3.1. More may appear in the future as people create newer and better object types.
Table 3.1: The current set of object type GUIDs GUID_XAxis
An axis representing movement in the x-axis (for example, left-to-right movement on a mouse).
GUID_YAxis
An axis representing movement in the y-axis (for example, up-to-down movement on a mouse).
GUID_ZAxis
An axis representing movement in the z-axis (for example, the mouse wheel on newer models).
GUID_RxAxis
An axis representing rotation relative to the x-axis.
GUID_RyAxis
An axis representing rotation relative to the y-axis.
GUID_RzAxis
An axis representing rotation relative to the z-axis.
99
GUID_Slider
A slider axis (for example, the throttle slider that appears on some joysticks).
GUID_Button
A button (on a mouse or joystick).
GUID_Key
A key (on a keyboard).
GUID_POV
A POV hat that appears on some joysticks.
GUID_Unknown
An unknown type of device.
When an application requests the current state of the device, the information needs to be transmitted in some meaningful way. Just getting a list of bytes wouldn't provide enough information, and forcing applications to use a standard communication method wouldn't elegantly solve the problem for all the different types of devices on the market. Because of this, DirectInput lets the application dictate to the device how it wishes to receive its data. If you only want one or two buttons on a joystick, you don't need to request all of the data from the joystick, which may have dozens of buttons. Among other things, the application can decide if any axes on the device should be absolute (centered around a neutral origin, like a joystick axis) or relative (freely moving, like a mouse axis). When a device is created, you must call IDirectInputDevice8::SetDataFormat. HRESULT IDirectInputDevice8::SetDataFormat( LPCDIDATAFORMAT lpdf ); lpdf
A pointer to a DIDATAFORMAT structure that defines the format of the data received from the device. There are some defined constants that you can use: c_dfDIKeyboard—Standard keyboard structure. An array of 256 characters, one for each key. c_dfDIMouse—Standard mouse structure. Three axes and four buttons. Corresponds to the DIMOUSESTATE structure. c_dfDIMouse2—Extended mouse structure. Three axes and eight buttons. Corresponds to the DIMOUSESTATE2 structure. c_dfDIJoystick—Standard joystick. Three positional axes, three rotation axes, two
100
sliders, a POV hat, and 32 buttons. Corresponds to the DIJOYSTATE structure. c_dfDIJoystick2—Extended capability joystick. Refers to the SDK documentation for the truly massive data format definition. Corresponds to the DIJOYSTATE2 structure.
Receiving Device States There are two ways to receive data from a device: immediate data access and buffered data access. This code only uses immediate data access, but buffered data access is not without its merits. Buffered data access is useful for when you absolutely need to get every input event that happens. If a key is quickly pressed and released between immediate device state requests, you will miss it since the state changes aren't queued. If the application is running at any reasonable frame rate, however, this won't be a problem. Immediate data access is used to find the current state of the device at some point in time. If buttons were pressed and released between when you ask, you don't see them. You ask for the device state using IDirectInputDevice8::GetDeviceState: HRESULT IDirectInputDevice8::GetDeviceState( DWORD cbData, LPVOID lpvData ); cbData
Size, in bytes, of the data structure being passed in with lpvData.
lpvData
Pointer to a buffer to fill with the device state. The format of the data depends on the format you defined using SetDataFormat.
For mouse devices, if you set the data format to c_dfDIMouse, the parameters to GetDeviceData should be sizeof(DIMOUSESTATE) and the address of a valid DIMOUSESTATE structure. After the function completes, if it is successful, the structure will be filled with the data from the mouse. typedef struct DIMOUSESTATE { LONG lX; LONG lY; LONG lZ; BYTE rgbButtons[4]; } DIMOUSESTATE, *LPDIMOUSESTATE; lX
X-axis of movement. Relative movement; if the axis hasn't moved since the last time you checked this will be 0.
101
lY
Y-axis of movement. Relative movement; if the axis hasn't moved since the last time you checked this will be 0.
lZ
Z-axis (mouse wheel) movement. Relative movement; if the axis hasn't moved since the last time it was checked this will be 0.
rgbButtons
A set of bytes, one for each of four mouse buttons. To support a mouse with more buttons, use the DIMOUSESTATE2 structure.
As for the keyboard data, all you do is pass in a 256-element array of characters. Each character represents a certain key. You can index into the array to find a certain key using the DirectInput key constants. There is a constant for every possible key on a keyboard. Table 3.2 has a list of the common ones. Some of the more obscure ones, like the ones for Japanese keyboards and web keyboards, are not included. See the SDK documentation for a complete list at DirectX 9.0 C++ Documentation/DirectInput/ DirectInput C++ Reference/Device Constants/Keyboard Device.
Table 3.2: The common DirectInput keyboard constants DIK_A … DIK_Z
A through Z keys
DIK_0 … DIK_9
0 through 9 keys
DIK_F1 … DIK_F15
F1 through F15 keys, if they exist
DIK_NUMPAD0 …
Number pad keys. The keys are the same regardless of whether
DIK_NUMPAD9
or not Num Lock is on.
DIK_ESCAPE
Esc key
DIK_MINUS
− key on the top row
DIK_EQUALS
= key on the top row
102
DIK_BACK
Backspace key
DIK_TAB
Tab key
DIK_LBRACKET
[ (left bracket) key
DIK_RBRACKET
] (right bracket) key
DIK_RETURN
Return key
DIK_LCONTROL
Left-side Ctrl key
DIK_SEMICOLON
; key
DIK_APOSTROPHE
' (apostrophe) key
DIK_GRAVE
‘ (grave accent) key; usually the same as the tilde (~) key
DIK_LSHIFT
Left-side Shift key
DIK_BACKSLASH
\ (backslash) key
DIK_COMMA
, (comma) key
DIK_PERIOD
. (period) key
DIK_SLASH
/ (forward slash) key
DIK_RSHIFT
Right-side Shift key
103
DIK_MULTIPLY
* key on numeric pad
DIK_LMENU
Left-side Alt key
DIK_SPACE
Spacebar
DIK_CAPITAL
Caps Lock key
DIK_NUMLOCK
Num Lock key
DIK_SCROLL
Scroll Lock key
DIK_SUBTRACT
− sign on keypad
DIK_ADD
+ sign on keypad
DIK_DECIMAL
. sign on keypad
DIK_NUMPADENTER
Enter on keypad
DIK_RCONTROL
Right-side Ctrl key
DIK_DIVIDE
/ sign on keypad
DIK_SYSRQ
SysRq (same as PrtScrn) key
DIK_RMENU
Right-side Alt key
104
DIK_PAUSE
Pause key
DIK_HOME
Home key (if there is a set separate from the keypad)
DIK_UP
Up arrow
DIK_PRIOR
PgUp key (if there is a set separate from the keypad)
DIK_LEFT
Left arrow
DIK_RIGHT
Right arrow
DIK_END
End key (if there is a set separate from the keypad)
DIK_DOWN
Down arrow
DIK_NEXT
PgDn key (if there is a set separate from the keypad)
DIK_INSERT
Insert key (if there is a set separate from the keypad)
DIK_DELETE
Delete key (if there is a set separate from the keypad)
DIK_LWIN
Left-side Windows key
DIK_RWIN
Right-side Windows key
DIK_APPS
Application key
Cooperative Levels
105
DirectInput devices have a concept of a cooperative level, since they are shared by all applications using the system. Setting the cooperative level is the first thing that you should do upon successful creation of an IDirectInputDevice8 interface. The call to set the cooperative level is: HRESULT IDirectInputDevice8::SetCooperativeLevel( HWND hwnd, DWORD dwFlags ); hwnd
Handle to the window of the application that created the object.
dwFlags
A set of flags describing the cooperative level desired. Can be a combination of the following: DISCL_BACKGROUND—When this flag is set, the application may acquire the device at any time, even if it is not the currently active application. DISCL_EXCLUSIVE—Application requests exclusive access to the input device. This prevents other applications from simultaneously using the device (for example, Windows itself). If the mouse device is set to exclusive mode, Windows stops sending mouse messages and the cursor disappears. DISCL_FOREGROUND—When this flag is set, the device is automatically unacquired when the window moves to the background. It can only be reacquired when the application moves to the foreground. DISCL_NONEXCLUSIVE—Application requests non-exclusive access to the input device. This way it doesn't interfere with the other applications that are simultaneously using the device (for example, Windows itself). DISCL_NOWINKEY—Disables the use of the Windows key. This prevents the user from accidentally being knocked out of an exclusive application by pressing the Windows key. All devices must set either DISCL_FOREGROUND or DISCL_BACKGROUND (but not both), as well as either DISCL_EXCLUSIVE or DISCL_NONEXCLUSIVE (but not both).
Application Focus and Devices If you ever can't get the device state from a device, chances are access to it has been lost. For example, when the application doesn't have focus you can't grab the state of the keyboard. The application class will automatically detect when it loses focus and stop the input code from polling the devices until focus is regained. When you get focus, you need to reacquire the device before you can
106
start requesting its state. That is done using the parameter-free function IDirectInputDevice8::Acquire(). You'll see Acquire scattered throughout the input code for both the keyboard and the mouse.
The DirectInput Object The DirectInput object (which has the interface IDirectInputDevice8) doesn't have a clear tie to a physical device as the Direct3D device object did. It is useful, however; you need it to enumerate available devices and to create them. To create the DirectInput object, you use the global function DirectInput8Create, which wraps up all the necessary COM work. HRESULT WINAPI DirectInput8Create( HINSTANCE hinst, DWORD dwVersion, REFIID riidltf, LPVOID* ppvOut, LPUNKNOWN punkOuter ); hinst
Handle to the instance of the application that is creating the DirectInput.
dwVersion
The version number of the DirectInput object that you want to create. You should specify DIRECTINPUT_VERSION for this parameter.
riidltf
An identifier for the interface you want to create. Specify IID_IDirectInput8 for this parameter and you won't go wrong.
ppvOut
Address of a pointer that will receive the address of the newly created interface.
punkOuter
Used for COM aggregation—just specify NULL.
Once you have the DirectInput interface, you can use it to enumerate and create devices. Device creation is done using IDirectInput8::CreateDevice.
Implementing DirectInput with cInputLayer Due to the small subset of the total DirectInput functionality I'm showing you, the code to handle DirectInput is very simple. Adding support for simple joysticks wouldn't be too much harder, but
107
implementing a robust system that could enumerate device objects and assign tasks to each of them would take considerably more work than I have space to apply. The way the code works is the input layer constructs and holds onto a mouse object and a keyboard object (cMouse and cKeyboard, respectively). Both the mouse and the keyboard can have listeners, or classes that are notified when events happen. To make a class a listener, two things must happen. First, the class must implement the iKeyboardReceiver interface (for keyboards) and/or the iMouseReceiver interface (for mouse devices). Second, it must tell the keyboard or mouse to make itself a receiver. This can be done by calling cKeyboard::SetReceiver() or cMouse::SetReceiver(). Just pass in the address of the class that wishes to become a receiver. Here are the interfaces: Listing 3.1: Input communication interfaces
/** * Any object that implements this interface can receive input * from the keyboard. */ struct iKeyboardReceiver { virtual void KeyUp( int key) = 0; virtual void KeyDown( int key) = 0; }; /** * Any object that implements this interface can receive input * from the mouse. */ struct iMouseReceiver { virtual void MouseMoved( int dx, int dy) = 0; virtual void MouseButtonUp( int button) = 0; virtual void MouseButtonDown( int button) = 0; };
108
The input layer is another system object, and like the others can only have one instance. This condition is validated in the constructor. The input layer appears in Listings 3.2 (header) and 3.3 (source). Listing 3.2: InputLayer.h
/******************************************************************* *
Advanced 3D Game Programming using DirectX 9.0
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
Desc: Sample application for Direct3D
* * copyright (c) 2002 by Peter A Walsh and Adrian Perez * See license.txt for modification and distribution information ******************************************************************/
#ifndef _INPUTLAYER_H #define _INPUTLAYER_H
#include #include "Keyboard.h" #include "Mouse.h"
class cInputLayer { cKeyboard* cMouse*
m_pKeyboard; m_pMouse;
// The DI8 object LPDIRECTINPUT8 m_pDI;
static cInputLayer* m_pGlobalILayer;
cInputLayer( HINSTANCE hInst, HWND hWnd,
109
bool bExclusive, bool bUseKeyboard = true, bool bUseMouse = true );
public:
virtual ~cInputLayer();
cKeyboard* GetKeyboard() { return m_pKeyboard; }
cMouse* GetMouse() { return m_pMouse; }
void UpdateDevices();
static cInputLayer* GetInput() { return m_pGlobalILayer; }
LPDIRECTINPUT8 GetDInput()
{ return m_pDI; }
void SetFocus(); // called when the app gains focus
110
void KillFocus(); // called when the app must release focus
static void Create( HINSTANCE hInst, HWND hWnd, bool bExclusive, bool bUseKeyboard = true, bool bUseMouse = true ) { //everything is taken care of in the constructor new cInputLayer( hInst, hWnd, bExclusive, bUseKeyboard, bUseMouse ); } };
inline cInputLayer* Input() { return cInputLayer::GetInput(); }
#endif //_INPUTLAYER_H
Listing 3.3: InputLayer.cpp
/******************************************************************* *
Advanced 3D Game Programming using DirectX 9.0
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
111
*
Desc: Sample application for Direct3D
* * copyright (c) 2002 by Peter A Walsh and Adrian Perez * See license.txt for modification and distribution information ******************************************************************/
#include "stdafx.h" #include "InputLayer.h" #include "Keyboard.h" #include "Mouse.h" #include "Application.h" #include "Window.h"
cInputLayer* cInputLayer::m_pGlobalILayer = NULL;
cInputLayer::cInputLayer( HINSTANCE hInst, HWND hWnd, bool bExclusive, bool bUseKeyboard, bool bUseMouse ) {
m_pKeyboard = NULL; m_pMouse = NULL;
if( m_pGlobalILayer ) { throw cGameError("cInputLayer already initialized!\n"); } m_pGlobalILayer = this;
112
HRESULT hr;
/** * Create the DI8 object */
hr = DirectInput8Create( hInst, DIRECTINPUT_VERSION, IID_IDirectInput8, (void**)&m_pDI, NULL ); if( FAILED(hr) ) { throw cGameError("DirectInput8 object could not be created\n"); }
try { if( bUseKeyboard ) { m_pKeyboard = new cKeyboard( hWnd ); } if( bUseMouse ) { m_pMouse = new cMouse( hWnd, bExclusive ); } } catch( ... ) { SafeRelease( m_pDI ); throw; }
}
113
cInputLayer::~cInputLayer() { if( m_pDI ) { if( m_pKeyboard ) { delete m_pKeyboard; // this does all the de-init. }
if( m_pMouse ) { delete m_pMouse; // this does all the de-init. } SafeRelease( m_pDI ); } m_pGlobalILayer = NULL; }
void cInputLayer::UpdateDevices() { if( m_pKeyboard ) { m_pKeyboard->Update(); } if( m_pMouse ) { m_pMouse->Update(); } }
114
void cInputLayer::SetFocus() { if( m_pKeyboard ) { m_pKeyboard->ClearTable(); } if( m_pMouse ) { m_pMouse->Acquire(); } }
void cInputLayer::KillFocus() { if( m_pKeyboard ) { m_pKeyboard->ClearTable(); } if( m_pMouse ) { m_pMouse->UnAcquire(); } }
The keyboard object pretty much wraps around the IDirectInputDevice8 interface, while providing the listener interface for an easy way for classes to listen to keys that get pressed. If you don't want to use listeners, just call the Poll method on the keyboard object to find the state of a certain key at the last checked time. Listing 3.4: Keyboard.h
115
/******************************************************************* *
Advanced 3D Game Programming using DirectX 9.0
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
Desc: Sample application for Direct3D
* * copyright (c) 2002 by Peter A Walsh and Adrian Perez * See license.txt for modification and distribution information ******************************************************************/
#ifndef _KEYBOARD_H #define _KEYBOARD_H #include <memory.h> #include
class cInputLayer;
/** * Any object that implements this interface can receive input * from the keyboard. */ struct iKeyboardReceiver { virtual void KeyUp( int key ){}; virtual void KeyDown( int key ){}; };
class cKeyboard { // The DInput device used to encapsulate the keyboard LPDIRECTINPUTDEVICE8
m_pDevice;
116
char
m_keyState[256];
iKeyboardReceiver*
m_pTarget;
public:
void ClearTable() { memset( m_keyState, 0, sizeof(char)*256 ); }
cKeyboard( HWND hWnd ); ~cKeyboard();
// Poll to see if a certain key is down bool Poll( int key );
// Use this to establish a KeyboardReceiver as the current input focus void SetReceiver( iKeyboardReceiver* pTarget );
eResult Update();
};
#endif //_KEYBOARD_H
Listing 3.5: Keyboard.cpp
/******************************************************************* *
Advanced 3D Game Programming using DirectX 9.0
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
117
*
Desc: Sample application for Direct3D
* * copyright (c) 2002 by Peter A Walsh and Adrian Perez * See license.txt for modification and distribution information ******************************************************************/
#include "stdafx.h" #include "InputLayer.h" #include "window.h"
#include <stack> using namespace std;
#include "Keyboard.h"
cKeyboard::cKeyboard( HWND hWnd ) { m_pTarget = NULL; HRESULT hr;
/** * Get the DInput interface pointer */ LPDIRECTINPUT8 pDI = Input()->GetDInput();
/** * Create the keyboard device * */ hr = Input()->GetDInput()->CreateDevice( GUID_SysKeyboard, &m_pDevice, NULL );
118
if( FAILED(hr) ) { throw cGameError("Keyboard could not be created\n"); } /**
* Set the keyboard data format */ hr = m_pDevice->SetDataFormat(&c_dfDIKeyboard); if( FAILED(hr) ) { SafeRelease( m_pDevice ); throw cGameError("Keyboard could not be created\n"); }
/** * Set the cooperative level */ hr = m_pDevice->SetCooperativeLevel( hWnd, DISCL_FOREGROUND | DISCL_NONEXCLUSIVE); if( FAILED(hr) ) { SafeRelease( m_pDevice ); throw cGameError("Keyboard coop level could not be changed\n"); }
memset( m_keyState, 0, 256*sizeof(bool) ); }
cKeyboard::~cKeyboard() {
119
if( m_pDevice ) { m_pDevice->Unacquire(); SafeRelease( m_pDevice ); } }
void cKeyboard::SetReceiver( iKeyboardReceiver* pTarget ) { // Set the new target. m_pTarget = pTarget; }
bool cKeyboard::Poll( int key ) { // stuff goes in here. if( m_keyState[key] & 0 x 80 ) return true; return false; }
eResult cKeyboard::Update() { char
newState[256];
HRESULT hr;
hr = m_pDevice->Poll(); hr = m_pDevice->GetDeviceState(sizeof(newState),(LPVOID)&newState);
120
if( FAILED(hr) ) { hr = m_pDevice->Acquire(); if( FAILED( hr ) ) { return resFailed; }
hr = m_pDevice->Poll(); hr = m_pDevice->GetDeviceState(sizeof(newState),(LPVOID)&newState); if( FAILED( hr ) ) { return resFailed; } } if( m_pTarget ) { int i; for( i=0; i< 256; i++ ) { if( m_keyState[i] != newState[i] ) { // Something happened to this key since last checked if( !(newState[i] & 0 x 80) ) { // It was Released m_pTarget->KeyUp( i ); } else { // Do nothing; it was just pressed, it'll get a keydown // in a bit, and we don't want to send the signal to
121
// the input target twice } }
// copy the state over (we could do a memcpy at the end, but this // will have better cache performance) m_keyState[i] = newState[i];
if( Poll(i)) { // It was pressed m_pTarget->KeyDown( i ); } } } else { // copy the new states over. memcpy( m_keyState, newState, 256 ); }
return resAllGood; }
The mouse object is almost identical in function to the keyboard object. The code behind the mouse is in Listings 3.6 (header) and Listings 3.7 (source). Listing 3.6: Mouse.h
/******************************************************************* *
Advanced 3D Game Programming using DirectX 9.0
122
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
Desc: Sample application for Direct3D
* * copyright (c) 2002 by Peter A Walsh and Adrian Perez * See license.txt for modification and distribution information ******************************************************************/
#ifndef _MOUSE_H #define _MOUSE_H
#include
/** * Any object that implements this interface can receive input * from the mouse. */ struct iMouseReceiver { virtual void MouseMoved( int dx, int dy ){}; virtual void MouseButtonUp( int button ){}; virtual void MouseButtonDown( int button ){}; };
class cMouse { LPDIRECTINPUTDEVICE8 m_pDevice; DIMOUSESTATE iMouseReceiver*
m_lastState; m_pTarget;
public:
cMouse( HWND hWnd, bool bExclusive );
123
~cMouse();
/** * Use this to establish a MouseReceiver as the current * input focus */ void SetReceiver( iMouseReceiver* pTarget );
eResult Update();
eResult Acquire(); void UnAcquire(); };
#endif // _MOUSE_H
Listing 3.7: Mouse.cpp
/******************************************************************* *
Advanced 3D Game Programming using DirectX 9.0
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
Desc: Sample application for Direct3D
* * copyright (c) 2002 by Peter A Walsh and Adrian Perez * See license.txt for modification and distribution information ******************************************************************/
#include "stdafx.h" #include "InputLayer.h" #include "Window.h"
124
#include "Mouse.h"
cMouse::cMouse( HWND hWnd, bool bExclusive ) { m_pTarget = NULL;
HRESULT hr;
/** * Create the device * */ hr = Input()->GetDInput()->CreateDevice( GUID_SysMouse, &m_pDevice, NULL ); if( FAILED( hr )) { throw cGameError("[cMouse::Init]: Couldn't create the device!\n"); } /**
* Set the data format */ hr = m_pDevice->SetDataFormat(&c_dfDIMouse); if( FAILED( hr )) { SafeRelease( m_pDevice ); throw cGameError("[cMouse::Init]: SetDataFormat failed\n"); }
/** * Set the cooperative level */
125
if( bExclusive ) { hr = m_pDevice->SetCooperativeLevel( hWnd, DISCL_EXCLUSIVE | DISCL_NOWINKEY | DISCL_FOREGROUND ); } else { hr = m_pDevice->SetCooperativeLevel( hWnd, DISCL_NONEXCLUSIVE | DISCL_FOREGROUND); }
if( FAILED( hr )) { SafeRelease( m_pDevice ); throw cGameError("[cMouse::Init]: SetCooperativeLevel failed\n"); } m_lastState.lX = 0; m_lastState.lY = 0; m_lastState.lZ = 0; m_lastState.rgbButtons[0] = 0; m_lastState.rgbButtons[1] = 0; m_lastState.rgbButtons[2] = 0; m_lastState.rgbButtons[3] = 0; }
cMouse::~cMouse() { if( m_pDevice ) { m_pDevice->Unacquire(); SafeRelease( m_pDevice );
126
} }
void cMouse::SetReceiver( iMouseReceiver* pTarget ) { m_pTarget = pTarget; }
eResult cMouse::Update() { DIMOUSESTATE currState; HRESULT hr; hr = m_pDevice->Poll(); hr = m_pDevice->GetDeviceState( sizeof(DIMOUSESTATE), (void*)&currState );
if( FAILED(hr) ) { hr = m_pDevice->Acquire(); if( FAILED( hr ) ) { return resFailed; }
hr = m_pDevice->Poll(); hr = m_pDevice->GetDeviceState( sizeof(DIMOUSESTATE), (void*)&currState ); if( FAILED( hr ) ) { return resFailed;
127
} } if( m_pTarget ) { int dx = currState.lX; int dy = currState.lY; if( dx || dy ) { m_pTarget->MouseMoved( dx, dy ); } if( currState.rgbButtons[0] & 0x80 ) { // the button got pressed. m_pTarget->MouseButtonDown( 0 ); } if( currState.rgbButtons[1] & 0x80 ) { // the button got pressed. m_pTarget->MouseButtonDown( 1 ); } if( currState.rgbButtons[2] & 0x80 ) { // the button got pressed. m_pTarget->MouseButtonDown( 2 ); } if( !(currState.rgbButtons[0] & 0x80) && (m_lastState.rgbButtons[0] & 0x80) ) { // the button got released. m_pTarget->MouseButtonUp( 0 ); } if( !(currState.rgbButtons[1] & 0x80) && (m_lastState.rgbButtons[1]
128
& 0x80) ) { // the button got released. m_pTarget->MouseButtonUp( 1 ); } if( !(currState.rgbButtons[2] & 0x80) && (m_lastState.rgbButtons[2] & 0x80) ) { // the button got released. m_pTarget->MouseButtonUp( 2 ); } } m_lastState = currState; return resAllGood; }
eResult cMouse::Acquire() { HRESULT hr = m_pDevice->Acquire(); if( FAILED(hr) ) { return resFailed; } return resAllGood; }
void cMouse::UnAcquire() { m_pDevice->Unacquire(); }
129
Additions to cApplication The only addition to cApplication is the InitInput call. It initializes both the keyboard and the mouse. The method can be overloaded if this behavior isn't what you want. The code is in the following: cInputLayer::Create( AppInstance(), MainWindow()->GetHWnd(), NULL, true, true ); As you have probably noticed, there is no sample application for this chapter. Don't worry though; I decided to combine the samples for this and the next chapter together, so you will see it in about 20 pages or so. DirectInput is pretty involved, but it is really a lot nicer interface than what existed before in the DOS world, when you had to deal with analog timing signals, the BIOS, and proprietary mouse drivers. It is also a huge improvement on the original support that Win32 had for input devices. Once you have created your DirectInput code, you can keep it as it is for most of your projects without too much modification. So if, in the future, you ever need to use code for any of your own projects to deal with input, you can just cut and paste what you have learned in this chapter into your code. Now it's time to move further into the possibilities of DirectX, with DirectSound…
Chapter 4: DirectSound Overview I am a recent convert to the importance of sound in games. I used to think that the main selling point of any game was the initial shock value of how its graphics looked. However, a while back I attended a Microsoft DirectX Meltdown conference in London, where one of the Microsoft guys showed me a rewritten version of 3D Boids that included full support for advanced 3D DirectSound and DirectMusic. The results were really spectacular. The original, slightly boring game became incredibly immersive at the press of a key. Since then I have always strived to ensure that audio is a huge part of any project I work on. There was a time, long ago, when computers didn't have sound cards. Sound cards were add-ons that people bought and installed manually. I clearly remember the first time I played Wolfenstein 3D on a sound card-enabled machine; after that I ran out and bought one. Sound can totally change the experience of electronic entertainment. Instead of just associating visual images with a virtual experience, adding sound to an application makes it still more immersive, especially if the sound effects are well made.
130
Before the great move to Windows, using sound was a tricky process for programmers. Usually it involved licensing an expensive and complex third-party sound library that could interface with the different types of sound cards on the market. These libraries could cost hundreds or thousands of dollars. With the advent of DirectSound, the need for these libraries has all but disappeared. DirectSound is an API that can play sound on any Windows-capable sound card (which is, basically, all of them). It has advanced features for more advanced cards, like 3D sound effects. While the Win32 API has some limited sound-playing functionality, it's not something that is practical for most games. Sounds can't be mixed together, signal processing is nonexistent, and it isn't the fastest thing in the world. As of DirectX 6.1, the DirectX component called DirectMusic allows applications to dynamically improvise music for games. DirectMusic is really a specialist subject that goes too far off track for this book, so I'm going to limit my discussions to DirectSound only.
The Essentials of Sound Sound itself is a wave of kinetic energy caused by the motion of an object. The wave travels through matter at a speed dependent on the type of matter and temperature (very quickly through solids; through air at 24° C (75° F) it moves at about 1240 kph (775 mph)). Sound waves have energy, so they can cause objects to move; when they hit a solid object, some of the sound is transmitted through the object, some is absorbed, and some is reflected back (the reflecting back is known as echo). When the waves hit an object, they make it vibrate. When the vibrating object is your eardrum, electric signals go to your brain and it hears the sound. The waves are sinusoidal in nature, and they have an amplitude and a frequency. The amplitude defines how loud the sound is and is usually measured in decibels (dB). The frequency is how many different wave oscillations fit into one second, measured in hertz (Hz). The frequency of a sound defines what its pitch is; lower-pitched sounds resonate less than higher-pitched sounds. The A above middle C has a wave that resonates 440 times a second, so it has a frequency of 440 Hz. Sound is additive; that is, if two sounds are going through the air together, they both apply their energy to the air molecules around them. When the crests of the sound waves match up, their result is a louder sound, while if opposite crests match up, they cancel each other out. The more things there are creating sound in a room, the more sound there generally is in the room. On a computer, sound is represented as a stream of discrete samples. Each sample is usually an 8-bit or 16-bit integer, representing the amplitude of the sample. With 16 bits the amplitude can be better approximated, since there is a range of about 65,000 values, instead of only 256 found in 8 bits. Successive samples are played, and when enough samples are put together, they approximate the continuous sound curve well enough that the human ear can't tell the difference. In order to approximate it well, the sampling rate (number of samples every second) is much higher than the frequency of most audible sounds—for CD-quality sound, 44.1 thousand samples per second are used to approximate the
131
waveform. See Figure 4.1 for what this looks like. The figure shows an extremely magnified waveform; the amount of signal shown would probably account for a few hundredths of a second of sound.
Figure 4.1: Continuous waveforms, and a computer's approximation Note
By the way, in case you have any experience with previous versions of DirectSound, there are virtually no changes between DirectSound 8.0 and DirectSound 9.0. The changes are pretty obscure and minor but if you're interested, check out DirectX C++ Documentation/DirectSound/What's New. There are no changes to any methods or interfaces so your old code should work perfectly with DirectX 9.0.
DirectSound Concepts DirectSound centers around a set of interfaces that perform all the work you need to do. The DirectSound interfaces are summed up in Table 4.1. For now, I'm just going to focus on the ability to play sounds, so don't get too caught up with all interfaces below.
Table 4.1: The main DirectSound interfaces IDirectSound8
Used in determining capabilities of the sound card and creating buffers for playback.
IDirectSoundBuffer8
A buffer of data used to hold onto the data for a playable sound.
IDirectSound3DBuffer8
A buffer used to contain a 3D sound. Has additional information like distance, position, projection cones, and so forth.
132
IDirectSound3DListener8
An object used to represent a 3D listener. Depending on the location and direction of the listener in 3D space, 3D buffers sound different.
IDirectSoundCapture8
Interface used to create capture buffers.
IDirectSoundCapture-
Buffer used to hold sound data recorded from a device such as
Buffer8
a microphone.
IDirectSoundNotify8
Object that can be used to notify an application when a sound has finished playing.
IKsPropertySet8
An interface used by sound card manufacturers to add special abilities to their driver without needing to extend the spec. This is for pretty hard core stuff, so I'm not going to cover it.
DirectSound Buffers DirectSound buffers are your main tools in DirectSound. They are akin to the surfaces used in Direct3D in more ways than one. They even operate in a similar way. Just like surfaces, in order to access their data you need to lock them and then unlock them when you're finished. This is for the same reason as in Direct3D: The DirectSound driver can operate asynchronously from the user application, so care must be taken that no application is reading data when another is reading from it, or vice versa. There are two kinds of buffers in DirectSound: primary buffers and secondary buffers. The primary buffer (there is only one of them) represents the sound that is currently playing on the card. There is a secondary buffer for each sound effect an application wants to play. Secondary sound buffers are mixed together into the primary buffer and play out the speakers. Using the mixer is how you get multiple sound effects to play at once; DirectSound has a well-optimized piece of code that can mix a bunch of secondary sound buffers together, and many sound cards can perform this operation in hardware automatically. One key difference between Direct3D surfaces and DirectSound buffers is that buffers are conceptually circular. When a sound effect is playing, the play marker loops around to the beginning of the buffer when it reaches the end, unless you tell it to do otherwise. The play marker is a conceptual marker in the buffer that represents where sound data is being retrieved.
133
Just like surfaces, buffers are created by filling out a description of what you want in the buffer. The structure used to describe a DirectSound buffer is called DSBUFFERDESC: typedef struct { DWORD
dwSize;
DWORD
dwFlags;
DWORD
dwBufferBytes;
DWORD
dwReserved;
LPWAVEFORMATEX lpwfxFormat; GUID
guid3DAlgorithm;
} DSBUFFERDESC, *LPDSBUFFERDESC; dwSize
Size of the structure; set this to sizeof(DSBUFFERDESC).
dwFlags
Flags that describe the capabilities or desired capabilities of the surface. Can be one or more of the following: DSBCAPS_CTRL3D—The buffer requires 3D control. It may be a primary or secondary buffer. DSBCAPS_CTRLFREQUENCY—The buffer requires the ability to control its frequency. DSBCAPS_CTRLPAN—The buffer requires the ability to control panning. DSBCAPS_CTRLPOSITIONNOTIFY—The buffer requires position notification. DSBCAPS_CTRLVOLUME—The buffer requires the ability to control its volume. DSBCAPS_GETCURRENTPOSITION2—Any calls to GetCurrentPosition() should use the new behavior of putting the read position where it is actually reading. The old behavior put it right behind the write position. The old behavior was also only on emulated DirectSound devices. DSBCAPS_GLOBALFOCUS—Like DSBCAPS_STICKYFOCUS, except the buffer can also be heard when other DirectSound applications have focus. The exception is applications that request exclusive access to the sound cards. All other global sounds will be muted when those applications have focus.
134
DSBCAPS_LOCDEFER—The buffer can be assigned to either hardware or software playback, depending on the mood of the driver. This flag must be set if the voice management features in version 9.0 are to be used. DSBCAPS_LOCHARDWARE—Forces the buffer to be mixed in hardware. The application must make sure there is a mixing channel available for the buffer. If there isn't enough memory on the card, or the card doesn't support hardware mixing, calling CreateSoundBuffer will fail. DSBCAPS_LOCSOFTWARE—Forces the buffer to be mixed in software. DSBCAPS_MUTE3DATMAXDISTANCE—This flag applies to advanced 3D sound buffers. DSBCAPS_PRIMARYBUFFER—Indicates that the buffer is the single and only primary buffer for the sound card. A secondary buffer is created if this flag is not set. DSBCAPS_STATIC—Informs the driver that the buffer will be filled once and played many times. This makes the driver more likely to put the buffer in hardware memory. DSBCAPS_STICKYFOCUS—Changes the focus behavior of a sound buffer. Buffers created with sticky focus aren't muted when the user switches to a non-DirectSound application. This is useful for applications like TV cards, where the user wants to hear what is happening while using another application. However, if the user switches to another DirectSound application, all sound effects are muted.
dwBufferBytes
Size of the buffer, in bytes. When you create the primary surface, this parameter should be set to zero.
dwReserved
Reserved for use by DirectSound; don't use.
lpwfxFormat
Pointer to a WAVEFORMATEX structure describing the format of the wave data in the buffer. This is analogous to the pixel formats describing the format of the pixels in Direct3D surfaces.
guid3DAlgorithm
GUID that defines the two-speaker virtualization algorithm to be used for
135
software rendering. This GUID is ignored unless the buffer needs 3D control (set by the DSBCAPS_CTRL3D flag). See the documentation for a listing of the available GUIDs for this parameter. The lpwfxFormat member of the sound buffer description is a pointer to a WAVEFORMATEX structure. The reason why there's no DS prefixing the structure is because it isn't a DirectSound structure, but instead is one used intrinsically by Windows for its sound playback work. typedef struct { WORD wFormatTag; WORD nChannels; DWORD nSamplesPerSec; DWORD nAvgBytesPerSec; WORD nBlockAlign; WORD wBitsPerSample; WORD cbSize; } WAVEFORMATEX; wFormatTag
A tag describing the content of the sound data. If the data is compressed, this tag will correspond to the particular method that was used to compress it. For non-compressed data, this will be set to the constant WAVE_FORMAT_PCM.
nChannels
The number of separate audio channels for the sound data. For monaural sound there is one channel; for stereo sound there are two.
nSamplesPerSec
The number of samples per second. For CD-quality audio this is about 44,100; for radio quality it is about 22,050.
nAvgBytesPerSec
The required data throughput to play the sound. This is here so you can deal with compressed sound files.
nBlockAlign
Block alignment in bytes. Essentially this is the amount of data for one sample. If you had two channels of audio and 16 bits (2 bytes) per sample, this would be 2*2 = 4 bytes.
wBitsPerSample
The number of bits for each discrete sample. This is generally either 8 or 16.
136
cbSize
The size of any extra info that is appended to the structure. This is only used by compressed sound formats.
Operations on Sound Buffers Once you have created a buffer and filled it with the appropriate data, you would, of course, like to play it. The Play() method on the buffer interface plays a sound buffer on the primary surface. The sound can be stopped by calling the Stop() method, which takes no parameters. HRESULT IDirectSoundBuffer8::Play( DWORD dwReserved1, DWORD dwPriority, DWORD dwFlags ); HRESULT IDirectSoundBuffer8::Stop(); dwReserved1
Reserved parameter; must be set to 0.
dwPriority
The priority of the sound. This is used by the sound manager in the event that it needs to evict a playing sound (it evicts the one with the lowest priority). The valid range is anywhere from 0x0 to 0xFFFFFFFF. 0 has the lowest priority. This value shouldn't be used if the surface wasn't created with the LOC_DEFER flag, and should be left as 0.
dwFlags
A set of flags describing the method's behavior. They are: DSBPLAY_LOOPING—Whenever the end of the buffer is reached, DirectSound wraps to the beginning of the buffer and continues playing it. This is useful for sounds like engine hums. The sound effect continues playing until it is explicitly shut off using Stop(). DSBPLAY_LOCHARDWARE—This flag only affects surfaces created with the DSBCAPS_LOCDEFER flag. It forces the buffer to be played in the hardware. If there aren't any voices available and no TERMINATEBY_* flags are set, Play() will fail. This flag shouldn't be used with DSBPLAY_LOCSOFTWARE. DSBPLAY_LOCSOFTWARE—This flag only affects surfaces created with the DSBCAPS_LOCDEFER flag. It forces the buffer to be played in software. If there aren't any voices available and no TERMINATEBY_* flags are set, Play()
137
will fail. This flag shouldn't be used with DSBPLAY_LOCHARDWARE. If neither LOCSOFTWARE or LOCHARDWARE is specified, the location for playback will be decided by the sound driver, depending on the available resources. DSBPLAY_TERMINATEBY_TIME—Setting this flag enables the buffer to steal resources from another buffer. The driver is forced to play the buffer in hardware. If no hardware voices are available, the driver chooses a buffer to remove, choosing the buffer that has the least amount of time left to play. The only candidate buffers for removal are ones created with the DSBCAPS_LOCDEFER flag. DSBPLAY_TERMINATEBY_DISTANCE—This flag is only relevant to 3D buffers, which are not discussed in this book. DSBPLAY_TERMINATEBY_PRIORITY—Setting this flag enables the buffer to steal resources from another buffer. The driver is forced to play the buffer in hardware. If no hardware voices are available, the driver chooses a buffer to remove, choosing the buffer that has the lowest priority. The only candidate buffers for removal are ones created with the DSBCAPS_LOCDEFER flag. Unfortunately, there is only one play marker per sound buffer, so you can't play the same sound twice at the same time. However, the code I'll show you can clone the sound effect into a new buffer and play the new effect, so you can have multiple sounds of the same type playing at the same time. To implement this, however, you need to know if the sound buffer is playing at any point in time. You can do this using the GetStatus method on the sound buffer interface: HRESULT IDirectSoundBuffer8::GetStatus( LPDWORD lpdwStatus );
lpdwStatus
Pointer to a DWORD that will be filled with the status of the sound buffer. If the function succeeds, the DWORD can check to see if any of the following flags are set: DSBSTATUS_BUFFERLOST—The sound buffer was lost. Before it can be played or locked, it must be restored using the Restore() method on the DirectSoundBuffer. Restore takes no parameters and reallocates the required memory for a DirectSound buffer. DSBSTATUS_LOOPING—The buffer is playing and also looping. It won't stop until the Stop() method is called on it. DSBSTATUS_PLAYING—The buffer is currently playing. The buffer is stopped if this flag isn't set.
138
DSBSTATUS_LOCSOFTWARE—The buffer is playing from system RAM. This flag is only meaningful for buffers that were created with the DSBCAPS_LOCDEFER flag. DSBSTATUS_LOCHARDWARE—The buffer is playing on the sound card's memory. This flag is only meaningful for buffers that were created with the DSBCAPS_LOCDEFER flag. DSBSTATUS_TERMINATED—The buffer was terminated by the sound logic. To play a buffer with anything meaningful in it, you're going to need to fill it with something. Unfortunately, DirectSound doesn't have the ability to automatically load WAV files, so you have to do it yourself. When you load the file and get the data, you put it into the sound buffer by locking it and getting a pointer to the buffer to write into. This is done using the Lock() method on the sound buffer interface. HRESULT IDirectSoundBuffer8::Lock( DWORD dwWriteCursor, DWORD dwWriteBytes, LPVOID lplpvAudioPtr1, LPDWORD lpdwAudioBytes1, LPVOID lplpvAudioPtr2, LPDWORD lpdwAudioBytes2, DWORD dwFlags ); dwWriteCursor
Offset from the start of the buffer (in bytes) to where the lock should begin.
dwWriteBytes
Number of bytes that should be locked. Remember that sound buffers are circular, conceptually. If more bytes are requested than are left in the file, the lock continues at the beginning of the buffer.
lplpvAudioPtr1
Pointer to be filled with the requested data pointer of the lock.
lpdwAudioBytes1
Pointer to be filled with the number of bytes of the first data block. This may or may not be the same as dwWriteBytes, depending on whether or not the lock wrapped to the beginning of the sound buffer.
139
lplpvAudioPtr2
Pointer to be filled with the secondary data pointer of the lock. This member is only set if the memory requested in the lock wrapped to the beginning of the buffer (it will be set to the beginning of the buffer). If the lock did not require a wrap, this pointer will be set to NULL.
lpdwAudioBytes2
Pointer to be filled with the number of bytes of the second data block. If the lock required a wrap, this will be the number of bytes left over after the wrap around.
dwFlags
A set of flags modifying the behavior of the lock method: DSBLOCK_FROMWRITECURSOR—Locks from the current write cursor in the buffer. DSBLOCK_ENTIREBUFFER—Locks the entire sound buffer. The dwWriteBytes parameter is ignored and can be set to zero.
To unlock a sound buffer after filling it, just call the Unlock() method on it. This allows other concurrent tasks on the machine, like the sound hardware, to access the sound buffer's data bits. HRESULT IDirectSoundBuffer8::Unlock( LPVOID lpvAudioPtr1, DWORD dwAudioBytes1, LPVOID lpvAudioPtr2, DWORD dwAudioBytes2 ); lpvAudioPtr1
Pointer to the first block of data to unlock. This must be the same value that was given by Lock().
dwAudioBytes1
Length of the first block of data to unlock. This must be the same value that was given by Lock().
lpvAudioPtr2
Pointer to the second block of data to unlock. This must be the same value that was given by Lock().
dwAudioBytes2
Length of the second block of data to unlock. This must be the same value that was given by Lock().
140
Loading WAV Files Call me old fashioned, but I try to avoid reinventing any wheels I can. One I distinctly do not want to reinvent is the WAV-file-loading wheel. The DirectX SDK comes with code to load a WAV file and create a DirectSound buffer, and I'm going to use it verbatim here. Rather than list the source code for it, which is pretty confusing, I'm just going to list the interface for it. You'll see how this fits into the code later. Listing 4.1: WavRead.h, the Microsoft-provided interface for the Wave Sound Reader object
//-------------------------------------------------------------------------// File: WavRead.h // // Desc: Support for loading and playing Wave files using DirectSound sound //
buffers.
// // Copyright (c) 1999 Microsoft Corp. All rights reserved. //-------------------------------------------------------------------------#ifndef WAVE_READ_H #define WAVE_READ_H
#include <mmreg.h> #include <mmsystem.h>
//-------------------------------------------------------------------------// Name: class CWaveSoundRead // Desc: A class to read in sound data from a Wave file //-------------------------------------------------------------------------class CWaveSoundRead { public:
141
WAVEFORMATEX* m_pwfx; HMMIO
// Pointer to WAVEFORMATEX structure
m_hmmioIn; // MM I/O handle for the WAVE
MMCKINFO
m_ckIn;
// Multimedia RIFF chunk
MMCKINFO
m_ckInRiff; // Use in opening a WAVE file
public: CWaveSoundRead(); ~CWaveSoundRead(); HRESULT Open( CHAR* strFilename ); HRESULT Reset(); HRESULT Read( UINT nSizeToRead, BYTE* pbData, UINT* pnSizeRead ); HRESULT Close(); };
#endif WAVE_READ_H
Implementing DirectSound with cSoundLayer The final system layer I'm going to implement in this chapter is the sound layer. The class is called cSoundLayer, and has the same restrictions as the graphics and input layers (most notably only one instance of the class may exist in any application). Creating the sound layer is simple enough. The sound layer has the same interface for creation that the graphics and input layers did: a static Create() method that took care of the initialization hassles. The Create method for the sound layer is simple enough, and it appears in the following: static void cSoundLayer::Create( HWND hWnd ) { new cSoundLayer( hWnd ); } The code that lies inside the cSoundLayer constructor is what I'll dissect next in the step-by-step process of setting up DirectSound.
Creating the DirectSound Object The first step in initializing DirectSound is to actually acquire the interface pointer to the IDirectSound8 object. To do this, you call the function DirectSoundCreate8.
142
HRESULT WINAPI DirectSoundCreate8( LPCGUID lpcGuid, LPDIRECTSOUND8 * ppDS, LPUNKNOWN pUnkOuter ); lpcGuid
A pointer to a GUID that describes the device you wish to create. While you can enumerate all of the sound devices with DirectSoundEnumerate, generally there is only one sound card on a machine. To get the default device (which is what you want, usually), set this to NULL.
ppDS
A pointer to an LPDIRECTSOUND8 interface pointer that will be filled with a valid interface pointer if the function succeeds.
pUnkOuter
Used for COM aggregation; leave this as NULL.
Sample code to create the sound interface appears in the following: LPDIRECTSOUND8 m_pDSound = 0;
// Create IDirectSound using the primary sound device hr = DirectSoundCreate8( NULL, &m_pDSound, NULL ); if( FAILED( hr ) ) { // Handle critical error }
Setting the Cooperative Level After you acquire the interface pointer, the next step is to declare how cooperative you intend on being. Just like DirectInput, this is done using the SetCooperativeLevel command. HRESULT IDirectSound8::SetCooperativeLevel( HWND hwnd, DWORD dwLevel );
143
hwnd
Handle to the window to be associated with the DirectSound object. This should be the primary window.
dwLevel
One of the following flags, describing the desired cooperative level. DSSCL_EXCLUSIVE—Grab exclusive control of the sound device. When the application has focus, it is the only audible application. DSSCL_NORMAL—Smoothest, yet most restrictive cooperative level. The primary format cannot be changed. This is the cooperative level the sound layer uses. DSSCL_PRIORITY—Like DDSCL_NORMAL except the primary format may be changed. DSSCL_WRITEPRIMARY—This is the highest possible priority for an application to have. It can't play any secondary buffers, and it has the ability to manually mangle the bits of the primary buffer. Only for the extremely hardcore!
This code will be changing the primary format of the sound buffer, so I'll go ahead and set this to DSSCL_PRIORITY. Sample code to do this appears in the following: // pDSound is a valid LPDIRECTSOUND8 object. HRESULT hr = pDSound->SetCooperativeLevel( hWnd, DSSCL_PRIORITY ); if( FAILED( hr ) ) { /* handle error */ }
Grabbing the Primary Buffer Since the sound layer sets the cooperative level's priority, it can do some crazy things like change the format of the primary buffer. Generally it's best to set the primary buffer to the same format that all of your secondary buffers will be in; this makes the mixer's job easier, as it doesn't have to resample any sound effects to be able to mix them into the primary buffer. You can imagine what would happen if you tried to play a 22 KHz sound effect in a 44 KHz buffer without resampling: You would run out of samples twice as soon as you would expect, and the sound effect would have sort of a chipmunkish quality to it. To change the format of the primary buffer, you just need to grab it using CreateSoundBuffer, fill out a new format description, and set it using the SetFormat() method on the primary buffer. Listing 4.2 has code that sets the primary format to 22 KHz, 16-bit stereo. Listing 4.2: Sample code to change the format of the primary buffer
144
// pDSound is a valid LPDIRECTSOUND object. LPDIRECTSOUNDBUFFER pDSBPrimary = NULL;
sAutoZero dsbd; dsbd.dwFlags = DSBCAPS_PRIMARYBUFFER; dsbd.dwBufferBytes = 0; dsbd.lpwfxFormat = NULL;
HRESULT hr = pDSound->CreateSoundBuffer( &dsbd, &pDSBPrimary, NULL ); if( FAILED( hr ) ) { /* handle error */ }
// Set primary buffer format to 22 kHz and 16-bit output. WAVEFORMATEX wfx; ZeroMemory( &wfx, sizeof(WAVEFORMATEX) ); wfx.wFormatTag
= WAVE_FORMAT_PCM;
wfx.nChannels
= 2;
wfx.nSamplesPerSec = 22050; wfx.wBitsPerSample = 16; wfx.nBlockAlign
= wfx.wBitsPerSample/8* wfx.nChannels;
wfx.nAvgBytesPerSec = wfx.nSamplesPerSec * wfx.nBlockAlign;
HRESULT hr = hr = pDSBPrimary->SetFormat(&wfx) if( FAILED( ) ) { throw cGameError( "SetFormat (DS) failed!" ); }
145
SafeRelease( pDSBPrimary );
With all the code in place, you can actually write the sound layer class. The header appears in Listing 4.3, and the source code is in Listing 4.4. Listing 4.3: SoundLayer.h
/******************************************************************* *
Advanced 3D Game Programming using DirectX 9.0
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
Desc: Sample application for Direct3D
* * copyright (c) 2002 by Peter A Walsh and Adrian Perez * See license.txt for modification and distribution information ******************************************************************/
#ifndef _SOUNDLAYER_H #define _SOUNDLAYER_H
#include #include "GameErrors.h" // Added by ClassView
class cSound;
class cSoundLayer {
LPDIRECTSOUND8
m_pDSound;
LPDIRECTSOUNDBUFFER8 m_pPrimary; // primary mixer
static cSoundLayer* m_pGlobalSLayer;
146
cSoundLayer( HWND hWnd );
public: virtual ~cSoundLayer();
static cSoundLayer* GetSound() { return m_pGlobalSLayer; }
LPDIRECTSOUND8 GetDSound() { return m_pDSound; } static void Create( HWND hWnd ) { new cSoundLayer( hWnd ); } };
inline cSoundLayer* Sound() { return cSoundLayer::GetSound(); }
#endif //_SOUNDLAYER_H
Listing 4.4: SoundLayer.cpp
/******************************************************************* *
Advanced 3D Game Programming using DirectX 9.0
147
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
Desc: Sample application for Direct3D
* * copyright (c) 2002 by Peter A Walsh and Adrian Perez * See license.txt for modification and distribution information ******************************************************************/
#include "stdafx.h"
#include "SoundLayer.h" #include "Sound.h"
cSoundLayer* cSoundLayer::m_pGlobalSLayer = NULL;
cSoundLayer::cSoundLayer( HWND hWnd ) { m_pDSound = NULL; m_pPrimary = NULL;
if( m_pGlobalSLayer ) { throw cGameError( "cSoundLayer already initialized!" ); } m_pGlobalSLayer = this;
HRESULT
hr;
LPDIRECTSOUNDBUFFER pDSBPrimary = NULL;
// Create IDirectSound using the primary sound device hr = DirectSoundCreate8( NULL, &m_pDSound, NULL ); if( FAILED( hr ) ) {
148
throw cGameError( "DirectSoundCreate failed!" ); }
// Set coop level to DSSCL_PRIORITY hr = m_pDSound->SetCooperativeLevel( hWnd, DSSCL_PRIORITY ); if( FAILED( hr ) ) { throw cGameError( "SetCooperativeLevel (DS) failed!" ); }
// Get the primary buffer sAutoZero dsbd; dsbd.dwFlags
= DSBCAPS_PRIMARYBUFFER;
dsbd.dwBufferBytes = 0; dsbd.lpwfxFormat
= NULL;
hr = m_pDSound->CreateSoundBuffer( &dsbd, &pDSBPrimary, NULL ); if( FAILED( hr ) ) { throw cGameError( "SetFormat (DS) failed!" ); }
// Set primary buffer format to 22 kHz and 16-bit output. WAVEFORMATEX wfx; ZeroMemory( &wfx, sizeof(WAVEFORMATEX) ); wfx.wFormatTag
= WAVE_FORMAT_PCM;
wfx.nChannels
= 2;
wfx.nSamplesPerSec = 22050; wfx.wBitsPerSample = 16; wfx.nBlockAlign
= wfx.wBitsPerSample/8* wfx.nChannels;
wfx.nAvgBytesPerSec = wfx.nSamplesPerSec * wfx.nBlockAlign;
149
if( FAILED( hr = pDSBPrimary->SetFormat(&wfx) ) ) { throw cGameError( "CreateSoundBuffer (DS) failed!" ); } SafeRelease( pDSBPrimary ); }
cSoundLayer::~cSoundLayer() { SafeRelease( m_pPrimary ); SafeRelease( m_pDSound ); m_pGlobalSLayer = NULL; }
The cSound Class To help facilitate the creation and playback of secondary buffers, I constructed an encapsulation class called cSound. A cSound object can be constructed either from a filename or from another cSound object. The copy constructor uses a ref-counting map so that all cSounds based on the same WAV file use the same CWaveSoundRead object. The overhead of the map could have been avoided if the CWaveSoundRead code was changed to accommodate the needed functionality, but I felt it was better to leave the code unchanged from the DirectX SDK. Without any further ado, let's just dive into the code. The details of how this code works isn't terribly interesting but have a look through it anyway to get accustomed to it. Listing 4.5: Sound.h
/******************************************************************* *
Advanced 3D Game Programming using DirectX 9.0
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
Desc: Sample application for Direct3D
* * copyright (c) 2002 by Peter A Walsh and Adrian Perez * See license.txt for modification and distribution information
150
******************************************************************/
#ifndef _SOUND_H #define _SOUND_H
#include <map>
#include "SoundLayer.h" #include "Wavread.h"
class cSound { CWaveSoundRead*
m_pWaveSoundRead;
LPDIRECTSOUNDBUFFER8 m_pBuffer; int
m_bufferSize;
/** * Multiple sounds that use the same * file shouldn't reread it, they should * share the CWSR object. This map * implements rudimentary reference counting. * I would have just changed CWaveSoundRead, * but I wanted to keep it unchanged from the * samples. */ static std::map< CWaveSoundRead*, int > m_waveMap;
void Init();
public: cSound( char* filename ); cSound( cSound& in );
151
cSound& operator=( const cSound &in );
virtual ~cSound();
void Restore(); void Fill(); void Play( bool bLoop = false );
bool IsPlaying();
};
#endif //_SOUND_H
Listing 4.6: Sound.cpp
/******************************************************************* *
Advanced 3D Game Programming using DirectX 9.0
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
Desc: Sample application for Direct3D
* * copyright (c) 2002 by Peter A Walsh and Adrian Perez * See license.txt for modification and distribution information ******************************************************************/
#include "stdafx.h"
#include "WavRead.h" #include "Sound.h"
using std::map;
152
map< CWaveSoundRead*, int > cSound::m_waveMap;
cSound::cSound( char* filename ) { m_pWaveSoundRead = NULL; m_pBuffer = NULL;
// Create a new wave file class m_pWaveSoundRead = new CWaveSoundRead(); m_waveMap[ m_pWaveSoundRead]=1;
// Load the wave file if( FAILED( m_pWaveSoundRead->Open( filename))) { throw cGameError("couldn't open file!"); } Init(); Fill(); }
cSound::cSound( cSound& in ) { m_pWaveSoundRead = in.m_pWaveSoundRead; m_waveMap[ m_pWaveSoundRead ]++; Init(); Fill(); }
cSound& cSound::operator=( const cSound &in ) { /**
153
* Destroy the old object */ int count = --m_waveMap[ m_pWaveSoundRead ]; if( !count ) { delete m_pWaveSoundRead; } SafeRelease( m_pBuffer );
/** * Clone the incoming one */ m_pWaveSoundRead = in.m_pWaveSoundRead; m_waveMap[ m_pWaveSoundRead ]++;
Init(); Fill();
return *this; }
cSound::~cSound() { int count = m_waveMap[ m_pWaveSoundRead ]; if( count == 1 ) { delete m_pWaveSoundRead; } else { m_waveMap[ m_pWaveSoundRead ] = count - 1; }
154
SafeRelease( m_pBuffer ); }
void cSound::Init() { /** * Set up the DirectSound surface. The size of the sound file * and the format of the data can be retrieved from the wave * sound object. Besides that, we only set the STATIC flag, * so that the driver isn't restricted in setting up the * buffer. */ sAutoZero dsbd; dsbd.dwFlags
= DSBCAPS_STATIC;
dsbd.dwBufferBytes = m_pWaveSoundRead->m_ckIn.cksize; dsbd.lpwfxFormat
= m_pWaveSoundRead->m_pwfx;
HRESULT hr;
// Temporary pointer to old DirectSound interface LPDIRECTSOUNDBUFFER pTempBuffer = 0;
// Create the sound buffer hr = Sound()->GetDSound()->CreateSoundBuffer( &dsbd, &pTempBuffer, NULL ); if( FAILED( hr ) ) { throw cGameError( "couldn't get buffer status" ); }
// Upgrade the sound buffer to version 8
155
pTempBuffer->QueryInterface( IID_IDirectSoundBuffer8, (void**)&m_pBuffer ); if( FAILED( hr ) ) { throw cGameError("CreateSoundBuffer failed!"); }
// Release the temporary old buffer pTempBuffer->Release();
/** * Remember how big the buffer is */ m_bufferSize = dsbd.dwBufferBytes; }
void cSound::Restore() { HRESULT hr; if( NULL == m_pBuffer ) { return; }
DWORD dwStatus; if( FAILED( hr = m_pBuffer->GetStatus( &dwStatus))) { throw cGameError("SoundBuffer query to 8 failed!"); }
if( dwStatus & DSBSTATUS_BUFFERLOST ) {
156
/** * Chances are, we got here because the app /just/ * started, and DirectSound hasn't given us any * control yet. Just spin until we can restore * the buffer */ do { hr = m_pBuffer->Restore(); if( hr == DSERR_BUFFERLOST ) Sleep( 10 ); } while( hr = m_pBuffer->Restore() );
/** * The buffer was restored. Fill 'er up. */ Fill(); } }
void cSound::Fill() { HRESULT hr; uchar* pbWavData; // Pointer to actual wav data uint
cbWavSize; // Size of data
void*
pbData = NULL;
void*
pbData2 = NULL;
ulong
dwLength;
ulong
dwLength2;
/**
157
* How big the wav file is */ uint nWaveFileSize = m_pWaveSoundRead->m_ckIn.cksize;
/** * Allocate enough data to hold the wav file data */ pbWavData = new uchar[ nWaveFileSize ]; if( NULL == pbWavData ) { delete [] pbWavData; throw cGameError("Out of memory!"); }
hr = m_pWaveSoundRead->Read( nWaveFileSize, pbWavData, &cbWavSize ); if( FAILED( hr ) ) { delete [] pbWavData; throw cGameError("m_pWaveSoundRead->Read failed"); } /** * Reset the file to the beginning */ m_pWaveSoundRead->Reset();
/** * Lock the buffer so we can copy the data over */ hr = m_pBuffer->Lock(
158
0, m_bufferSize, &pbData, &dwLength, &pbData2, &dwLength2, 0L ); if( FAILED( hr ) ) { delete [] pbWavData; throw cGameError("m_pBuffer->Lock failed"); }
/** * Copy said data over, unlocking afterwards */ memcpy( pbData, pbWavData, m_bufferSize ); m_pBuffer->Unlock( pbData, m_bufferSize, NULL, 0 );
/** * We're done with the wav data memory. */ delete [] pbWavData; }
bool cSound::IsPlaying() { DWORD dwStatus = 0; m_pBuffer->GetStatus( &dwStatus ); if( dwStatus & DSBSTATUS_PLAYING ) return true; else return false; }
void cSound::Play( bool bLoop ) {
159
HRESULT hr; if( NULL == m_pBuffer ) return;
// Restore the buffers if they are lost Restore();
// Play buffer DWORD dwLooped = bLoop ? DSBPLAY_LOOPING : 0L; if( FAILED( hr = m_pBuffer->Play( 0, 0, dwLooped))) { throw cGameError("m_pBuffer->Play failed"); } }
Additions to cApplication The only addition to cApplication is the InitSound call, which initializes the sound layer. After the call completes you can freely create cSound objects and play them. If this is not the behavior you would like in your application, the function is overloadable. The code is in the following: void cApplication::InitSound() { cSoundLayer::Create( MainWindow()->GetHWnd() ); }
Application: DirectSound Sample Adrian, the lead author of the DirectX 7.0 version of this book, has a few interesting hobbies. As part of an ongoing effort, he does extracurricular activities that actually have nothing to do with programming. One of them is an a cappella group that he sings bass in. One of his jobs in the a cappella group is to take care of some of the vocal percussion. A cappella music can't have any sort of accompaniment, so any percussion needs to be done with the human voice. This has spawned an entire subculture of vocal percussionists, each trying to make that
160
perfect snare sound or cymbal crash using only their mouths. The DirectSound sample for this chapter was created using Adrian's unique vocal abilities. When you load the file DSSAMPLE from the companion files, you're presented with a small window that lists six different vocal percussion sounds. The keys 1 through 6 play each of the sounds, and you can press multiple keys simultaneously to play multiple sounds. You'll note that I didn't show you a DirectInput sample, because I figured it would be better to roll DirectSound and DirectInput into one sample. DirectInput is used to capture the keystrokes. With some practice you can get a pretty swank beat going. The code behind the sample appears in Listing 4.7. Listing 4.7: The vocal percussion DirectSound sample app
/******************************************************************* *
Advanced 3D Game Programming using DirectX 9.0
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
Desc: Sample application for Direct3D
* * copyright (c) 2002 by Peter A Walsh and Adrian Perez * See license.txt for modification and distribution information ******************************************************************/
#include "stdafx.h"
#include #include <string> using namespace std;
class cDSSampleApp : public cApplication, public iKeyboardReceiver { vector< cSound* > m_sounds[6]; string m_names[6];
int m_states[6]; // states of the keys 1-6
161
public:
void PlaySound( int num );
//==========-------------------------- cApplication
virtual void DoFrame( float timeDelta ); virtual void SceneInit();
cDSSampleApp() : cApplication() { m_title = string( "DirectSound Sample" ); m_width = 320; m_height = 200; for( int i=0; iSetReceiver( this );
for( int i=0; iPlay(); }
void cDSSampleApp::DoFrame( float timeDelta ) { // Clear the previous contents of the back buffer Graphics()->GetDevice()->Clear( 0, 0, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, D3DCOLOR_XRGB( 0,0,200), 1.0f, 0 ); // Set up the strings string help; help += "DirectSound Sample application\n"; help += "Vocal Percussion with Adrian Perez\n";
164
help += " [1]: Keg drum\n"; help += " [2]: Crash 1\n"; help += " [3]: Crash 2\n"; help += " [4]: Bass drum\n"; help += " [5]: Snare drum\n"; help += " [6]: Hi-Hat\n";
// Tell Direct3D we are about to start rendering Graphics()->GetDevice()->BeginScene();
// Output the text Graphics()->DrawTextString( 1, 1, D3DCOLOR_XRGB( 0, 255, 0), help.c_str() );
// Tell Direct3D we are done rendering Graphics()->GetDevice()->EndScene();
// Present the back buffer to the primary surface Graphics()->Flip(); }
void cDSSampleApp::KeyDown( int key ) { switch( key ) { case DIK_1: if( !m_states[0] ) { m_states[0] = 1; PlaySound(0); } break;
165
case DIK_2: if( !m_states[1] ) { m_states[1] = 1; PlaySound(1); } break; case DIK_3: if( !m_states[2] ) { m_states[2] = 1; PlaySound(2); } break; case DIK_4: if( !m_states[3] ) { m_states[3] = 1; PlaySound(3); } break; case DIK_5: if( !m_states[4] ) { m_states[4] = 1; PlaySound(4); } break; case DIK_6: if( !m_states[5] ) { m_states[5] = 1;
166
PlaySound(5); } break; } }
void cDSSampleApp::KeyUp( int key ) { switch( key ) { case DIK_1: m_states[0] = 0; break; case DIK_2: m_states[1] = 0; break; case DIK_3: m_states[2] = 0; break; case DIK_4: m_states[3] = 0; break; case DIK_5: m_states[4] = 0; break; case DIK_6: m_states[5] = 0; break; } }
167
And that, ladies and gentlemen, is DirectSound. You should be able to build on top of the code I have shown you in this chapter to create the perfect acoustic accompaniment to your own projects without too much difficulty. Now it's time to focus on the 3D mathematics that you need to start exploring the next dimension with Direct3D. What is the matrix? You're about to find out…
Chapter 5: 3D Math Foundations When you really get down to it, using 3D graphics is an exercise in math. Some of the math can be intensely interesting; some of it can be seriously dull. It all depends on the eye of the beholder. Love it or hate it, however, you still have to learn it. A solid foundation in math is a requirement if you want to be a successful 3D coder. Don't worry, though; I'll try to keep this chapter as interesting as possible.
Points Let's start with the most basic of basic primitives: the 3D point, or vector. Points are paramount in 3D graphics. The vertices of objects, the objects' locations and directions, and their velocities/forces are all described with 3D points. Three-dimensional objects have width, height, and depth, which are represented with the shorthand components x (width), y (height), and z (depth). Points and vectors, when used in equations, are referred to as vector quantities, while regular numbers are referred to as scalar quantities. In this book I'll refer to 3D vectors with lower-case, boldface letters (examples would be v and p). The three components are written separated by commas like this: <x,y,z>. They are also represented as a single row matrix (or, equivalently, a transposed single column matrix). If you're unfamiliar with the concept of matrices, have patience: I'll get there soon. At the right is an example of how points are represented using matrix notation:
Note
In the book I use the terms "point" and "vector" interchangeably. They loosely mean the same thing. A point is a location in 3D space, and a vector is a line that goes from the origin to a location in 3D space. For all the math that I'm discussing in this book, they can be used interchangeably.
Here are a few examples of three-dimensional points. It's difficult to represent the dimensions on paper, so please be tolerant of the illustrations used in this book.
168
Figure 5.1: Examples of 3D vectors 3D points are graphed in a way analogous to the 2D Cartesian coordinate system. There are three principal axes stretching off into infinity in both directions. These are the x, y, and z axes. They meet at the origin, a specific point that represents the center of the current coordinate system (typically you have several coordinate systems to worry about, but I'll leave this until later). The coordinates of the origin are, of course, . Which way do the axes point? In some systems (for example, some 3D modelers like 3D Studio Max), x increases to the right, y increases forward (into the page), and z increases up. These directions are all dependent on the orientation of the viewer of the scene. My choice of axes direction is the one used in most 3D games: x increases to the right, y increases up, and z increases forward, into the monitor (or away from you if that makes it clearer). Note
This book uses a left-handed coordinate space, where x increases to the right, y increases up, and z increases forward (into the screen). In right-handed coordinate systems, z increases coming out of the screen.
A point always exists some distance away from the origin of the coordinate space; this quantity is called the magnitude of the vector (or, more intuitively, the length of the vector). To compute the magnitude of vectors in 2D, you use the Pythagorean theorem:
Luckily, the Pythagorean theorem extends into 3D to measure the length of 3D vectors by simply adding the extra z component into the equation. You can see that the 2D Pythagorean equation is simply a special case of the 3D equation where the z-distance from the origin is zero.
169
There is a shorthand notation used to denote the magnitude of a vector when used in more complex equations. The notation is the vector surrounded on both sides by double vertical lines. The equation for vector length, given a vector v with components x, y, and z is:
A special type of vector is one that has a length of 1. This type of vector is called a unit vector. Each unit vector touches a point on what is called the unit sphere, a conceptual sphere with radius 1, situated at the origin. It's often the case that you want a unit-length version of a given vector. For example, the unit-length version n of a given vector m would be:
For simplicity's sake, however, I'll introduce some shorthand notation. The same equation can be represented by putting a bar over m to signify the unit-length version:
There are three specific unit vectors that represent the directions along the three primary axes: i , j , and k .
Figure 5.2: The i, j, and k vectors Many physics texts use the i, j, and k vectors as primitives to describe other 3D vectors, so it is worth mentioning it here. Any point in 3D can be represented as a linear combination of the i, j, and k vectors. You can define any vector as a sum of the scalar components with the three principal vectors. For example, if you had the 3D vector a = , you could represent it like this:
170
This trait will become more important later on, when I discuss matrices and the spaces they represent. Aside
While it isn't really pertinent to the level of expertise you need to reach in this book, the concept of a linear combination is important when talking about spaces and transformations. Given n vectors b0..bn−1, any vector v is a linear combination of the set of the vectors if the following equation can be satisfied:
where k0..kn−1 are scalars. That is, if you want to get to v, you can start at the origin and walk along any or all of the vectors some amount and reach v. You can say the set of b vectors is linearly independent if no single b vector is a linear combination of the others.
The point3 Structure It is always useful to design a class to encapsulate a generic 3D point. The class name I use is point3. Unlike most of the other classes you have seen so far, the intent of the point3 structure is to act as a mathematical primitive like float or int. The 3 suffix denotes the dimension of the point. I'll also define 2D and 4D versions of points, which are named point2 and point4, respectively. Listing 5.1: The point3 structure (defined in point3.h)
struct point3 { union { struct { float x,y,z;
// 3 real components of the vector
}; float v[3];
// Array access useful in for loops
};
171
// Default constructor point3(){}
// Construct a point with 3 given inputs point3( float X, float Y, floatZ): x(X), y(Y), z(Z) { } // ... more will go in here. };
This class uses a union in conjunction with a nameless struct. If you've never encountered unions before, a union is used to name components that share memory. So, in the above code, the y variable and the v[1] variable represent the same piece of memory; when one of them changes, both of them change. A nameless struct is used to let you define the x, y, and z components as one atomic unit (since I don't want them to each be referring to the same piece of memory). This way you can use the familiar x,y,z notation for most of the code, but maintain the ability to index into an array for iteration. Aside
The non-default constructor uses initialization lists. C++ classes should use these whenever possible. They clarify the intent of the code to the compiler, which lets it do its job better (it has a better chance to inline the code, and the code will end up being considerably more efficient, especially for complex structures).
Finally, you may wonder why I'm choosing floats (32 bits/4 bytes) instead of doubles (64 bits/8 bytes) or long doubles (80 bits/10 bytes). Well, I could just implement the point as a template class, but there are too many other interactions with other classes to complicate the code that much. Using it as a template in a way defeats the concept of using the point as a generic primitive, especially since there is a space of only three types I would use. Doubles and long doubles are slower than floats, about twice as slow for things like divides (19 versus 39 cycles), and on top of that they require twice the space. The added precision really isn't important unless you really need a wide range of precision. Within a few years worlds will be big enough and model resolution will be fine enough that you may need to employ larger floating-point resolutions to get the job done. Until then I'd suggest sticking with traditional floats.
Basic point3 Functions
172
The point3 structure is pretty lame right now. All it can do is construct structures! To spice it up, I'll add some member functions to help perform some basic operations on 3D points, and explain what they are used for.
Assign Setting a point to a certain value is a common task. It could be done explicitly in three lines, setting the x, y, and z values separately. However, for simplicity's sake, it's easier to set them all at once, with a single function call. This is also better than just creating a new variable on the stack with a point3 constructor; it's more efficient to reuse stack variables whenever possible. The code to do this appears in Listing 5.2. Listing 5.2: point3::Assign
// Reassign a point without making a temporary structure inline void point3::Assign( float X, float Y, float Z ) { x=X; y=Y; z=Z; }
Mag and MagSquared The function Mag uses the 3D version of the Pythagorean theorem mentioned previously to calculate the length of the point structure (the distance from the point to the origin). The code appears in Listing 5.3. Listing 5.3: point3::Mag
inline float point3::Mag() const { return (float)sqrt( x*x + y*y + z*z ); }
173
Sometimes you want the squared distance (for example, when calculating the attenuation factor for a point-source light). Rather than computing the expensive square root and squaring it, you can avoid the cost and simply make an extra function to do it for you, which appears in Listing 5.4. Listing 5.4: point3::MagSquared
inline float point3::MagSquared() const { return ( x*x + y*y + z*z ); }
Normalize Normalize takes a point structure and makes it a unit-length vector pointing in the same direction. The code appears in Listing 5.5. Listing 5.5: point3::Normalize
inline void point3::Normalize() { float InvertedMagnitude=1/Mag(); x*=InvertedMagnitude; y*=InvertedMagnitude; z*=InvertedMagnitude; }
Dist Dist is a static function that calculates the distance between two point structures. Conceptually, it finds the vector that connects them (which is the vector b–a) and computes its length. The code appears in Listing 5.6. Listing 5.6: point3::Dist
inline static float point3::Dist( const point3 &a, const point3 &b )
174
{ point3 distVec( b.x - a.x, b.y - a.y, b.z - a.z ); return distVec.Mag(); }
point3 Operators Now that there is a basic primitive I can use, like other primitives (e.g., int or float), I need some way to operate on the data. Since vectors can be added, subtracted, and multiplied (sort of), just like scalars, it would be cool to have an easy way to perform these operations. Operator overloading to the rescue! C++ lets you modify/define the behavior of operators on classes.
Addition/Subtraction Vector addition and subtraction are useful in moving points around in 3D. Conceptually, adding a vector to another moves the location of the first vector in the direction of the second. Figure 5.3 shows what the result of vector addition looks like, and Figure 5.4 shows the result of vector subtraction.
Figure 5.3: Vector addition example
175
Figure 5.4: Vector subtraction example In many respects, vector addition/subtraction is incredibly similar to the normal scalar addition that I'm sure you know and love. For example, if you wanted to find the average location of a set of vectors, you simply add them together and divide the result by the number of vectors added, which is, of course, the same averaging formula used for scalars. The code for adding/subtracting vectors is equally similar to their scalar cousins: Simply add (or subtract) each component together separately. I'll give the + and − operators; in the code you'll find the += and −= operators. Listing 5.7: Addition and subtraction operators for point3
inline point3 operator+(point3 const &a, point3 const &b) { return point3 ( a.x+b.x, a.y+b.y, a.z+b.z ); };
inline point3 operator-(point3 const &a, point3 const &b) { return point3
176
( a.x-b.x, a.y-b.y, a.z-b.z ); };
Vector-Scalar Multiplication/Division Often, you may want to increase or decrease the length of a vector, while making sure it still points in the same direction. Basically, you want to scale the vector by a scalar. Figure 5.5 shows what scaling vectors looks like.
Figure 5.5: Multiplying/dividing vectors by scalars Doing this in code is easy enough; just multiply (or divide) each component in the vector by the provided scalar. Listing 5.8 has the * and / operators; the *= and /= operators are defined in the header. Note that I defined two multiplicative operators; one for vector * scalar and another for scalar * vector. Listing 5.8: Scalar multiplication/division operators for point3
inline point3 operator*(point3 const &a, float const &b) { return point3
177
( a.x*b, a.y*b, a.z*b ); };
inline point3 operator*(float const &a, point3 const &b) { return point3 ( a*b.x, a*b.y, a*b.z ); };
inline point3 operator/(point3 const &a, float const &b) { float inv = 1.f / b; // Cache the division. return point3 ( a.x*inv, a.y*inv, a.z*inv ); };
Vector Equality
178
Often, you want to know if two points represent the same location in 3D. You can use this to see if two polygons share an edge, or if two triangles are the same, for example. I'll overload the equality operator (==) to do this. This one, at first glance, would be a no-brainer; just compare to see if the x, y, and z values match up. However, the answer is not as simple as that. This is one of many points where an important line in the sand must be drawn, a line between the wonderful land of theory and the painful land of reality. In Theory, there is infinite precision for scalar values. The decimal value of 1/3 has a string of 3s that never ends. When you multiply two scalar numbers together, the solution is exactly the correct one. When comparing two floating-point numbers, you know (with infinite precision) whether or not the numbers are equal. When multiplying an extremely large number by an extremely small one, the result is exactly what was expected. Everything is nice, in Theory. However, right now real estate is pretty expensive over there, so you and I are going have to stay here, in Reality. In Reality, floating pointers do not have infinite precision. Floats (32 bits) and doubles (64 bits) can only encode so much precision (around 5 and 15 base 10 places, respectively). They do not multiply nicely. If you multiply an extremely large number and an extremely small number, the solution is not the solution you might expect, due to the lack of precision. Finally, they do not handle equality too well. Due to all the imprecision floating around, two different paths of calculation that should result in the same answer can yield subtly different, although technically equal, numbers. Note
Look on the web for programming horror stories, and you'll see thatcountless problems in computer programming come from assuming that floating- or fixed-point numbers will have enough precision for what you need.
So, how is this little issue fixed? In practice, the problem really can't be fixed, but it is possible to hack out a solution that works well enough. Epsilon values provide the answer. (You'll see them covered throughout the book; epsilons are used all over the place to correct for numerical imprecision.) What you do is make each point have a certain, extremely small mass, going out in each direction a value epsilon. For instance, I will be using an epsilon of 10−3, or 0.001. That way, in order to see if two points are equal (or, in this case, equal enough), you test to see if the difference between them is less than or equal to epsilon. If this case is satisfied for all three coordinates, then it can safely be said the two points are equal. Note
In case you haven't picked it up yet, getting a solution to a problem that is not necessarily correct but good enough is one of the mantras of graphics programming. There is never enough time to calculate everything the hard way; the more corners you can cut without people being able to tell, the more of an edge you'll have over your competition.
In code, this becomes:
179
Listing 5.9: point3 equality operator
// above somewhere: #define EPSILON 0.001 inline bool operator==(point3 const &a, point3 const &b) { if( fabs(a.x-b.x)<EPSILON ) { if( fabs(a.y-b.y)<EPSILON ) { if( fabs(a.z-b.z)<EPSILON ) { return true; // We passed } } } return false; // The points were not equal enough };
Dot Product The dot product (mathematically represented with the symbol •) is one of the most important operations in 3D graphics. It is used everywhere. Everything from transformation to clipping to BSP tree traversal uses the dot product. The mathematical definition for the dot product is this:
In this equation, u and v represent two vectors in 3D. The ||u|| and ||v|| represent the lengths of the vectors, and theta (θ) represents the angle between the vectors. As you can see from the equation, the result of the dot product equation is a scalar, not a vector. Conceptually, the dot product describes the relation between two vectors in scalar form. If one of the vectors is normalized, the dot product represents the length of the shadow that the other vector would cast, as shown in Figure 5.6.
180
Figure 5.6: The conceptual "shadow" the dot product produces This particular trait is used in clipping. Using the equation given above, you can rearrange the terms to provide a way to find the angle theta between two vectors:
This works out very conveniently if both vectors are unit-length; two square roots (to find the vector lengths) and a division drop out of the equation and you get:
How does this work? This seems like a rather arbitrary trait for the dot product to have. Well, for some insight, think back to your trigonometry days. My trigonometry professor had a little mnemonic device to help remember the basic rules of trigonometry called "SOHCAHTOA." The middle three letters say that cosine is equal to the adjacent edge divided by the hypotenuse of a right triangle or:
Now, on a unit circle, the hypotenuse will be length 1, so that drops out of the equation. You're left with cos(θ)= adjacent edge. Think of the adjacent edge as the shadow of the hypotenuse onto the x-axis as shown in Figure 5.7.
181
Figure 5.7: Visual definitions of the cosine terms
Figure 5.8: The analog to cosine in the vector world So if, for the sake of this example, v is a unit vector going out along the x-axis, and u is a unit vector of the hypotenuse, then u•v will give the length of the shadow of u onto v, which is equivalent to the adjacent edge in the right triangle, and therefore cos(θ). The actual code behind the dot product is much simpler than the equations above, devoid of square roots, divides, and cosines (which is great, since the dot product is computed so often!). The dot product is achieved by summing the piecewise multiplication of each of the components. To implement dot products, I'm going to overload the multiplication operator *. It seems almost mysterious how three multiplications and two additions can make the same result that you get from the complex equation above, but don't look a gift horse in the mouth, as they say.
182
Listing 5.10: Dot product operator
inline float operator*(point3 const &a, point3 const &b) { return a.x*b.x + a.y*b.y + a.z*b.z; }
Cross Product Another operation that can be performed between two vectors is called the cross product. It's represented mathematically with the symbol ×. The formula for computing the cross product is shown at the right:
The operation returns a vector, not a scalar like the dot product. The vector it returns is mutually orthogonal to both input vectors. A vector mutually orthogonal to two others means that it is perpendicular to both of them. The resultant vector from a cross product is perpendicular (or orthogonal) to both of the input vectors. Once I start discussing planes you'll see how useful they can be. For most applications of the cross product, you want the result to be unit-length. Warning
If the two input vectors in a cross-product operation are parallel, the result of the operation is undefined (as there are an infinite number of vectors that are perpendicular to one vector).
An important note is that the cross product operation is not commutative. That is, a × b is not the same as b × a. They are very similar, however, as one points in the opposite direction of the other. Now it's time for some implementation. Since the * operator is already used for the dot product, something else needs to be picked instead. The choice of operator is fairly arbitrary, but following the example of a former professor of mine named David Baraff (who's now working at Pixar), I use the XOR operator ^. The code, while not the most intuitive thing in the world, follows the equations stated above. Listing 5.11: Cross product operator
inline point3 operator^(point3 const &a, point3 const &b) {
183
return point3 ( (a.y*b.z-a.z*b.y), (a.z*b.x-a.x*b.z), (a.x*b.y-a.y*b.x) ); }
The full code that defines all the behavior for points in 3D is found in the downloadable files in the code directory for this chapter in point3.h and point3.cpp. Also included are point4.h and point4.cpp, which define four-dimensional points (you'll see these later for quaternion rotations and parametric surfaces).
Polygons The polygon is the bread and butter of computer graphics. Rendered images would be pretty bland if you didn't have the polygon. While there are other primitives used in computer graphics (implicit surfaces, for example), just about every personal computer on the market today has hardware in it to accelerate the drawing of polygons (well, triangles actually … but same difference), so the polygon is king. All of the polygons dealt with here are convex. Convex polygons have no dents or pits, i.e., no internal obtuse angles. A convex polygon is much easier to rasterize, easier to clip, easier to cull, and the list goes on. While you could deal with concave polygons, the code to manage them and draw them is harder than in the convex case. It's much easier to represent concave polygons with two or more convex polygons. Polygons (or triangles, which I'll discuss next) describe the boundary representation of an object (academic and CAD texts often use the term b-rep to mean this). A b-rep is simply a set of polygons that exactly define the boundary surface of an object. If the object is a cube, the b-rep is the six square polygons that make up each face. Figure 5.9 has four examples of polygons. Two are convex, and two are not.
184
Figure 5.9: Different types of polygons For now, I'll implement polygons with a template class. This is because I don't want to have to reimplement the class for holding indices or point data (I'll discuss what this means later). While polygons could be implemented with a fully dynamic array, like an STL vector, I chose to limit the functionality for the sake of speed. Each polygon is created with a maximum number of possible elements it can contain. For most applications, a number like 8 or 10 will suffice. In addition to this, there is the number of actual elements in the polygon. This number should never be greater than the maximum number of elements. Let's take a look at the polygon class. Listing 5.12 has the code for it. Listing 5.12: The polygon template struct, defined in polygon.h
template struct polygon { int nElem; // number of elements in the polygon int maxElem;
type *pList;
polygon() { nElem = 0; maxElem = 0; pList = NULL; }
185
polygon( int maxSize ) { maxElem = maxSize; pList = new type[maxSize]; } polygon( const polygon &in ) { CloneData( in ); } ~polygon() { DestroyData(); }
void CloneData( const polygon &in ) { if( !in.pList ) return;
pList = new type[in.maxElem]; maxElem = in.maxElem; nElem = in.nElem; for( int i=0; i is any point that satisfies the equation. The set of all points <x,y,z> that solve the equation is exactly all the points that lie in the plane.
190
All of the pictures I'm showing you will be of the top-down variety, and the 3D planes will be on edge, appearing as 2D lines. This makes figure drawing much easier; if there is an easy way to represent infinite 3D planes in 2D, I sure don't know it. (If only Q were here, he could tell me…) Following are two examples of planes. The first has the normal pointing away from the origin, which causes d to be negative (try some sample values for yourself if this doesn't make sense). The second has the normal pointing towards the origin, so d is positive. Of course, if the plane goes through the origin, d is zero (the distance from the plane to the origin is zero). Figures 5.13 and Figure 5.14 provide some insight into this relation.
Figure 5.13: d is negative when the normal faces towards the origin
Figure 5.14: d is positive when it faces away from the origin
191
It's important to notice that technically the normal does not have to be unit-length for it to have a valid plane equation. But since things end up nicer if the normal is unit-length, all of the normals in this book are unit-length. The basic plane3 structure is defined in Listing 5.14. Listing 5.14: The plane3 structure
struct plane3 {
point3 n; // Normal of the plane float d; // Distance along the normal to the origin
plane3( float nX, float nY, float nZ, float D) : n( nX, nY, nZ ), d( D ) { // All done.
} plane3( const point3& N, float D) : n( N ), d ( D ) { // All done. }
// Construct a plane from three 3D points plane3( const point3& a, const point3& b, const point3& c);
// Construct a plane from a normal direction and // a point on the plane plane3( const point3& norm, const point3& loc);
// Construct a plane from a polygon plane3( const polygon<point3>& poly );
192
plane3() { // Do nothing }
// Flip the orientation of the plane void Flip(); };
Constructing a plane given three points that lie in the plane is a simple task. You just perform a cross product between the two vectors made up by the three points (<point2 − point0> and <point1 − point0>) to find a normal for the plane. After generating the normal and making it unit length, finding the d value for the plane is just a matter of storing the negative dot product of the normal with any of the points. This holds because it essentially solves the plane equation above for d. Of course plugging a point in the plane equation will make it equal 0, and this constructor has three of them. Listing 5.15 has the code to construct a plane from three points. Listing 5.15: Constructing a plane from three points on the plane
inline plane3::plane3( const point3& a, const point3& b, const point3& c ) { n = (b-a)^(c-a); n.Normalize(); d = -(n*a); }
193
If you already have a normal and also have a point on the plane, the first step can be skipped. See Listing 5.16. Listing 5.16: Constructing a plane from a normal and a point on the plane
inline plane3::plane3( const point3& norm, const point3& loc) : n( norm ), d( -(norm*loc) ) { // all done }
Finally, constructing a plane given a polygon of point3 elements is just a matter of taking three of the points and using the constructor given above. Listing 5.17 shows what I'm talking about. Listing 5.17: Constructing a plane given a polygon<point3> structure
inline plane3::plane3( const polygon<point3>& poly ) { point3 a = poly.pList[0]; point3 b = poly.pList[1]; point3 c = poly.pList[2];
n = (b-a)^(c-a); n.Normalize(); d = -(n*a); }
This brings up an important point. If you have an n-sided polygon, nothing discussed up to this point is forcing all of the points to be coplanar. However, problems can crop up if some of the points in the polygon aren't coplanar. For example, when I discuss back-face culling in a moment, you may misidentify what is actually behind the polygon, since there won't be a plane that clearly defines what is in front of and what is behind the plane. That is one of the advantages of using triangles to represent geometry—three points define a plane exactly.
194
Defining Locality with Relation to a Plane One of the most important operations planes let you perform is defining the location of a point with respect to a plane. If you drop a point into the equation, it can be classified into three cases: in front of the plane, in back of the plane, or coplanar with the plane. Front is defined as the side of the plane the normal sticks out of. Here, once again, precision will rear its ugly head. Instead of doing things the theoretical way, having the planes infinitely thin, I'm going to give them a certain thickness of (you guessed it) epsilon. How do you orient a point in relation to a plane? Well, simply plug x, y, and z into the equation, and see what you get on the right side. If you get zero (or a number close enough to zero by plus or minus epsilon), then the point satisfied the equation and lies on the plane. Points like this can be called coplanar. If the number is greater than zero, then you know that you would have to travel farther along the origin following the path of the normal than you would need to go to reach the plane, so the point must be in front of the plane. If the number is negative, it must be behind the plane. Note that the first three terms of the equation simplify to the dot product of the input vector and the plane normal. Figure 5.15 has a visual representation of this operation, and Listing 5.18 has the code for it.
Figure 5.15: Classifying points with respect to a plane Listing 5.18: plane3::TestPoint
// Defines the three possible locations of a point in // relation to a plane enum ePointLoc {
195
ptFront, ptBack, ptCoplanar }; // we're inlining this because we do it constantly inline ePointLoc plane3::TestPoint( point3 const &point ) const { float dp = (point * n) + d; if(dp > EPSILON) { return ptFront; } if(dp < -EPSILON ) { return ptBack; } return ptCoplanar; // it was between EP and -EP }
Once you have code to classify a point, classifying other primitives, like polygons, becomes pretty trivial, as shown in Listing 5.19. The one issue is there are now four possible definition states when the element being tested isn't infinitesimally small. The element may be entirely in front of the plane, entirely in back, or perfectly coplanar. It may also be partially in front and partially in back. I'll refer to this state as splitting the plane. It's just a term; the element isn't actually splitting anything. Listing 5.19: Polygon classification code
// Defines the four possible locations of a point list in // relation to a plane. A point list is a more general // example of a polygon. enum ePListLoc {
196
plistFront, plistBack, plistSplit, plistCoplanar };
ePListLoc plane3::TestPList( point3 *list, int num ) const { bool allfront=true, allback=true;
ePointLoc res;
for( int i=0; i &in, polygon<point3> *out ) const { // Make sure our pointer to the out polygon is valid assert( out ); // Make sure we're not passed a degenerate polygon assert( in.nElem>2);
int thisInd=in.nElem-1; int nextInd=0;
ePointLoc thisRes = TestPoint( in.pList[thisInd] ); ePointLoc nextRes;
out->nElem = 0;
for( nextInd=0; nextIndpList[out->nElem++] = in.pList[thisInd]; }
if( ( thisRes == ptBack && nextRes == ptFront ) || ( thisRes == ptFront && nextRes == ptBack ) ) { // Add the split point out->pList[out->nElem++] = Split( in.pList[thisInd], in.pList[nextInd] ); }
thisInd = nextInd;
thisRes = nextRes; } if( out->nElem >= 3 ) { return true; } return false; }
If you have code to take a polygon and clip off the area behind a plane, then creating a function to save the area behind the plane into an additional polygon isn't too hard. The operation takes a polygon that
203
has elements lying on both sides of a plane and splits it into two distinct pieces, one completely in front of and one completely behind the plane. The BSP code at the end of this chapter uses polygon splitting. The algorithm to do this follows directly from the clipping code, and the code is very similar. Listing 5.22: plane3::Split
bool plane3::Split( polygon<point3> const &in, polygon<point3> *pFront, polygon<point3> *pBack ) const {
// Make sure our pointer to the out polygon is valid assert( pFront ); // Make sure our pointer to the out polygon is valid assert( pBack ); // Make sure we're not passed a degenerate polygon assert( in.nElem>2);
// Start with curr as the last vertex and next as 0. pFront->nElem = 0; pBack->nElem = 0;
int thisInd=in.nElem-1; int nextInd=0;
ePointLoc thisRes = TestPoint( in.pList[thisInd] ); ePointLoc nextRes;
for( nextInd=0; nextIndpList[pFront->nElem++] = in.pList[thisInd]; }
if( thisRes == ptBack ) { // Add the point to the back pBack->pList[pBack->nElem++] = in.pList[thisInd]; }
if( thisRes == ptCoplanar ) { // Add the point to both pFront->pList[pFront->nElem++] = in.pList[thisInd]; pBack->pList[pBack->nElem++] = in.pList[thisInd]; }
if( ( thisRes == ptBack && nextRes == ptFront ) || ( thisRes == ptFront && nextRes == ptBack ) ) { // Add the split point to both point3 split = Split( in.pList[thisInd], in.pList[nextInd] ); pFront->pList[pFront->nElem++] = split; pBack->pList[pBack->nElem++] = split; }
thisInd = nextInd; thisRes = nextRes; }
205
if( pFront->nElem > 2 && pBack->nElem > 2) { // Nothing ended up degenerate return true; } return false; }
Object Representations Now that you have polygons and triangles, you can build objects. An object is just a boundary representation (and a few other traits, like materials, textures, and transformation matrices). Representing the boundary representations of objects is one of the ways that differentiate the myriad of 3D engines out there. There are many different ways to represent polygon data, each with its own advantages and disadvantages. A big concern is that triangles and polygons need more information than just position if anything interesting is going to be drawn. Typically, the points that make up the triangle faces of an object are called vertices, to differentiate them from points or vectors. Vertices can have many different types of data in them besides position, from normal information (for smooth shading), to texture coordinates for texture mapping, to diffuse and specular color information. I'll visit this point in Chapter 8 when I start showing you how to make 3D objects, but for right now keep in mind that the models will be more complex than just a list of points connecting a bunch of triangles. An unsophisticated first approach to representing an object would be to explicitly list each triangle as a triplet of vertices. This method is bad for several reasons. The main reason is that generally the objects are made up of a closed mesh of triangles. They meet up and touch each other; each vertex is the meeting point of two or more triangles. While a cube actually has only eight vertices, this method would need three distinct vertices for each of the 12 triangles, a total of 36 vertices. Any amount of work to do per-vertex would have to be done four times more than if you had a representation with only eight vertices. Because of this downfall, this method isn't used much.
206
Figure 5.20: Example of an object made up of distinct triangles However, it isn't without its advantages. For example, if the triangles are all distinct entities, you can do some neat effects, such as having the triangles fly off in separate directions when the object explodes (the game MDK did a good job with this; at the end of each level the world broke up into its component triangles and flew up into the sky). Another big advantage that this method has is it allows triangles that share vertex locations to have different color, texture, and normal information. For example, if you have the eight-vertex cube, where each vertex had a position and a color, all the triangles that share each corner have the same color information for that corner. If you want each face of the cube to have a different color, you can use explicit vertices for each triangle. Note
A better way to do this would be to only have explicit copies of the color information and just use one vector. However, this style of object representation doesn't work well with Direct3D.
If you don't need distinct information for each triangle, there is a much better way to represent the objects. There are two lists: one list of vertices representing all of the vertices in the object and one list of triangles, where each triangle is a triplet of integers, not points. The integers represent indices into the vertex list.
207
Figure 5.21: Index-based object definition This is the method used by many 3D applications, and the method most preferred by Direct3D. In Chapter 8, I'll create a format to represent objects of this type, and provide code both to load objects from disk and draw them. These aren't the only two horses in town. In Chapter 9, I'll talk about objects where vertices need to know adjacency information (that is, which other vertices are connected to it by triangle edges). There are even more esoteric systems, like the quad-edge data structure, whose data structures barely resemble objects at all, essentially being a pure graph of nodes and edges (nodes represent vertices; triangles are represented by loops in the graph).
Transformations Now that there are objects in the world, it would be good to be able to move them around the scene: animate them, spin them, and so forth. To do this you need to define a set of transformations that act upon the points in the objects. I'll start out with the simplest transformation: translation. To move an object by a given vector p, all you need to do is add p to each of the points in the object. The translation transformation can be defined by a vector p as T(p). The translation transformation is inverted easily. The transformation T-1(p) that undoes T(p) is just T(−p), in essence subtracting p from each point in the object. Unfortunately, translation isn't terribly interesting on its own. It is also important to be able to rotate the objects around arbitrary points and axes as well as translating them. The next thing to do is add rotation transformations. Before doing that, however, I need to talk a little about matrices.
Matrices A matrix is really just a shorthand way to write a set of simultaneous equations. For example, let's say you're trying to solve x, y, and z that satisfy the following three equations:
208
First, put all the coefficients of the equations into an n by m box called a matrix, where n (the vertical dimension) is the number of equations and m (the horizontal dimension) is the number of coefficients:
Here's a 3x4 matrix:
The subscript notation used above is how to reference individual elements of a matrix. The first component is the row number, and the second component is the column number. Matrices can be added together simply by adding each component. However, the matrices must be the same size to be able to add them (you couldn't, for example, add a 3x3 and a 2x2 matrix together).
Multiplying matrices together is a bit more involved. To find AB=C, each component cij of the resultant matrix is found by computing the dot product of the ith row of A with the jth column of B. The rules for matrix sizes are different than that in addition. If A is m by n and B is o by p, the multiplication is only valid if n = o, and the dimension of the resultant matrix is m by p. Note that multiplication only is valid if the row length of matrix A is the same as the column length of matrix B.
Another example (3x3 times 3x1 yields 3x1):
209
This way it is easy to represent the problem above of trying to solve a matrix equation. If you multiply out the matrices below into three simultaneous equations, you'll get the same three above.
Warning
Note that multiplication is not commutative. That is, AB is not the same as BA.
Matrix multiplication has an identity value, just like scalar multiplication (which has an identity of 1). The identity is only defined for square matrices, however. It is defined as a zeroed-out matrix with ones running down the diagonal. Here is the 3x3 identity matrix I3:
Matrix multiplication also has the law of associativity going for it. That means that as long as you preserve left-to-right order, you can multiply matrix pairs together in any order:
This will come into play later; right now just keep it in the back of your head. What does all this have to do with anything? Very good question. Matrices can be used to represent transformations, specifically rotations. You can represent rotations with 3x3 matrices and points as 1x3 matrices, multiplying them together to get transformed vertices.
There are three standard matrices to facilitate rotations about the x, y, and z axes by some angle theta. They are:
210
To show this happening, let's manually rotate the point 45 degrees clockwise about the z axis.
Now you can take an object and apply a sequence of transformations to it to make it do whatever you want. All you need to do is figure out the sequence of transformations needed and then apply the sequence to each of the points in the model. As an example, let's say you want to rotate an object sitting at a certain point p around its z axis. You would perform the following sequence of transformations to achieve this:
The first transformation moves a point such that it is situated about the world origin instead of being situated about the point p. The next one rotates it (remember, you can only rotate about the origin, not arbitrary points in space). Finally, after the point is rotated, you want to move it back so that it is situated about p. The final translation accomplishes this.
211
Figure 5.22: Visualizing compound transformations Notice the difference between a rotation followed by a translation and a translation followed by a rotation. You would be set now, except for one small problem: Doing things this way is kind of slow. There may be dozens of transformations to perform on an object, and if the object has thousands of points, that is dozens of thousands of transformations that need to be trudged through. The nice thing about matrices is that they can be concatenated together before they are multiplied by points. If there are two rotations, A and B, you know from the associativity law:
So before multiplying each of the points by both rotation transformations, you multiply them together into one matrix that represents both rotations, and just multiply the points by the new matrix. If you could also represent translations as matrices, you could concatenate the entire string of matrices together into one big matrix, cutting down on the transformation work quite a bit. There's a problem: 3x3 matrices can't encode translation. A translation is just an addition by another vector, and because of the semantics of matrix multiplication, you just can't make a 3x3 matrix that adds a vector to an input one. The way the graphics, robotics, mathematics, and physics communities have solved this problem is to introduce a fourth component to the vectors and an added dimension to the matrices, making them 4x4. The fourth coordinate is called the homogenous coordinate, and is represented with the letter w. There are an infinite number of 4D homogenous coordinates for any 3D Cartesian coordinate you can supply. The space of homogenous coordinates given a Cartesian coordinate is defined as this:
212
To reclaim a Cartesian coordinate from a homogenous coordinate, just make sure the w component is 1, and then get the x, y, and z values. If w isn't 1, then divide all four components by w (removing the b from the equation). Now you can change the translation transformation to a 4x4 matrix:
Note that multiplication by this matrix has the desired behavior:
The identity and rotation matrices change too, to reflect the added dimension:
213
Now that know how to represent all of the transformations with matrices, you can concatenate them together, saving a load of time and space. This also changes the way you might think about transformations. Each object defines all of its points with respect to a local coordinate system, with the origin representing the center of rotation for the object. Each object also has a matrix, which transforms the points from the local origin to some location in the world. When the object is moved, the matrix can be manipulated to move the points to a different location in the world. To understand what is going on here, you need to modify the way you perceive matrix transformations. Rather than translate or rotate, they actually become maps from one coordinate space to another. The object is defined in one coordinate space (which is generally called the object's local coordinate space), and the object's matrix maps all of the points to a new location in another coordinate space, which is generally the coordinate space for the entire world (generally called the world coordinate space). A nice feature of matrices is that it's easy to see where the matrix that transforms from object space to world space is sitting in the world. If you look at the data the right way, you can actually see where the object axes get mapped into the world space. Consider four vectors, called n, o, a, and p. The p vector represents the location of the object coordinate space with relation to the world origin. The n, o, and a vectors represent the orientation of the i, j, and k vectors, respectively.
Figure 5.23: The n, o, a, and p vectors for a transformation You can get and set these vectors right in the matrix, as they are sitting there in plain sight:
214
This system of matrix concatenations is how almost all 3D applications perform their transformations. There are four spaces that points can live in: object space, world space, and two new spaces: view space and screen space. View space defines how images on the screen are displayed. Think of it as a camera. If you move the camera around the scene, the view will change. You see what is in front of the camera (in front is defined as positive z).
Figure 5.24: Mapping from world space to view space The transformation here is different than the one used to move from object space to world space. Now, while the camera is defined with the same n, o, a, and p vectors as defined with the other transforms, the matrix itself is different. In fact, the view matrix is the inversion of what the object matrix for that position and orientation would be. This is because you're performing a backward transformation: taking points once they're in world space and putting them into a local coordinate space. As long as you compose the transformations of just rotations and translations (and reflections, by the way, but that comes into play much later in the book), computing the inverse of a transformation is easy. Otherwise, computing an inverse is considerably more difficult and may not even be possible. The inverse of a transformation matrix is given below.
215
Warning
This formula for inversion is not universal for all matrices. In fact, the only matrices that can be inverted this way are ones composed exclusively of rotations, reflections, and translations.
There is a final transformation that the points must go through in the transformation process. This transformation maps 3D points defined with respect to the view origin (in view space) and turns them into 2D points that can be drawn on the display. After transforming and clipping the polygons that make up the scene such that they are visible on the screen, the final step is to move them into 2D coordinates, since in order to actually draw things on the screen you need to have absolute x,y coordinates on the screen to draw. The way this used to be done was without matrices, just as an explicit projection calculation. The point <x,y,z> would be mapped to <x ′,y ′> using the following equations:
where xCenter and yCenter were half of the width and height of the screen, respectively. These days more complex equations are used, especially since there is now the need to make provisions for zbuffering. While you want x and y to still behave the same way, you don't want to use a value as arbitrary as scale. Instead, a better value to use in the calculation of the projection matrix is the horizontal field of view (fov). The horizontal fov will be hardcoded, and the code chooses a vertical field of view that will keep the aspect ratio of the screen. This makes sense: You couldn't get away with using the same field of view for both horizontal and vertical directions unless the screen was square; it would end up looking vertically squished. Finally, you also want to scale the z values appropriately. In Chapter 8, I'll teach you about z-buffering, but for right now just make note of an important feature: They let you clip out certain values of z-range. Given the two variables znear and zfar, nothing in front of znear will be drawn, nor will anything behind zfar. To make the z-buffer work swimmingly on all ranges of znear and zfar, you need to scale the valid z values to the range of 0.0 to 1.0. For purposes of continuity, I'll use the same projection matrix definition that Direct3D recommends in the documentation. First, let's define some values. You initially start with the width and height of the viewport and the horizontal field of view.
216
With these parameters, the following projection matrix can be made:
Just for a sanity check, check out the result of this matrix multiplication:
Hmm… this is almost the result wanted, but there is more work to be done. Remember that in order to extract the Cartesian (x,y,z) coordinates from the vector, the homogenous w component must be 1.0. Since, after the multiplication, it's set to z (which can be any value), all four components need to be divided by w to normalize it. This gives the following Cartesian coordinate:
As you can see, this is exactly what was wanted. The width and height are still scaled by values as in the above equation and they are still divided by z. The visible x and y pixels are mapped to [−1,1], so before rasterization Direct3D multiplies and adds the number by xCenter or yCenter. This, in essence, maps the coordinates from [−1,1] to [0,width] and [0,height]. With this last piece of the puzzle, it is now possible to create the entire transformation pipeline. When you want to render a scene, you set up a world matrix (to transform an object's local coordinate points into world space), a view matrix (to transform world coordinate points into a space relative to the viewer), and a projection matrix (to take those viewer-relative points and project them onto a 2D surface so that they can be drawn on the screen). You then multiply the world, view, and projection matrices together (in that order) to get a total matrix that transforms points from object space to screen space.
217
Warning
OpenGL uses a different matrix convention (where vectors are column vectors, not row vectors, and all matrices are transposed). If you're used to OpenGL, the equation above will seem backward. This is the convention that Direct3D uses, so to avoid confusion, it's what is used here.
To draw a triangle, for example, you would take its local space points defining its three corners and multiply them by the transformation matrix. Then you have to remember to divide through by the w component and voilá! The points are now in screen space and can be filled in using a 2D raster algorithm. Drawing multiple objects is a snap, too. For each object in the scene all you need to do is change the world matrix and reconstruct the total transformation matrix.
The matrix4 Structure Now that all the groundwork has been laid out to handle transformations, let's actually write some code. The struct is called matrix4, because it represents 4D homogenous transformations. Hypothetically, if you wanted to just create rotation matrices, you could do so with a class called matrix3. The definition of matrix4 appears in Listing 5.23. Listing 5.23: The matrix4 structure
struct matrix4 {
/** * we're using m[y][x] as our notation. */ union { struct { float _11, _12, _13, _14;
218
float _21, _22, _23, _24; float _31, _32, _33, _34; float _41, _42, _43, _44; }; float m[4][4]; }; // justification for a function this ugly: // provides an easy way to initialize static matrix variables // like base matrices for bezier curves and the identity matrix4(float IN_11, float IN_12, float IN_13, float IN_14, float IN_21, float IN_22, float IN_23, float IN_24, float IN_31, float IN_32, float IN_33, float IN_34, float IN_41, float IN_42, float IN_43, float IN_44) { _11 = IN_11; _12 = IN_12; _13 = IN_13; _14 = IN_14; _21 = IN_21; _22 = IN_22; _23 = IN_23; _24 = IN_24; _31 = IN_31; _32 = IN_32; _33 = IN_33; _34 = IN_34; _41 = IN_41; _42 = IN_42; _43 = IN_43; _44 = IN_44; }
matrix4() { // Do nothing. }
static const matrix4 Identity; };
The code contains three main ways to multiply matrices. Two 4x4 matrices can be multiplied together; this is useful for concatenating matrices. A point4 structure can be multiplied by a matrix4 structure; the result is the application of the transformation to the 4D point. Finally, a specialization for multiplying
219
point3 structures and matrix4 structures exists to apply a non-projection transformation to a point3 structure. The matrix4*matrix4 operator creates a temporary structure to hold the result, and isn't terribly fast. Matrix multiplications aren't performed often enough for this to be much of a concern, however. Warning
If you plan on doing a lot of matrix multiplications per object or even per triangle, you won't want to use the operator. Use the provided MatMult function; it's faster.
Listing 5.24: Matrix multiplication routines
matrix4 operator*(matrix4 const &a, matrix4 const &b) { matrix4 out;
// temporary matrix4 for storing result
for(int j = 0; j < 4; j ++)
// transform by columns first
for(int i = 0; i < 4; i ++)
// then by rows
out.m[i][j] = a.m[i][0] * b.m[0][j] + a.m[i][1] * b.m[1][j] + a.m[i][2] * b.m[2][j] + a.m[i][3] * b.m[3][j]; return out; };
inline const point4 operator*( const matrix4 &a, const point4 &b) { return point4( b.x*a._11 + b.y*a._21 + b.z*a._31 + b.w*a._41, b.x*a._12 + b.y*a._22 + b.z*a._32 + b.w*a._42, b.x*a._13 + b.y*a._23 + b.z*a._33 + b.w*a._43, b.x*a._14 + b.y*a._24 + b.z*a._34 + b.w*a._44 ); };
inline const point4 operator*( const point4 &a, const matrix4 &b) { return b*a;
220
};
inline const point3 operator*( const matrix4 &a, const point3 &b) { return point3( b.x*a._11 + b.y*a._21 + b.z*a._31 + a._41, b.x*a._12 + b.y*a._22 + b.z*a._32 + a._42, b.x*a._13 + b.y*a._23 + b.z*a._33 + a._43 ); };
inline const point3 operator*( const point3 &a, const matrix4 &b) { return b*a; };
There are two ways to create each type of matrix transformation. One performs on an existing matrix4 structure (it doesn't create a temporary matrix4 structure, which is slow). The function for a transformation x is void matrix4::Tox. The other is a static function designed to help write cleaner looking code, not for speed. The format for these functions is static matrix4 matrix4::x.
Translation Here again is the matrix for the translation transformation by a given point p:
The code to create this type of transformation matrix appears in Listing 5.25. Listing 5.25: Code to create a translation transformation
void matrix4::ToTranslation( const point3& p )
221
{ MakeIdent(); _41 = p.x; _42 = p.y; _43 = p.z; }
matrix4 matrix4::Translation( const point3& p ) { matrix4 out; out.ToTranslation( p ); return out; }
Basic Rotations The matrices used to rotate around the three principal axes, again, are:
The code to set up Euler rotation matrices appears in Listing 5.26. Listing 5.26: Code to create Euler rotation transformations
void matrix4::ToXRot( float theta ) {
222
float c = (float) cos(theta); float s = (float) sin(theta); MakeIdent(); _22=c; _23=s; _32 = -s; _33=c; }
matrix4 matrix4::XRot( float theta ) { matrix4 out; out.ToXRot( theta ); return out; } //==========--------------------------
void matrix4::ToYRot( float theta ) { float c = (float) cos(theta); float s = (float) sin(theta); MakeIdent(); _11 = c; _13 = -s; _31 = s; _33 = c; }
matrix4 matrix4::YRot( float theta ) { matrix4 out; out.ToYRot( theta );
223
return out; }
//==========--------------------------
void matrix4::ToZRot( float theta ) { float c = (float) cos(theta); float s = (float) sin(theta); MakeIdent(); _11 = c; _12 = s; _21 = -s; _22 = c; }
matrix4 matrix4::ZRot( float theta ) { matrix4 out; out.ToZRot( theta ); return out; }
Axis-Angle Rotation While there isn't enough space to provide a derivation of the axis-angle rotation matrix, that doesn't stop it from being cool. Axis-angle rotations are the most useful matrix-based rotation. (I say matrix-based because quaternions are faster and more flexible than matrix rotations; see Real-Time Rendering by Tomas Moller and Eric Haines for a good discussion on them.) There are a few problems with using just Euler rotation matrices (the x-rotation, y-rotation, z-rotation matrices you've seen thus far). For starters, there really is no standard way to combine them together.
224
Imagine that you want to rotate an object around all three axes by three angles. In which order should the matrices be multiplied together? Should the x-rotation come first? The z-rotation? Since no answer is technically correct, usually people pick the one convention that works best and stick with it. A worse problem is that of gimbal lock. To explain, look at how rotation matrices are put together. There are really two ways to use rotation matrices. Method 1 is to keep track of the current yaw, pitch, and roll rotations, and build a rotation matrix every frame. Method 2 uses the rotation matrix from the last frame, by just rotating it a small amount to represent any rotation that happened since the last frame. The second method, while it doesn't suffer from gimbal lock, suffers from other things, namely the fact that all that matrix multiplication brings up some numerical imprecision issues. The i, j, and k vectors of your matrix gradually become non-unit length and not mutually perpendicular. This is a bad thing. However, there are ways to fix it that are pretty standard, such as renormalizing the vectors, using cross-products to assure orthagonality. Gimbal lock pops up when you're using the first method detailed above. Imagine that you perform a yaw rotation first, then pitch, then roll. Also, say that the yaw and pitch rotations are both a quarter-turn (this could come up quite easily in a game like Descent). So imagine you perform the first rotation, which takes you from pointing forward to pointing up. The second rotation spins you around the y axis 90 degrees, so you're still facing up but your up direction is now to the right, not backward. Now comes the lock. When you go to do the roll rotation, which way will it turn you? About the z axis, of course. However, given any roll value, you can reach the same final rotation just by changing yaw or pitch. So essentially, you have lost a degree of freedom. This, as you would expect, is bad. Axis-angle rotations fix both of these problems by doing rotations much more intuitively. You provide an axis that you want to rotate around and an angle amount to rotate around that axis. Simple. The actual matrix to do it, which appears below, isn't quite as simple, unfortunately. For sanity's sake, just treat it as a black box. See Real-Time Rendering (Moller and Haines) for a derivation of how this matrix is constructed.
Code to create an axis-angle matrix transformation appears in Listing 5.27. Listing 5.27: Axis-angle matrix transformation code
void matrix4::ToAxisAngle( const point3& inAxis, float angle )
225
{ point3 axis = inAxis.Normalized(); float s = (float)sin( angle ); float c = (float)cos( angle ); float x = axis.x, y = axis.y, z = axis.z;
_11 = x*x*(1-c)+c; _21 = x*y*(1-c)-(z*s); _31 = x*z*(1-c)+(y*s); _41 = 0; _12 = y*x*(1-c)+(z*s); _22 = y*y*(1-c)+c; _32 = y*z*(1-c)-(x*s); _42 = 0; _13 = z*x*(1-c)-(y*s); _23 = z*y*(1-c)+(x*s); _33 = z*z*(1-c)+c; _43 = 0; _14 = 0; _24 = 0; _34 = 0; _44 = 1;
}
matrix4 matrix4::AxisAngle( const point3& axis, float angle ) { matrix4 out; out.ToAxisAngle( axis, angle ); return out; }
226
The LookAt Matrix I discussed before that the first three components of the first three rows (the n, o, and a vectors) make up the three principal axes (i, j, and k)of the coordinate space that the matrix represents. I am going to use this to make a matrix that represents a transformation of an object looking a particular direction. This is useful in many cases and is most often used in controlling the camera. Usually, there is a place where the camera is and a place you want the camera to focus on. You can accomplish this using an inverted LookAt matrix (you need to invert it because the camera transformation brings points from world space to view space, not the other way around, like object matrices). There is one restriction the LookAt matrix has. It always assumes that there is a constant up vector, and the camera orients itself to that, so there is no tilt. For the code to work, the camera cannot be looking in the same direction that the up vector points. This is because a cross product is performed with the view vector and the up vector, and if they're the same thing the behavior of the cross product is undefined. In games like Quake III: Arena, you can look almost straight up, but there is some infinitesimally small epsilon that prevents you from looking in the exact direction. Three vectors are passed into the function: a location for the matrix to be, a target to look at, and the up vector (the third parameter will default to j so you don't need to always enter it). The transformation vector for the matrix is simply the location. The a vector is the normalized vector representing the target minus the location (or a vector that is the direction you want the object to look in). To find the n vector, simply take the normalized cross product of the up vector and the direction vector. (This is why they can't be the same vector; the cross product would return garbage.) Finally, you can get the o vector by taking the cross product of the n and a vectors already found. I'll show you two versions of this transformation, one to compute the matrix for an object to world transformation, and one that computes the inverse automatically. Use ObjectLookAt to make object matrices that look in certain directions, and CameraLookAt to make cameras that look in certain directions. Listing 5.28: LookAt matrix generation code
void matrix4::ToObjectLookAt( const point3& loc, const point3& lookAt, const point3& inUp ) {
227
point3 viewVec = lookAt - loc; float mag = viewVec.Mag(); viewVec /= mag;
float fDot = inUp * viewVec; point3 upVec = inUp - fDot * viewVec; upVec.Normalize();
point3 rightVec = upVec ^ viewVec; // The first three rows contain the basis // vectors used to rotate the view to point // at the lookat point _11 = rightVec.x; _21 = upVec.x; _31 = viewVec.x; _12 = rightVec.y; _22 = upVec.y; _32 = viewVec.y; _13 = rightVec.z; _23 = upVec.z; _33 = viewVec.z;
// Do the translation values _41 = loc.x; _42 = loc.y; _43 = loc.z;
_14 = 0; _24 = 0; _34 = 0; _44 = 1; }
matrix4 matrix4::ObjectLookAt( const point3& loc, const point3& lookAt, const point3& inUp ) {
228
matrix4 out; out.ToObjectLookAt( loc, lookAt, inUp ); return out; }
//==========--------------------------
void matrix4::ToCameraLookAt( const point3& loc, const point3& lookAt, const point3& inUp ) { point3 viewVec = lookAt - loc; float mag = viewVec.Mag(); viewVec /= mag;
float fDot = inUp * viewVec; point3 upVec = inUp - fDot * viewVec; upVec.Normalize();
point3 rightVec = upVec ^ viewVec;
// The first three columns contain the basis // vectors used to rotate the view to point // at the lookat point _11 = rightVec.x;
_12 = upVec.x;
_13 = viewVec.x;
_21 = rightVec.y;
_22 = upVec.y;
_23 = viewVec.y;
_31 = rightVec.z;
_32 = upVec.z;
_33 = viewVec.z;
// Do the translation values _41 = - (loc * rightVec); _42 = - (loc * upVec);
229
_43 = - (loc * viewVec);
_14 = 0; _24 = 0; _34 = 0; _44 = 1; }
matrix4 matrix4::CameraLookAt( const point3& loc, const point3& lookAt, const point3& inUp ) { matrix4 out; out.ToCameraLookAt( loc, lookAt, inUp ); return out; }
Perspective Projection Matrix Creating a perspective projection matrix will be handled by the graphics layer when I add Direct3D to it in Chapter 8, using the matrix discussed earlier in the chapter.
Inverse of a Matrix Again, the inverse of a matrix composed solely of translations, rotations, and reflections (scales such as that flip sign but don't change the length) can be computed easily. The inverse matrix looks like this:
Code to perform inversion appears in Listing 5.29.
230
Listing 5.29: Matrix inversion code
void matrix4::ToInverse( const matrix4& in ) {
// first transpose the rotation matrix _11 = in._11; _12 = in._21; _13 = in._31; _21 = in._12; _22 = in._22; _23 = in._32; _31 = in._13; _32 = in._23; _33 = in._33;
// fix right column _14 = 0; _24 = 0; _34 = 0; _44 = 1;
// now get the new translation vector point3 temp = in.GetLoc();
_41 = -(temp.x * in._11 + temp.y * in._12 + temp.z * in._13); _42 = -(temp.x * in._21 + temp.y * in._22 + temp.z * in._23); _43 = -(temp.x * in._31 + temp.y * in._32 + temp.z * in._33); }
matrix4 matrix4::Inverse( const matrix4& in ) {
231
matrix4 out; out.ToInverse( in ); return out; }
Collision Detection with Bounding Spheres Up until now, when I talked about moving 3D objects around, I did so completely oblivious to wherever they may be moving. But suppose there is a sphere slowly moving through the scene. During its journey it collides into another object (for the sake of simplicity, say another sphere). You generally want the reaction that results from the collision to be at least partially similar to what happens in the real world. In the real world, depending on the mass of the spheres, the amount of force they absorb, the air resistance in the scene, and a slew of other factors, they will physically react to each other the moment they collide. If they were rubber balls, they may bounce off of each other. If the spheres were instead made of crazy glue, they would not bounce at all, but would become inextricably attached to each other. Physics simulation aside, you most certainly do not want to allow any object to blindly fly through another object (unless, of course, that is the effect you're trying to achieve, such as an apparition object like the ghosts in Super Mario Brothers games). There are a million and one ways to handle collisions and the method you use will be very implementation dependent. So for now, all I'm going to discuss here is just getting a rough idea of when a collision has occurred. Most of the time, games only have the horsepower to do very quick and dirty collision detection. Games generally use bounding boxes or bounding spheres to accomplish this; I'm going to talk about bounding spheres. They try to simplify complex graphics tasks like occlusion and collision detection. The general idea is that instead of performing tests against possibly thousands of polygons in an object, you can simply hold on to a sphere that approximates the object, and just test against that. Testing a plane or point against a bounding sphere is a simple process, requiring only a subtraction and a vector comparison. When the results you need are approximate, using bounding objects can speed things up nicely. This gives up the ability to get exact results. Fire up just about any game and try to just miss an object with a shot. Chances are (if you're not playing something with great collision detection like MDK, Goldeneye, or House of the Dead) you'll hit your target anyway. Most of the time you don't even notice, so giving up exact results isn't a tremendous loss. Even if you do need exact results, you can still use bounding objects. They allow you to perform trivial rejection. An example is in collision detection. Typically, to calculate collision detection exactly is an expensive process (it can be as bad as O(mn), where m and n are the number of polygons in each
232
object). If you have multiple objects in the scene, you need to perform collision tests between all of them, a total of O(n2) operations where n is the number of objects. This is prohibitive with a large amount of complex objects. Bounding object tests are much more manageable, typically being O(1) per test. To implement bounding spheres, I'll create a structure called bSphere3. It can be constructed from a location and a list of points (the location of the object, the object's points) or from an explicit location and radius check. Checking if two spheres intersect is a matter of calling bSphere3::Intersect with both spheres. It returns true if they intersect each other. This is only a baby step that can be taken towards good physics, mind you, but baby steps beat doing nothing! Listing 5.30: Bounding sphere structure
struct bSphere3 { float m_radius; point3 m_loc;
bSphere3(){}
bSphere3( float radius, point3 loc ) : m_radius( radius ), m_loc( loc ) { }
bSphere3( point3 loc, int nVerts, point3* pList ) { m_loc = loc; m_radius = 0.f; float currRad; for( int i=0; i< nVerts; i++ ) { currRad = pList[i].Mag(); if( currRad > m_radius ) {
233
m_radius = currRad; } } }
template< class iter > bSphere3( point3 loc, iter& begin, iter& end ) { iter i = begin; m_loc = loc; m_radius = 0.f; float currRad; while( i != end ) { currRad = (*i).Mag(); if( currRad > m_radius ) { m_radius = currRad; } i++; } }
static bool Intersect( bSphere3& a, bSphere3& b ) { // avoid a square root by squaring both sides of the equation float magSqrd = (a.m_radius + b.m_radius) * (a.m_radius + b.m_radius); if( (b.m_loc - a.m_loc).MagSquared() > magSqrd ) { return false; }
234
return true; } };
Some additional operators are defined in bSphere3.h, and plane-sphere classification code is in plane3.h as well. See the downloadable files for more detail.
Lighting Lighting your scenes is essentially a prerequisite if you want them to look realistic. Lighting is a fairly slow and complex system, especially when modeling light correctly (this doesn't happen too often). Later in the book I'll discuss some advanced lighting schemes, specifically radiosity. Advanced lighting models typically are done as a preprocessing step, as they can take several hours or even days for complex scenes. For real-time graphics you need simpler lighting models that approximate correct lighting. I'll discuss two points in this section: how to acquire the amount of light hitting a point in 3D and how to shade a triangle with those three points.
Representing Color Before you can go about giving color to anything in a scene, you need to know how to represent color! Usually you use the same red, green, and blue channels discussed in Chapter 2, but for this there will also be a fourth component called alpha. The alpha component stores transparency information about a surface. It's discussed more in detail in Chapter 10, but for right now let's plan ahead. There will be two structures to ease the color duties: color3 and color4. They both use floating-point values for their components; color3 has red, green, and blue, while color4 has the additional fourth component of alpha in there. Colors aren't like points—they have a fixed range. Each component can be anywhere between 0.0 and 1.0 (zero contribution of the channel or complete contribution). If performing operations on colors, such as adding them together, the components may rise above 1.0 or below 0.0. Before trying to use a color, for example feeding it to Direct3D, it needs to be saturated. That is what the Sat() function does. The conversions to unsigned longs will be used in Chapter 8, when the colors start to get plugged into Direct3D. The code for color4 appears in Listing 5.31. I've left out a few routine bits of code to keep the listing focused. Listing 5.31: The color4 structure
struct color4
235
{ union { struct { float r, g, b, a; // Red, Green, and Blue color data }; float c[4]; };
color4(){}
color4( float inR, float inG, float inB, float inA ) : r( inR ), g( inG ), b( inB ), a( inA ) { }
color4( const color3& in, float alpha = 1.f ) { r = in.r; g = in.g; b = in.b; a = alpha; }
color4( unsigned long color ) { b = (float)(color&255) / 255.f; color >>= 8; g = (float)(color&255) / 255.f; color >>= 8; r = (float)(color&255) / 255.f; color >>= 8;
236
a = (float)(color&255) / 255.f; }
void Assign( float inR, float inG, float inB, float inA ) { r = inR; g = inG; b = inB; a = inA; }
unsigned long MakeDWord() { unsigned long iA = (int)(a * 255.f ) 1 ) g = 1.f; if( b > 1 ) b = 1.f; if( a > 1 ) a = 1.f; if( r < 0.f ) r = 0.f; if( g < 0.f ) g = 0.f; if( b < 0.f ) b = 0.f; if( a < 0.f ) a = 0.f; }
color4& operator += ( const color4& in ); color4& operator -= ( const color4& in ); color4& operator *= ( const color4& in ); color4& operator /= ( const color4& in ); color4& operator *= ( const float& in ); color4& operator /= ( const float& in ); // some basic colors. static const color4 Black; static const color4 Gray; static const color4 White; static const color4 Red; static const color4 Green; static const color4 Blue; static const color4 Magenta; static const color4 Cyan; static const color4 Yellow;
238
};
Lighting Models Lighting an object correctly is an extremely difficult process. Even today, it's still an area of research in academia. There are applications on the market that cost tens of thousands of dollars to perform renderings of scenes that have extremely accurate lighting. These renderings can take inordinate amounts of time to compute, sometimes on the order of several hours or even days for extremely complex images. Think of some of the computer-generated imagery in movies like Final Fantasy, Shrek, and Ice Age. Never one to do difficult things, Direct3D and OpenGL graphics programmers use approximations of correct lighting models to get fast but good looking lighting models. While the images invariably end up looking computer generated, they can be done in real time. True photo realism needs to have incredibly accurate lighting, as human eyes are very sensitive to lighting in a scene. All the kinds of light are cubby-holed into four essential types: Ambient light—Ambient light can be thought of as the average light in a scene. It is light that is equally transmitted to all points on all surfaces the same amount. Ambient lighting is a horrible hack—an attempt to impersonate the diffuse reflection that is better approximated by radiosity (covered in Chapter 9), but it works well enough for many applications. The difference between ambient light and ambient reflection is that ambient reflection is how much a surface reflects ambient light. Diffuse light—Diffuse light is light that hits a surface and reflects off equally in all directions. Surfaces that only reflect diffuse light appear lit the same amount, no matter how the camera views it. If modeling chalk or velvet, for example, only diffuse light would be reflected. Specular light—Specular light is light that only reflects off a surface in a particular direction. This causes a shiny spot on the surface, which is called a specular highlight. The highlight is dependent on both the location of the light and the location of the viewer. For example, imagine picking up an apple. The shiny spot on the apple is a good example of a specular highlight. As you move your head, the highlight moves around the surface (which is an indication that it's dependent on the viewing angle). Emissive light—Emissive light is energy that actually comes off of a surface. A light bulb, for example, looks very bright, because it has emissive light. Emissive light does not contribute to other objects in the scene. It is not a light itself; it just modifies the appearance of the surface. Ambient and diffuse lights have easier equations, so I'll give those first. If the model doesn't reflect specular light at all, you can use the following equation to light each vertex of the object. This is the
239
same diffuse and ambient lighting equation that Direct3D uses (given in the Microsoft DirectX 9.0 SDK documentation). The equation sums all of the lights in the scene.
Table 5.1: Terms in the ambient/diffuse/emissive lighting equation for a surface Dv
Final color for the surface.
Ia
Ambient light for the entire scene.
Sa
Ambient color for the surface.
Se
Emitted color of the surface.
Ai
Attenuation for light i. This value depends on the kind of light you have, but essentially means how much of the total energy from the light hits an object.
Rdi
Diffuse reflection factor for light i. This is usually the inverse of the dot product between the vertex normal and the direction in which the light is coming. That way, normals that are facing directly to the light receive more than normals that are turned away from it (of course, if the reflectance factor is less than zero, no diffuse light hits the object). Figure 5.25 shows the calculation visually.
Sd
Diffuse color for the surface.
Ldi
Diffuse light emitted by light i.
Lai
Ambient light emitted by light i.
240
Figure 5.25: Computation of the diffuse reflection factor The surfaces in the following equation will end up being vertices of the 3D models once D3D is up and running. The surface reflectance components are usually defined with material structures defined in Chapter 8.
Specular Reflection Specular reflections are more complex than ambient, emissive, or diffuse reflections, requiring more computation to use. Many old applications don't use specular reflections because of the overhead involved, or they'll do something like approximate them with an environment map. However, as accelerators are getting faster (especially since newer accelerators, such as the GeForce 4, can perform lighting in hardware) specular lighting is increasingly being used to add more realism to scenes. To find the amount of specular color to attribute to a given vector with a given light, you use the following equations (taken from the Microsoft DirectX 9.0 SDK documentation):
The meanings of the variables are given in Table 5.2.
Table 5.2: Meanings of the specular reflection variables pc
Location of the camera.
241
pv
Location of the surface.
ld
Direction of the light.
h
The "halfway" vector. Think of this as the vector bisecting the angle made by the light direction and the viewer direction. The closer this is to the normal, the brighter the surface should be. The normal-halfway angle relation is handled by the dot product.
n
The normal of the surface.
Rs
Specular reflectance. This is, in essence, the intensity of the specular reflection. When the point you're computing lies directly on a highlight, it will be 1.0; when it isn't in a highlight at all, it'll be 0.
p
The "power" of the surface. The higher this number, the sharper the specular highlight. A value of 1 doesn't look much different from diffuse lighting, but using a value of 15 or 20 gives a nice sharp highlight.
Ss
The color being computed (this is what you want).
Cs
Specular color of the surface. That is, if white specular light were hitting the surface, this is the specular color you would see.
A
Attenuation of the light (how much of the total energy leaving the light actually hits the surface).
Ls
Specular color of the light.
242
Figure 5.26: Parallel light sources Note that this only solves for one light; you need to solve the same equation for each light, summing up the results as you go.
Light Types Now that you have a way to find the light hitting a surface, you're going to need some lights! There are three types of lights I am going to discuss, which happen to be the same three light types supported by Direct3D.
Parallel Lights (or Directional Lights) Parallel lights cheat a little bit. They represent light that comes from an infinitely far away light source. Because of this, all of the light rays that reach the object are parallel (hence the name). The standard use of parallel lights is to simulate the sun. While it's not infinitely far away, 93 million miles is good enough! The great thing about parallel lights is that a lot of the ugly math goes away. The attenuation factor is always 1 (for point/spotlights, it generally involves divisions if not square roots). The incoming light vector for calculation of the diffuse reflection factor is the same for all considered points, whereas point lights and spotlights involve vector subtractions and a normalization per vertex. Typically, lighting is the kind of effect that is sacrificed for processing speed. Parallel light sources are the easiest and therefore fastest to process. If you can't afford to do the nicer point lights or spotlights, falling back to parallel lights can keep your frame rates at reasonable levels.
Point Lights One step better than directional lights are point lights. They represent infinitesimally small points that emit light. Light scatters out equally in all directions. Depending on how much effort you're willing to
243
expend on the light, you can have the intensity falloff based on the inverse squared distance from the light, which is how real lights work.
The light direction is different for each surface location (otherwise the point light would look just like a directional light). The equation for it is:
Figure 5.27: Point light sources
Spotlights Spotlights are the most expensive type of light I discuss in this book and should be avoided if possible. They model a spotlight not unlike the type you would see in a theatrical production. They are point lights, but light only leaves the point in a particular direction, spreading out based on the aperture of the light. Spotlights have two angles associated with them. One is the internal cone whose angle is generally referred to as theta (θ). Points within the internal cone receive all of the light of the spotlight; the attenuation is the same as it would be if point lights were used. There is also an angle that defines the outer cone; the angle is referred to as phi (ϕ). Points outside the outer cone receive no light. Points outside the inner cone but inside the outer cone receive light, usually a linear falloff based on how close it is to the inner cone.
244
Figure 5.28: A spotlight If you think all of this sounds mathematically expensive, you're right. Direct3D implements lighting for you, so you won't need to worry about the math behind spotlights, but rest assured that they're extremely expensive and can slow down your application a great deal. Then again, they do provide an incredible amount of atmosphere when used correctly, so you will have to figure out a line between performance and aesthetics.
Shading Models Once you've found lighting information, you need to know how to draw the triangles with the supplied information. There are currently three ways to do this; the third has just become a hardware feature with DirectX 9.0. Here is a polygon mesh of a sphere, which I'll use to explain the shading models:
Figure 5.29: Wireframe view of our polygon mesh
Lambert
245
Triangles that use Lambertian shading are painted with one solid color instead of using a gradient. Typically each triangle is lit using that triangle's normal. The resulting object looks very angular and sharp. Lambertian shading was used mostly back when computers weren't fast enough to do Gouraud shading in real time. To light a triangle, you compute the lighting equations using the triangle's normal and any of the three vertices of the triangle.
Figure 5.30: Flat shaded view of our polygon mesh
Gouraud Gouraud (pronounced garrow) shading is the current de facto shading standard in accelerated 3D hardware. Instead of specifying one color to use for the entire triangle, each vertex has its own separate color. The color values are linearly interpolated across the triangle, creating a smooth transition between the vertex color values. To calculate the lighting for a vertex, you use the position of the vertex and a vertex normal. Of course, it's a little hard to correctly define a normal for a vertex. What people do instead is average the normals of all the polygons that share a certain vertex, using that as the vertex normal. When the object is drawn, the lighting color is found for each vertex (rather than each polygon), and then the colors are linearly interpolated across the object. This creates a slick and smooth look, like the one in Figure 5.31.
246
Figure 5.31: Gouraud shaded view of our polygon mesh One problem with Gouraud shading is that the triangles' intensities can never be greater than the intensities at the edges. So if there is a spotlight shining directly into the center of a large triangle, Gouraud shading will interpolate the intensities at the three dark corners, resulting in an incorrectly dark triangle. Aside
The internal highlighting problem usually isn't that bad. If there are enough triangles in the model, the interpolation done by Gouraud shading is usually good enough. If you really want internal highlights but only have Gouraud shading, you can subdivide the triangle into smaller pieces.
Phong Phong shading is the most realistic shading model I'm going to talk about, and also the most computationally expensive. It tries to solve several problems that arise when you use Gouraud shading. If you're looking for something more realistic, Foley discusses nicer shading models like TarrenceSparrow, but they aren't real time (at least not right now). First of all, Gouraud shading uses a linear gradient. Many objects in real life have sharp highlights, such as the shiny spot on an apple. This is difficult to handle with pure Gouraud shading. The way Phong does this is by interpolating the normal across the triangle face, not the color value, and the lighting equation is solved individually for each pixel.
247
Figure 5.32: Phong shaded view of a polygon mesh Phong shading isn't techically supported in hardware. But you can now program your own Phong rendering engine, and many other special effects, using shaders, a hot new technology that I will discuss later in the book.
BSP Trees If all you want to do is just draw lists of polygons and be done with it, then you now have enough knowledge at your disposal to do that. However, there is a lot more to 3D game programming that you must concern yourself with. Hard problems abound, and finding an elegant way to solve the problems is half the challenge of graphics programming (actually implementing the solution is the other half). A lot of the hard graphics problems, such as precise collision detection or ray-object intersection, boil down to a question of spatial relationship. You need to know where objects (defined with a boundary representation of polygons) exist in relation to the other objects around them. You can, of course, find this explicitly if you'd like, but this leads to a lot of complex and slow algorithms. For example, say you're trying to see if a ray going through space is hitting any of a list of polygons. The slow way to do it would be to explicitly test each and every polygon against the ray. Polygon-ray intersection is not a trivial operation, so if there are a few thousand polygons, the speed of the algorithm can quickly grind to a halt. A spatial relationship of polygons can help a lot. If you were able to say, "The ray didn't hit this polygon, but the entire ray is completely in front of the plane the polygon lies in," then you wouldn't need to test anything that sat behind the first polygon. BSP trees, as you shall soon see, are one of the most useful ways to partition space. Aside
I implemented a ray-tracer a while back using two algorithms. One was a brute-force, test-every-polygon-against-every-ray nightmare; the other used BSP trees. The first algorithm took about 90 minutes to render a single frame with about 15K triangles in it. With BSP trees, the rendering time went down to about 45 seconds. Saying BSP trees make a big difference is a major understatement.
248
It all started when Henry Fuchs and Zvi Kedem, both professors at the University of Texas at Dallas, found a bright young recent grad working at Texas Instruments named Bruce Naylor. They talked him into becoming a graduate student in their graphics department, and he started doing work on computational geometry. Fuchs was a sort of bright, energetic type, and Kedem contained that spark that few other theoretical computer scientists have: He was able to take theory and apply it to practical problems. Out of this triumvirate came two SIGGRAPH papers, and Naylor's Ph.D. thesis, which gave birth to BSP trees.
BSP Tree Theory BSP trees are a specialization of binary trees, one of the most basic constructs of computer science. A BSP tree represents a region of space (the tree can have any number of nodes, including just one). The tree is made up of nodes (having exactly two children) and leaves (having exactly zero children). A node represents a partitioning of the space that the tree it is a part of represents. The partitioning creates two new spaces, one in front of the node and one in back of the node. In 2D applications, such as Doom (which used BSP trees to represent the worlds the fearless space marine navigated), the top-level tree represents the entire 2D world. The root node, which contains in it a line equation, defines a partitioning of the world into two pieces, one in front of the line and one in back of it. Each of these pieces is represented by a subtree, itself a BSP tree. The node also contained a line segment that was part of the line equation used in the partitioning. The line segment, with other information like the height and texture ID, became a wall in the world. Subtrees are leaves if and only if the space that they represent has no other walls in it. If it did, the wall would be used to partition the space yet again. In 3D applications, things are pretty much the same. The space is partitioned with 3D planes, which contain polygons within them. The plane at each node slices its region into two hunks, one that is further subdivided by its front child node, and the other further subdivided by its back child node. The recursion downward stops when a space cannot be partitioned any further. For now, this happens when there are no polygons inside of it. At this point, a leaf is created, and it represents a uniform, convex region of space. There are two primary ways to do BSP trees. In the first method (called node-based BSP trees), nodes contain both polygons and the planes used to partition. Leaves are empty. In the other method (called leaf-based or leafy BSP trees), nodes only contain planes. Leaves contain all of the polygons that form the boundary of that convex space. I'm only going to talk about node-based BSP trees, but leaf-based BSPs are useful, for example in computing the potentially visible set (PVS) of a scene. BSP trees are most useful when the set of polygons used to construct the tree represents the boundaryrepresentation of an object. The object has a conceptual inside made of solid matter, an outside of empty space surrounding it, and polygons that meet in the middle. Luckily this is how I am representing
249
the objects anyway. When the tree is complete, each leaf represents either solid or empty space. This will prove to be extremely useful, as you shall see in a moment.
BSP Tree Construction The algorithm to create a node-based BSP tree is simple and recursive. It is fairly time consuming, however, enough so that generally the set of polygons used to construct the BSP tree remains static. This is the case for most of the worlds that players navigate in 3D games, so games such as Quake III: Arena consist of a static BSP tree (representing a world) and a set of objects (health boxes, ammo boxes, players, enemies, doors, etc.) that can move around in the world. I'll go through the tree construction process step by step. Pseudocode for the algorithm appears in Listing 5.32. Listing 5.32: Pseudocode for BSP construction
struct node polygon poly plane
part_plane
ptr
front
ptr
back
vector< polygon > coplanar_polygons
struct leaf bool solid
leaf Make_Leaf( bool solid ) leaf out = new leaf out.solid = solid return out polygon Get_Splitting_Polygon( vector< polygon > input_list ) polygon out = polygon that satisfies some hueristic remove out from input_list return out node Make_Node( vector< polygon > input_list ) vector< polygon > front_list, back_list
250
node out = new node chosen_polygon = Get_Splitting_Polygon( input_list ) out.part_plane = Make_Plane_From_Polygon( chosen_polygon ) out.poly = chosen_polygon for( each polygon curr in input_list ) switch( out.part_plane.Classify_Polygon( curr ) ) case front add curr to front_list case back add curr to back_list case coplanar add curr to node.coplanar_polygons case split split curr into front and back polygons add front to front_list add back to back_list if( front_list is empty ) out.front = Make_Leaf( false ) else out.front = Make_Node( front_list ) if( back_list is empty ) out.back = Make_Leaf( true ) else out.back = Make_Node( back_list ) return out
node Make_BSP_Tree( vector< polygon > input_list ) return Make_Node( input_list )
Let's step through a sample 2D tree to show what is going on. The initial case will be a relatively small data set with four edges defining a closed region surrounded by empty space. Figure 5.33 shows the
251
initial case, with the polygons on the left and a list on the right that will be processed. Each of the segments also has its plane normal visible; note that they all point out of the solid region.
Figure 5.33: Initial case of the BSP construction To create the root node, segment A is used. Segments B, C, and D are all behind segment A, so they all go in the back list. The front list is empty, so the front child is made a leaf representing empty space corresponding to the entire subspace in front of segment A. The back list isn't empty, so it must be recursed, processing the subspace behind segment A. The result of the first partition appears in Figure 5.34.
Figure 5.34: Result after the first partitioning Once recursion into the root node's back child is complete, a polygon to partition with must once again be selected. While real-world applications probably wouldn't choose it, to diversify the example I'm going to use segment B. Segment C is completely in front, but segment D is partially in front and
252
partially in back. It is split into two pieces, one completely in front (which I'll call DF) and one completely in back (called DB). After the classification, both the front list and the back list have polygons in them, so they must be recursed with each. Figure 5.35 shows the progress up to this point.
Figure 5.35: Result after the second partitioning Note
Notice the dashed line for segment B. It doesn't intrude into the space in front of segment A, because it is only partitioning the subspace behind A. This is a very important point you'll need to assimilate if you want to understand BSP trees fully.
I'll partition the front side of the node, the one with a list of DF and C. I'll use DF as the partitioning polygon. C is the only polygon to classify, and it's completely behind DF. The front list is empty, so I create an empty space leaf. This brings the progress up to Figure 5.36.
Figure 5.36: Result of the third partitioning
253
Now there are two nodes left to process, C and DB. I'll consolidate them into one step. They both have no other polygons to classify once the only polygon in each list is selected to be the partitioner. This creates two child leaf nodes, one in back of the polygon representing solid space (represented with a plus sign) and one in front representing empty space (represented with a minus sign). This results in the final BSP tree, which appears in Figure 5.27. I put small dashed lines from each of the leaf nodes to the subspace they represent.
Figure 5.37: The final BSP tree One piece that's left out of the equation is how you take the list of polygons during each step and choose the polygon to use as the partitioner. There are two heuristics you can try to satisfy: Choose the polygon that causes the least amount of splits, or choose the polygon that most evenly divides the set. One problem, however, is that you can have a ton of polygons in the data set, especially at the top levels of the tree. In Foley's Computer Graphics it mentions that after you check about 10% of the polygons, the best candidate found thus far is so similar to the ideal one that it's not worth checking any more. This code will use a strict least-split heuristic, checking the first 10% of the polygon data (or the whole set if it's below some threshold).
BSP Tree Algorithms Now that you've covered enough ground to create a BSP tree, hopefully a few algorithms will be at your disposal to perform operations on them. A few of the algorithms work in all polygon configurations, but generally they're suited for BSP trees that represent the boundary representation of an object.
Sorted Polygon Ordering One of the first uses of BSP trees was to get a list of polygons sorted by distance from a given viewpoint. This was used back before hardware z-buffers, when polygons needed to be drawn in backto-front order to be rendered correctly. It's still useful, however; z-buffer rendering goes faster if you
254
reject early (so rendering front-to-back can be an advantage), and alpha-blended polygons need to be rendered back-to-front to be rendered correctly. The fundamental concept behind the algorithm is that if you have a certain plane in the scene dividing it into two pieces, and you are on one side of the plane, then nothing behind the plane can occlude anything in front of the plane. Armed with this rule, all you need to do is traverse the tree. At each node, you check to see which side the camera is on. If it's in front, then you add all the polygons behind the plane (by traversing into the back node), then all the polygons in the plane (the partitioning polygon and any coplanar polygons), and finally the polygons in front of the plane (by traversing into the front node). The opposite applies if it is in back. Leaves just return automatically. Note
If you don't want to draw polygons facing away, you can automatically discard the node polygon if the camera point is behind the node plane. The coplanar polygons you can check, unless you keep two lists of coplanar polygons—one facing in the same direction as the partitioning polygons and one facing the opposite way.
The algorithm to do this is fairly simple and recursive. Pseudocode for it appears in Listing 5.33. Listing 5.33: Pseudocode to sort a polygon list based on distance
void node::GetSortedPolyList( list< polygon3 >* pList, point& camera ) { switch( node.part_plane.Classify_Point( camera ) ) { case front back. GetSortedPolyList( pList, camera ); add all node polygons to pList front. GetSortedPolyList( pList, camera ); case back front. GetSortedPolyList( pList, camera ); add all node polygons to pList back. GetSortedPolyList( pList, camera ); case coplanar // order doesn't matter front. GetSortedPolyList( pList, camera );
255
back. GetSortedPolyList( pList, camera ); } } void leaf:: GetSortedPolyList( list< polygon3 >* pList, point& camera ) { return; }
Testing Locality of a Point A really great use of BSP trees is testing the locality of points. Given a point and a tree, you can tell whether the point is sitting in a solid leaf or not. This is useful for collision detection, among other things. The algorithm to do it is amazingly simple. At each branch of the tree, you test the point against the plane. If it's in front, you drop it down the front branch; if it's in back, you drop it down the back branch. If the point is coplanar with the polygon, you can pick either one. Whenever you land in a leaf, you have found the region of space that the point is sitting in. If the leaf is tagged as being solid, then the point is sitting in solid space; otherwise it's not. Pseudocode for this algorithm appears in Listing 5.34. Listing 5.34: Pseudocode to define the locality of a point
bool node::TestPoint( point& pt ) { switch( node.part_plane.Classify_Point( pt ) ) { case front return front.TestPoint( pt ); case back return back.TestPoint( pt ); case coplanar // Let's drop down the back tree
256
return back.TestPoint( pt ); } } bool leaf::TestPoint( point& pt ) { if( solid ) return true; return false; }
Testing Line Segments While there are many other algorithms for use with BSP trees, the last one I'll discuss lets you test a line segment against a tree. The algorithm returns true if there is a clear line of sight between both endpoints of the line, and false otherwise. Another way to think of it is to say that the algorithm returns true if and only if the line segment only sits in non-solid leaves. Like all the other algorithms I've discussed, this is a conceptually simple and elegant algorithm. Starting at the root, you compare the line segment to the plane at a node. If the line segment is completely in front, you drop it down the front side. If it's completely in back, you drop it down the back side. If the line segment is on both sides of the plane, you divide it into two pieces (one in front of the plane and one in back) and recurse with both of them. If any piece of segment ever lands in a solid cell, then you know there is no line of sight, and you return false. Source code to do this appears in the following BSP tree source code.
BSP Tree Code Listings 5.35 and 5.36 have the header and source code for the BSP class. I'll be using it in Chapter 9 to find the form factor in the radiosity simulator. The main difference between this code and the pseudocode given above is this code uses the same node structure to represent both nodes and leaves. This made the code simpler but is an inefficient use of space (leaves only need a single word defining them as solid; here a lot more than that is used). Listing 5.35: BspTree.h
257
/******************************************************************* *
Advanced 3D Game Programming using DirectX 9.0
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
Desc: Sample application for Direct3D
* * copyright (c) 2002 by Peter A Walsh and Adrian Perez * See license.txt for modification and distribution information ******************************************************************/
#ifndef _BSPTREE_H #define _BSPTREE_H
#include <point3.h> #include <polygon.h> #include
#include using std::vector;
const float percentageToCheck = .1f; // 10%
/** * This code expects the set of polygons we're giving it to be * closed, forming a continuous skin. If it's not, weird things * may happen. */ class cBspTree { public:
// construction/destruction cBspTree();
258
~cBspTree();
// we need to handle copying cBspTree( const cBspTree &in ); cBspTree& operator=( const cBspTree &in );
// add a polygon to the tree void AddPolygon( const polygon<point3>& in ); void AddPolygonList( vector< polygon<point3> >& in );
void TraverseTree( vector< polygon<point3>* >* polyList, const point3& loc );
bool LineOfSight( const point3& a, const point3& b );
protected:
private:
class cNode {
cNode*
m_pFront;
// pointer to front subtree
cNode*
m_pBack;
// pointer to back subtree
polygon<point3> m_poly; plane3
m_plane;
bool
m_bIsLeaf;
bool
m_bIsSolid;
vector< polygon<point3> > m_coplanarList;
259
static int BestIndex( vector< polygon<point3> >& polyList );
public: cNode( bool bIsSolid );
// leaf constructor
cNode( const polygon<point3>& in ); cNode( vector< polygon<point3> >& in );
// node constructor // node constructor
~cNode();
// we need to handle copying cNode( const cNode &in ); cNode& operator=( const cNode &in );
void AddPolygon( const polygon<point3>& in );
void TraverseTree( vector< polygon<point3>* >* polyList, const point3& loc );
bool IsLeaf() { return m_bIsLeaf; }
bool LineOfSight( const point3& a, const point3& b ); };
cNode* m_pHead; // root node of the tree
};
inline cBspTree::cBspTree( const cBspTree &in )
260
{ // clone the tree if( in.m_pHead ) m_pHead = new cNode( *in.m_pHead ); else m_pHead = NULL; }
inline cBspTree& cBspTree::operator=( const cBspTree &in ) { if( &in != this ) { // delete the tree if we have one already if( m_pHead ) delete m_pHead; // clone the tree if( in.m_pHead ) m_pHead = new cNode( *in.m_pHead ); else m_pHead = NULL; } return *this; }
inline cBspTree::cNode::cNode( const cNode &in ) { m_poly = in.m_poly; m_plane = in.m_plane; m_bIsLeaf = in.m_bIsLeaf; m_bIsSolid = in.m_bIsSolid;
// clone the trees
261
m_pFront = NULL; if( in.m_pFront ) m_pFront = new cNode( *in.m_pFront );
m_pBack = NULL; if( in.m_pBack ) m_pBack = new cNode( *in.m_pBack ); } inline cBspTree::cNode& cBspTree::cNode::operator=( const cNode &in ) { if( &in != this ) { // delete the subtrees if we have them already if( m_pFront ) delete m_pFront; if( m_pBack ) delete m_pBack;
// copy all the data over m_poly = in.m_poly; m_plane = in.m_plane; m_bIsLeaf = in.m_bIsLeaf; m_bIsSolid = in.m_bIsSolid;
// clone the trees m_pFront = NULL; if( in.m_pFront ) m_pFront = new cNode( *in.m_pFront );
m_pBack = NULL; if( in.m_pBack ) m_pBack = new cNode( *in.m_pBack );
262
} return *this; }
#endif //_BSPTREE_H
Listing 5.36: BspTree.cpp
/******************************************************************* *
Advanced 3D Game Programming using DirectX 9.0
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
Desc: Sampe application for Direct3D
* * copyright (c) 2002 by Peter A Walsh and Adrian Perez * See license.txt for modification and distribution information ******************************************************************/
#include #include
cBspTree::cBspTree() { }
cBspTree::~cBspTree() { // destroy the tree } void cBspTree::AddPolygon( const polygon<point3>& in ) { if( !m_pHead )
263
{ // if there's no tree, make a new one m_pHead = new cNode( in ); } else { // otherwise add it to the tree m_pHead->AddPolygon( in ); } }
void cBspTree::AddPolygonList( vector< polygon<point3> >& in ) { if( !m_pHead ) { // if there's no tree, make a new one m_pHead = new cNode( in ); } else { /** * Adding a list of polygons to * an existing tree is unimplemented * (exercise to the reader) */ assert( false ); } }
void cBspTree::TraverseTree( vector<polygon<point3>*>* polyList, const point3& loc )
264
{ if( m_pHead ) { // drop it down m_pHead->TraverseTree( polyList, loc ); } }
bool cBspTree::LineOfSight( const point3& a, const point3& b ) { assert( m_pHead ); // make sure there is a tree to test against
return m_pHead->LineOfSight( a, b ); } cBspTree::cNode::~cNode() { delete m_pFront; delete m_pBack; }
cBspTree::cNode::cNode( bool bIsSolid ) : m_bIsLeaf( true ) , m_bIsSolid( bIsSolid ) , m_pFront( NULL ) , m_pBack( NULL ) { // all done. }
cBspTree::cNode::cNode( const polygon<point3>& in ) : m_bIsLeaf( false ) , m_poly( in )
265
, m_plane( in ) , m_pFront( new cNode( false ) ) , m_pBack( new cNode( true ) ) { // all done. }
cBspTree::cNode::cNode( vector< polygon<point3> >& in ) : m_bIsLeaf( false ) { // if the list is empty, we're bombing out. assert( in.size() );
// get the best index to use as a splitting plane int bestIndex = BestIndex( in );
// we could remove the index from the vector, but that's slow. // instead we'll just kind of ignore it during the next phase. // remove the best index polygon<point3> splitPoly = in[bestIndex];
m_plane = plane3( splitPoly ); m_poly = splitPoly;
// take the rest of the polygons and divide them. vector< polygon<point3> > frontList, backList;
int i; for( i=0; i front, back; // used in PLIST_SPLIT
switch( res ) { case PLIST_FRONT: // drop down the front frontList.push_back( in[i] ); break; case PLIST_BACK: // drop down the back backList.push_back( in[i] ); break; case PLIST_SPLIT: // split the polygon, drop the halves down. m_plane.Split( in[i], &front, &back ); frontList.push_back( front ); backList.push_back( back ); break; case PLIST_COPLANAR: // add the polygon to this node's list m_coplanarList.push_back( in[i] ); break; } }
// we're done processing the polygon list. Deal with them. if( frontList.size() ) {
267
m_pFront = new cNode( frontList ); } else { m_pFront = new cNode( false ); } if( backList.size() ) { m_pBack = new cNode( backList ); } else { m_pBack = new cNode( true ); } }
void cBspTree::cNode::AddPolygon( const polygon<point3>& in ) { if( m_bIsLeaf ) { // reinitialize ourselves as a node *this = cNode( in ); } else { // test the polygon against this node. pListLoc res = this->m_plane.TestPoly( in );
polygon<point3> front, back; // used in PLIST_SPLIT switch( res ) { case PLIST_FRONT:
268
// drop down the front m_pFront->AddPolygon( in ); break; case PLIST_BACK: // drop down the back m_pBack->AddPolygon( in ); break; case PLIST_SPLIT: // split the polygon, drop the halves down. m_plane.Split( in, &front, &back ); m_pFront->AddPolygon( front ); m_pBack->AddPolygon( back ); break; case PLIST_COPLANAR: // add the polygon to this node's list m_coplanarList.push_back( in ); break; } } }
void cBspTree::cNode::TraverseTree( vector< polygon<point3>* >* polyList, const point3& loc ) { if( m_bIsLeaf ) { // do nothing. } else { // test the loc against the current node pointLoc res = m_plane.TestPoint( loc );
269
int i; switch( res ) { case POINT_FRONT: // get back, us, front m_pBack->TraverseTree( polyList, loc ); polyList->push_back( &m_poly ); // the poly at this node for( i=0; i<m_coplanarList.size(); i++ ) { polyList->push_back( &m_coplanarList[i] ); } m_pFront->TraverseTree( polyList, loc ); break;
case POINT_BACK: // get front, us, back m_pFront->TraverseTree( polyList, loc ); polyList->push_back( &m_poly ); // the poly at this node for( i=0; i<m_coplanarList.size(); i++ ) { polyList->push_back( &m_coplanarList[i] ); } m_pBack->TraverseTree( polyList, loc ); break;
case POINT_COPLANAR: // get front, back, us m_pFront->TraverseTree( polyList, loc ); m_pBack->TraverseTree( polyList, loc ); polyList->push_back( &m_poly ); // the poly at this node for( i=0; i<m_coplanarList.size(); i++ )
270
{ polyList->push_back( &m_coplanarList[i] ); } break;
} } }
int cBspTree::cNode::BestIndex( vector< polygon<point3> >& polyList ) { /** * The current hueristic is blind least-split */ // run through the list, searching for the best one. // the highest polygon we'll bother testing (10% of total) int maxCheck; maxCheck = (int)(polyList.size() * percentageToCheck); if( !maxCheck ) maxCheck = 1;
int i, i2; int bestSplits = 100000; int bestIndex = -1; int currSplits; plane3 currPlane; for( i=0; i<maxCheck; i++ ) { currSplits = 0; currPlane = plane3( polyList[i] ); pListLoc res;
for( i2=0; i2< polyList.size(); i2++ )
271
{ if( i == i2 ) continue;
res = currPlane.TestPoly( polyList[i2] ); if( res == PLIST_SPLIT ) currSplits++; } if( currSplits < bestSplits ) { bestSplits = currSplits; bestIndex = i; } } assert( bestIndex >= 0 ); return bestIndex; }
bool cBspTree::cNode::LineOfSight( const point3& a, const point3& b ) { if( m_bIsLeaf ) { // if we land in a solid node, then there is no line of sight return !m_bIsSolid; }
pointLoc aLoc = m_plane.TestPoint( a ); pointLoc bLoc = m_plane.TestPoint( b );
point3 split;
if( aLoc == POINT_COPLANAR && bLoc == POINT_COPLANAR ) {
272
// for sake of something better to do, be conservative //return false; return m_pFront->LineOfSight( a, b ); }
if( aLoc == POINT_FRONT && bLoc == POINT_BACK ) { //split, then return the logical 'or' of both sides split = m_plane.Split( a, b );
return m_pFront->LineOfSight( a, split ) && m_pBack->LineOfSight( b, split ); }
if( aLoc == POINT_BACK && bLoc == POINT_FRONT ) { // split, then return the logical 'or' of both sides split = m_plane.Split( a, b );
return m_pFront->LineOfSight( b, split ) && m_pBack->LineOfSight( a, split ); }
// the other == POINT_COLPLANAR or POINT_FRONT if( aLoc == POINT_FRONT || bLoc == POINT_FRONT ) { // drop down the front return m_pFront->LineOfSight( a, b ); }
else // they're both on the back side {
273
// drop down the front return m_pBack->LineOfSight( a, b ); }
return true; }
Wrapping It Up Most of the code discussed in this chapter is available from the downloadable files in one library, called math3d.lib. The rest of it (most notably the transformation, clipping, and lighting pipeline) won't be implemented by you; that's being left wholly to Direct3D. There aren't any sample applications for this chapter because you won't be able to draw any primitives until Chapter 8. The directory for this chapter contains more complete, more commented versions of the code discussed in this chapter. So feel free to take a look at that. In the next chapter I'm going to show you some really cool stuff. Get your terminator-destroying weapons out… It's time to check out the realms of artificial intelligence!
Chapter 6: Artificial Intelligence Overview Some of my earliest memories are of my dad bouncing me on his knee, playing computer games on our 8088. I was fascinated with computers, despite the fact that we only had two games for the machine: a game where a donkey ran down the road avoiding cars, and an app that used the PC speaker to crudely simulate a piano. One of my first phrases was "Dunkee n musik," a jumbled group of syllables I would yelp when I wanted to play the games. Right around then was when I saw my first AI application. The title escapes me (I believe it may have been just Animal), but the premise was simple enough. The object of the game was for the computer to guess an animal you were thinking about. It would ask a series of yes/no questions that would narrow down the possible choices (examples would be "does your animal fly?" or "does your animal have four legs?"), and when it was sure, it would tell you what it thought your animal was. The neat thing was, if it didn't guess your animal, it would ask you for a question that differentiated the two animals, something your animal had that the other didn't. From then on, the program would be able to guess your animal! It could learn! This impressed my young mind to no end. After some formal training in programming, I've come to accept that it's a fairly trivial program: The application keeps an internal binary tree with a question at
274
each branch and an animal at each leaf. It descends down the tree asking the question at each branch and taking the appropriate direction. If it reaches a leaf and the animal stored there isn't yours, it creates a new branch, adds your question, and puts your animal and the animal previously in the leaf in two new leaves. How the program worked, however, really isn't that important. The trick is, it seemed intelligent to me. Game programmers need to aim for this. While academia argues for the next 50 years over whether or not human-level intelligence is possible with computers, game developers need only be concerned with tricking humans into thinking what they're playing against is intelligent. And luckily (for both developers and academia), humans aren't that smart. This is, of course, not as easy as it sounds. Video games are rife with pretty stupid computer opponents. Early first-person shooters had enemies that walked towards the player in a zigzag pattern, never walking directly towards their target, shooting intermittently. Bad guys in other games would sometimes walk into a corner looking for you, determined that they would eventually find you even though you were several rooms away. Fighting games are even worse. The AI governing computer opponents can become extremely repetitive (so that every time you jump towards the opponent, they execute the same move). I can't promise to teach you everything you need to know to make the next Reaper Bot; that would be the topic of an entire book all its own. By the end of this chapter, however, you should be able to write an AI that can at least challenge you and maybe even surprise you!
Starting Point Most AI problems that programmers face fall into three groups. At the lowest level is the problem of physical movement—how to move the unit, how to turn, how to walk, etc. This group is sometimes called locomotion, or motor skills. Moving up one level is a higher-level view of unit movement, where the unit has to decide how to get from point A to point B, avoiding obstacles and/or other units. This group is called steering, or task generation. Finally, at the highest level, the meatiest part of AI, is the actual thinking. Any cockroach can turn in a circle and do its best to avoid basic obstacles (like a human's foot). That does not make the cockroach intelligent. The third and highest stage is where the unit decides what to do and uses its ability to move around and plan directions to carry out its wishes. This highest level is called motivation, or action steering.
Locomotion Locomotion, depending on how you look at it, is either trivial or trivially complex. An animation-based system can handle locomotion pretty easily, move forward one unit, and use the next frame of animation in the walk cycle. Every game on the market uses something similar to this to handle AI locomotion. However, that isn't the whole story. When you walk up stairs, you need a stair walking animation; when you descend down a hill, you naturally lean back to retain your balance. The angle you lean back is dependent on the angle of the hill. The amount you dig your feet into the ice is dependent on how slippery the ice is and how sure your footing needs to be before you proceed. Animation systems robust enough to handle cases like this require a lot of special casing and scripting; most animation systems
275
use the same walk animation for all cases. I always found it kind of disappointing when the guards in the surface level of Goldeneye could simply walk up 8-foot tall, 70 degree banks of snow. A branch of control theory attempts to solve this with physical controllers. You can actually teach an AI how to stand and tell it how to retain its balance, how to walk around, jump, anything. This gives the AI incredible control, as the algorithms can handle any realistic terrain, any conditions. Many people agree that the future of locomotion in games is physical controllers. However, physical controllers aren't easy. At all. For these purposes, it's total overkill. As Moore's law inevitably marches forward, there will eventually be enough processing power to devote the cycles to letting each creature figure out how to run towards its target. When this happens, games will be one huge step closer to looking like real life.
Steering—Basic Algorithms Even games with little or no AI at all need to implement some form of steering. Steering allows entities to navigate around the world they exist in. Without it, enemies would just sit there with a rather blank look in their eyes. There are a slew of extremely basic steering algorithms that I'll touch upon, and a couple of slightly more advanced ones that I'll dig into a little deeper.
Chasing The first AI that most people implement is the ruthless, unthinking, unrelenting Terminator AI. The creature never thinks about rest, about getting health or ammo, about attacking other targets, or even walking around obstacles: It just picks a target and moves towards it each frame relentlessly. The code to handle this sort of AI is trivial. Each frame, the creature takes the position of its target, generates a vector to it, and moves along the vector a fixed amount (the amount is the speed of the creature). Pseudocode to handle this type of AI is in Listing 6.1. Listing 6.1: The Terminator manifested
void cCreature::Chase( cObject* target ) { // Find the locations of the creature and its target. point3 creatureLoc = m_loc; point3 targetLoc = target->GetLoc();
// Generate a direction vector between the objects point3 direction = targetLoc - creatureLoc;
276
// Normalize the direction (make it unit-length) direction.Normalize();
// move our object along the direction vector some fixed amount m_loc += direction * m_speed; }
Evading The inverse of a chasing algorithm is what I could probably get away with calling rabbit AI, but I'll leave it at evading. Each frame, you move directly away from a target as fast as you can (although in this case the target would most likely be a predator). Listing 6.2: John Connor, perhaps?
void cCreature::Evade( cObject* target ) { // Find the locations of the creature and its target. point3 creatureLoc = m_loc; point3 targetLoc = target->GetLoc();
// Generate a direction vector between the objects point3 direction = targetLoc - creatureLoc;
// Normalize the direction (make it unit-length) direction.Normalize();
// move our object away from the target by multiplying // by a negative speed m_loc += direction * -m_speed; }
277
Pattern-based AI Another fairly simple AI algorithm I'm going to discuss is pattern-based AI. If you have ever played the classic Space Invaders, you're familiar with this AI algorithm. Aliens take turns dive-bombing the player, with every type of alien attacking in one uniform way. The way it attacks is called a pattern. At each point in time, each creature in the simulation is following some sort of pattern. The motivation engine (in this case, usually a random number generator) decides from a fixed set of patterns to perform. Each pattern encodes a series of movements to be carried out each frame. Following the Space Invaders theme, examples of pattern-based AI would be moving back and forth, diving, and diving while shooting. Anyone who has played the game has noticed that each unit type dives towards the player the same way, oblivious to where the player is. When the baddies aren't diving, they all slide back and forth in the same exact way. They're all following the same set of patterns. The algorithm to run a pattern-based AI creature is straightforward. I'll define a pattern to be an array of points that define direction vectors for each frame of the pattern. Since the arrays can be of any length, I also keep track of the length of the array. Then during the AI simulation step the creature moves itself by the amount in the current index of the array. When it reaches the end of an array, it randomly selects a new pattern. Let's examine some pseudocode to handle pattern-based AI. Listing 6.3: Pattern-based AI
struct sPattern { int patternLength; point3 *pattern; // array of length patternLength };
sPattern g_patterns[ NUM_PATTERNS ];
void cCreature::FollowPattern() { // pattFrame is the current frame of the pattern // pattNum is the current pattern we're using.
if( pattFrame >= g_patterns[ pattNum ].patternLength )
278
{ // new pattern pattNum = rand()%NUM_PATTERNS; pattFrame = 0; }
// follow our current pattern. m_loc += g_patterns[pattNum].pattern[pattFrame++]; }
Pattern-based AI can be specialized into what is known as scripted AI. When a certain state is reached, the motivation engine can run a certain scripted steering pattern. For example, an important state would be your player entering a room with a bad guy in it. This could cause the creature to follow a specialized animation just for that one game situation. The bad guy could run and trip an alarm, dive out of bed towards his bludgeoning weapon of choice, or anything else you can dream up.
Steering—Advanced Algorithms In case you haven't figured it out yet, the basic steering algorithms provided so far are terrible! They merely provide the creature with an ability to move. Moving in a pattern, moving directly towards an opponent, or fleeing directly away from it is only slightly more believable than picking a random direction to move every frame! No one will ever mistake your basic cretins for intelligent creatures. Real creatures don't follow patterns. Moving directly towards or directly away from you makes them an easy target. A prime example of how this would fail is illustrated in Figure 6.1.
279
Figure 6.1: Chasing directly towards a target wouldn't be too smart in many cases How can you make the creatures appear more intelligent? It would be cool to give them the ability to navigate through an environment, avoiding obstacles. If the top-level motivation AI decides that it needs health or ammo, or needs to head to a certain location, the task of getting there intelligently should be handed off to the steering engine. Two general algorithms for achieving this are what I'll discuss next.
Potential Functions Luckily for game programmers, a lot of the hard problems in steering and autonomous navigation for AI creatures have already been solved by the robotics community. Getting an autonomous unit, like a Mars rover, to plan a path and execute it in a foreign environment is a problem that countless researchers and academics have spent years trying to solve. One of the ways they have come up with to let a robot (or a creature in the game) wander through an unknown scene is to use what are called potential functions. Imagine a scene filled with obstacles, say tree trunks in a forest. There is a path from the start to the goal and no tricky situations (like a U-shaped wall of trees, which ends up being a real problem as you'll see in a moment). The unit should be able to reach the goal; all it needs to do is not run into any trees. Anytime it gets close to a tree, logically, it should adjust its direction vector so it moves away from the tree. The amount it wants to move away from the tree should be a function based on the distance from the obstacle; that is, if it is right next to the obstacle, it will want to avoid it more than if it is half a mile away from it. Figure 6.2 shows an example of this. It will obviously want to try to avoid obstacle 1 more than it tries to avoid obstacle 2, since obstacle 2 is so much farther away.
Figure 6.2: Some obstacles should be avoided more than others This statement can be turned into an equation. Initially the direction is the normalized vector leading to the goal (or the goal location minus the current location). Then, for each obstacle, you find the
280
normalized vector that moves directly away from it. Then multiply it by a constant, and divide it by the squared distance from the obstacle. When finished, you have a vector that the object should use as a direction vector (it should be normalized, however).
Generally the obstacles (and the object navigating) have some radius associated with them, so the last term in the equation can be adjusted to use the distance between the spheres, instead of the distance between the spheres' centers.
The Good Potential functions work great in sparse areas with physical obstacles, particularly outdoor scenes. You can reach a goal on the other side of a map avoiding trees, rocks, and houses beautifully and with little computational effort. A quick and easy optimization is to only consider the objects that are within some reasonable distance from you, say 50 feet; that way you don't need to test against every object in the world (which could have hundreds or thousands of objects in it). One great advantage of potential functions is that the obstacles themselves can move around. You can use potential functions to model the movement of a squad of units across a map for example. They can avoid obstacles in the scene (using potential functions or more complex path finding algorithms like A*) and then avoid each other using potential functions.
The Bad Potential functions are not a silver bullet for all problems, however. As intelligent as units can look being autonomously navigated with this method, they're still incredibly stupid. Mathematically, think of the potential functions as descending into a valley towards a goal, with the obstacles appearing as hills that roll past. If there is a miniature valley that is descended into, there is no way of getting out of it, since the only way to move is downward. This miniature valley can appear all over the place; if two obstacles are too close to each other, you won't be able to pass between them, and if obstacles are organized to form a barrier, like a wall or specifically a U-shaped obstacle, you're totally screwed. Figure 6.3 gives an example of this.
281
Figure 6.3: Potential functions alone cannot get to the goal in this configuration
Application: potentialFunc To help explain the ideas described above, I wrote a small test app to show off potential functions. You can use the z, x, and c keys to make large, medium, and small obstacles under the mouse, respectively. The Space key releases a creature under the mouse that heads to the goal, which appears as a green circle. Since the GDI is so slow, I decided against clearing the window every frame, so the creatures leave trails as they move around. For most cases, the creatures (more than one can be created at once) reach their goal well, as evidenced in the following picture:
Figure 6.4: Potential functions doing their job However, they don't work all the time, as evidenced by this picture:
282
Figure 6.5: Potential functions failing spectacularly You'll notice that inside the code I sum the potential forces for the objects and move a bit ten times each frame. If I only moved once, I would need to move a fairly large amount to have the speed of the creature be anything interesting. However, when the deltas are that large, the result is some ugly numerical stability problems (characterized by a jittering when the creature gets very close to an obstacle). Sampling multiple times each frame fixes the problem. The GDI isn't useful for writing 3D games, so I'm covering it very minimally in this book. However, for doing something like a potential function application it turns out to be quite useful. While I'm providing no explanations of how GDI works, armed with this code and the Win32 SDK documentation, figuring it out on your own won't be terribly difficult. The code uses two main classes, cCreature (an entity that tries to reach the goal) and cObstacle (something obstructing the path to the goal). The code keeps vectors of all of the creatures and objects in the scene. Each frame, each member of the creature vector gets processed, during which it examines the list of obstacles. A nice extension to the program would be for creatures to also avoid other creatures; currently they blindly run all over each other. The code for this application is mostly GUI and drawing code, and the important function is cCreature::Process. It is called every frame, and it performs the potential function equation listed above to find the new location. After each creature gets processed, the entire scene gets drawn. Rather than list all of the code for the program, I'll just give this one function. Listing 6.4: The main function of note, cCreature::Process
bool cCreature::Process() { point3 goalVec = g_goalLoc - m_loc;
283
if( goalVec.Length() < g_creatureSpeed ) return false; // we reached the goal, destroy ourselves
point3 dirVec = goalVec / goalVec.Length();
float k = .1f;
// for each obstacle for( int i=0; i edges node parent real cost
struct edge node dest
288
real cost
while( priority_queue is not empty ) node curr = priority_queue.pop for( all edges leaving curr ) if( edge.dest.cost > curr.cost + edge.cost ) edge.dest.cost = curr.cost + edge.cost edge.dest.parent = curr
Let me step through the algorithm so I can show you what happens. In the first iteration, I take the starting node off the priority queue (since its best cost is zero and the rest are all set to infinity). All of the destination nodes are currently at infinity, so they get updated, as shown in Figure 6.10.
Figure 6.10: Aftermath of the first step of Dijkstra's algorithm Then it all has to be done again. The new node you pull off the priority queue is the top left node, with a best cost of 8. It updates the top right node and the center node, as shown in Figure 6.11.
289
Figure 6.11: Step 2 The next node to come off the queue is the bottom right one, with a value of 10. Its only destination node, the top right one, already has a best cost of 13, which is less than 15 (10 + the cost of the edge −15). Thus, the top right node doesn't get updated, as shown in Figure 6.12.
Figure 6.12: Step 3 Next is the top right node. It updates the center node, giving it a new best cost of 14, producing Figure 6.13.
290
Figure 6.13: Step 4 Finally, the center node is visited. It doesn't update anything. This empties the priority queue, giving the final graph, which appears in Figure 6.14.
Figure 6.14: The graph with the final parent-pointers and costs
Using Graphs to Find Shortest Paths Now, armed with Dijkstra's algorithm, you can take a point and find the shortest path and shortest distance to all other visitable nodes on the graph. But one question remains: How is the graph to traverse generated? As it turns out, this is a simple, automatic process, thanks to the spatial data structure. First, the kind of behavior that you wish the creature to have needs to be established. When a creature's target exists in the same convex cell the creature is in, the path is simple: Go directly towards the object using something like the Terminator AI I discussed at the beginning of the chapter. There is no need to worry about colliding with walls since the definition of convexity assures that it is possible to just march directly towards the target.
291
Warning
I'm ignoring the fact that the objects take up a certain amount of space, so the total set of the creature's visitable points is slightly smaller than the total set of points in the convex cell. For the purposes of what I'm doing here, this is a tolerable problem, but a more robust application would need to take this fact into account.
So first there needs to be a way to tell which cell an object is in. Luckily, this is easy to do. Each polygon in a cell has a plane associated with it. All of the planes are defined such that the normal points into the cell. Simply controlling the winding order of the polygons created does this. Also known is that each point can be classified whether it is in front of or in back of a plane. For a point to be inside a cell, it must be in front of all of the planes that make up the boundary of the cell. It may seem mildly counterintuitive to have the normals sticking in towards the center of the object rather than outwards, but remember that they're never going to be considered for drawing from the outside. The cells are areas of empty space surrounded by solid matter. You draw from the inside, and the normals point towards you when the polygons are visible, so the normals should point inside. Now you can easily find out the cell in which both the source and destination locations are. If they are in the same cell, you're done (marching towards the target). If not, more work needs to be done. You need to generate a path that goes from the source cell to the destination cell. To do this, you put nodes inside each portal, and throw edges back and forth between all the portals in a cell. An implementation detail is that a node in a portal is actually held by both of the cells on either side of the portal. Once the network of nodes is set up, building the edges is fairly easy. Add two edges (one each way) between each of the nodes in each cell. You have to be careful, as really intricate worlds with lots of portals and lots of nodes have to be carefully constructed so as not to overload the graph. (Naturally, the more edges in the graph, the longer Dijkstra's algorithm will take to finish its task.) You may be wondering why I'm bothering with directed edges. The effect of having two directed edges going in opposite directions would be the same as having one bi-directed edge, and you would only have half the edges in the graph. In this 2D example there is little reason to have unidirectional edges. But in 3D everything changes. If, for example, the cell on the other side of the portal has a floor 20 feet below the other cell, you can't use the same behavior you use in the 2D example, especially when incorporating physical properties like gravity. In this case, you would want to let the creature walk off the ledge and fall 20 feet, but since the creature wouldn't be able to turn around and miraculously leap 20 feet into the air into the cell above, you don't want an edge that would tell you to do so. Here is where you can start to see a very important fact about AI. Although a creature seems intelligent now (well… more intelligent than the basic algorithms at the beginning of the chapter would allow), it's following a very standard algorithm to pursue its target. It has no idea what gravity is, and it has no idea that it can't leap 20 feet. The intelligence in this example doesn't come from the algorithm itself, but rather it comes from the implementation, specifically the way the graph is laid out. If it is done poorly (for example, putting in an edge that told the creature to move forward even though the door was 20 feet
292
above it), the creature will follow the same algorithm it always does but will look much less intelligent (walking against a wall repeatedly, hoping to magically cross through the doorway 20 feet above it).
Application: Path Planner The second application for this chapter is a fully functioning path planner and executor. The code loads a world description off the disk, and builds an internal graph to navigate with. When the user clicks somewhere in the map, the little creature internally finds the shortest path to that location and then moves there. Parsing the world isn't terribly hard; the data is listed in ASCII format (and was entered manually, yuck!). The first line of the file has one number, providing the number of cells. Following, separated by blank lines, are that many cells. Each cell has one line of header (containing the number of vertices, number of edges, number of portals, and number of items). Items were never implemented for this demo, but they wouldn't be too hard to stick in. It would be nice to be able to put health in the world and tell the creature "go get health!" and have it go get it. Points are described with two floating-point coordinates, edges with two indices, and portals with two indices and a third index corresponding to the cell on the other side of the doorway. Listing 6.6 has a sample cell from the world file you'll be using. Listing 6.6: Sample snippet from the cell description file
17
6 5 1 0 -8.0 8.0 -4.0 8.0 -4.0 4.0 -5.5 4.0 -6.5 4.0 -8.0 4.0 0 1 1 2 2 3 4 5 5 0 3 4 8
293
... more cells
Building the graph is a little trickier. The way it works is that each pair of doorways (remember, each conceptual doorway has a doorway structure leading out of both of the cells touching it) holds onto a node situated in the center of the doorway. Each cell connects all of its doorway nodes together with dual edges—one going in each direction. When the user clicks on a location, first the code makes sure that the user clicked inside the boundary of one of the cells. If it did not, the click is ignored. Only approximate boundary testing is used (using two-dimensional bounding boxes); more work would need to be done to do more exact hit testing (this is left as an exercise for the reader). When the user clicks inside a cell, then the fun starts. Barring the trivial case (the creature and clicked location are in the same cell), a node is created inside the cell and edges are thrown out to all of the doorway nodes. Then Dijkstra's algorithm is used to find the shortest path to the node. The shortest path is inserted into a structure called sPath that is essentially just a stack of nodes. While the creature is following a path, it peeks at the top of the stack. If it is close enough to it within some epsilon, the node is popped off the stack and the next one is chosen. When the stack is empty, the creature has reached its destination. The application uses the GDI for all the graphics, making it fairly slow. Also, the graph searching algorithm uses linear searches to find the cheapest node while it's constructing the shortest path. What fun would it be if I did all the work for you? A screen shot from the path planner appears in Figure 6.15 on the following page. The creature appears as a red circle.
294
Figure 6.15: Screen shot from the path planner Listing 6.7 gives the code used to find the shortest path in the graph. There is plenty of other source code to wander through in this project, but this seemed like the most interesting part. Listing 6.7: The graph searching code for the path planner
cNode* cWorld::FindCheapestNode() { // ideally, we would implement a slightly more advanced // data structure to hold the nodes, like a heap. // since our levels are so simple, we can deal with a // linear algorithm.
float fBestCost = REALLY_BIG; cNode* pOut = NULL;
295
for( int i=0; i<m_nodeList.size(); i++ ) { if( !m_nodeList[i]->m_bVisited ) { if( m_nodeList[i]->m_fCost < fBestCost ) { // new cheapest node fBestCost = m_nodeList[i]->m_fCost; pOut = m_nodeList[i]; } } }
// if we haven't found a node yet, something is // wrong with the graph. assert( pOut );
return pOut; }
void cNode::Relax() { this->m_bVisited = true;
for( int i=0; i<m_edgeList.size(); i++ ) { cEdge* pCurr = m_edgeList[i]; if( pCurr->m_fWeight + this->m_fCost < pCurr->m_pTo->m_fCost ) { // relax the 'to' node pCurr->m_pTo->m_pPrev = this; pCurr->m_pTo->m_fCost = pCurr->m_fWeight + this->m_fCost;
296
} } }
void cWorld::ShortestPath( sPath* pPath, cNode *pTo, cNode* pFrom ) { // easy out. if( pTo == pFrom ) return;
InitShortestPath();
pFrom->m_fCost = 0.f;
bool bDone = false; cNode* pCurr; while( 1 ) { pCurr = FindCheapestNode(); if( !pCurr ) return; // no path can be found. if( pCurr == pTo ) break; // We found the shortest path
pCurr->Relax(); // relax this node }
// now we construct the path.
// empty the path first. while( !pPath->m_nodeStack.empty() ) pPath->m_nodeStack.pop();
pCurr = pTo;
297
while( pCurr != pFrom ) { pPath->m_nodeStack.push( pCurr ); pCurr = pCurr->m_pPrev; } }
Motivation The final area of AI I'll be discussing is the motivation of a creature. I feel it's the most interesting facet of AI. The job of the motivation engine is to decide, at a very high level, what the creature should be doing. Examples of high-level states would be "get health" or "attack nearest player." Once you have decided on a behavior, you create a set of tasks for the steering engine to accomplish. Using the "get health" example, the motivation engine would look through an internal map of the world for the closest health and then direct the locomotion engine to find the shortest path to it and execute the path. I'll show you a few high-level motivation concepts.
Non-Deterministic Finite Automata (NFAs) NFAs are popular in simpler artificial intelligence systems (and not only in AI; NFAs are used everywhere). If, for example, you've ever used a search program like grep (a UNIX searching command), you've used NFAs. They're a classical piece of theoretic computer science, an extension of Deterministic Finite Automata (DFAs). How do they work? In the classic sense, you have a set of nodes connected with edges. One node (or more) is the start node and one (or more) is the end node. At any point in time, there is a set of active nodes. You send a string of data into an NFA. Each piece is processed individually. The processing goes as follows: Each active node receives the current piece of data. It makes itself inactive and compares the data to each of its edges. If any of its outgoing edges match the input data, they turn their destination node on. There is a special type of edge called an epsilon edge, which turns its destination on regardless of the input. When all of the data has been processed, you look at the list of active nodes. If any of the end nodes are active, then that means the string of data passed. You construct the NFA to accept certain types of strings and can quickly run a string through an NFA to test it. Here are a few examples to help make the definition more concrete. Both of the examples are fairly simple NFAs just to show the concepts being explained. Let's say there is an alphabet with exactly two
298
values, A and B. The first example, Figure 6.16, is an NFA that accepts only the string ABB and nothing else.
Figure 6.16: NFA that accepts the string ABB The second example, Figure 6.17, shows an NFA that accepts the string A*B, where A* means any number of As, including zero.
Figure 6.17: NFA that accepts the string A*B How is this useful for game programming? If you encode the environment that the creature exists in into a string that you feed into an NFA, you can allow it to process its scene and decide what to do. You could have one goal state for each of the possible behaviors (that is, one for "attack enemy," one for
299
"get health," and other high-level behaviors). As an example, one of the entries in the array of NFA data could represent how much ammo the character has. Let's say there are three possible states: {Plenty of ammo, Ammo, Little or no ammo}. The edge that corresponded to "Plenty of ammo" would lead to a section of the NFA that would contain aggressive end states, while the "Little or no ammo" edges would lead to a section of the NFA that would most likely have the creature decide that it needed to get some ammo. The next piece of data would describe a different aspect of the universe the creature existed in, and the NFA would have branches ready to accept it. Table 6.1 contains some examples of states that could be encoded in the string of data for the NFA.
Table 6.1: Some example states that could be encoded into an NFA Proximity to
Very near; Average distance; Very far.
nearest
If the nearest opponent is very far, the edge could lead to states that encourage
opponent
the collection of items.
Health
Plenty of health; Adequate health; Dangerous health. If the creature has dangerously low health and the opponent was very near, a kamikaze attack would probably be in order. If the nearest enemy was very far away, it should consider getting some health.
Environment
Tight and close; Medium; Expansive. A state like this would determine which weapon to use. For example, an explosive weapon like a rocket launcher shouldn't be used in tight and close areas.
Enemy health
Plenty of health; Adequate health; Dangerous health. The health of the nearest enemy determines the attacking pattern of the creature. Even if the creature has moderate to low health, it should try for the kill if the enemy has dangerous health.
Enemy altitude
Above; Equal; Below. It's advantageous in most games to be on higher ground than your opponent, especially in games with rocket launcher splash damage. If the creature is below its nearest opponent and the opponent is nearby, it might consider retreating to higher ground before attacking.
300
One way to implement NFAs would be to have a function pointer in each end state that got executed after the NFA was processed if the end state succeeded. The only problem with NFAs is that it's extremely difficult to encode fuzzy decisions. For example, it would be better if the creature's health was represented with a floating-point value, so there would be a nearly continuous range of responses based on health. I'll show you how to use neural networks to do this. However, NFA-based AI can be more than adequate for many games. If your NFA's behavior is too simple, you generally only need to extend the NFA, adding more behaviors and more states.
Genetic Algorithms While not directly a motivation concept, genetic algorithms (or GAs) can be used to tweak other motivation engines. They try to imitate nature to solve problems. Typically, when you're trying to solve a problem that has a fuzzy solution (like, for example, the skill of an AI opponent), it's very hard to tweak the numbers to get the best answer. One way to solve a problem like this is to attack it the way nature does. In nature (according to Darwin, anyway) animals do everything they can to survive long enough to produce offspring. Typically, the only members of a species that survive long enough to procreate are the most superior of their immediate peers. In a pride of lions, only one male impregnates all of the females. All of the other male lions vie for control of the pride, so that their genes get carried on. Added to this system, occasionally, is a bit of mutation. An offspring is the combination of the genes of the two parents, but it may be different from either of the parents by themselves. Occasionally, an animal will be born with bigger teeth, sharper claws, longer legs, or in Simpsonian cases, a third eye. The change might give that particular offspring an advantage over its peers. If it does, that offspring is more likely than the other animals to carry on its genes, and thus, over time, the species improves. That's nice and all, but what does that have to do with software development? A lot, frankly. What if you could codify the parameters of a problem into genes? You could randomly create a set of animals, each with its own genes. They are set loose, they wreak havoc, and a superior pair of genes is found. Then you combine these two genes, sprinkle some random perturbations in, and repeat the process with the new offspring and another bunch of random creatures. For example, you could define the behavior of all the creatures in terms of a set of scalar values. Values that define how timid a creature is when it's damaged, how prone it is to change its current goal, how accurate its shots are when it is moving backward, and so forth. Correctly determining the best set of parameters for each of the creatures can prove difficult. Things get worse when you consider other types of variables, like the weapon the creature is using and the type of enemy it's up against.
301
Genetic algorithms to the rescue! Initially, you create a slew of creatures with a bunch of random values for each of the parameters and put them into a virtual battleground, having them duke it out until only two creatures remain. Those two creatures mate, combining their genes and sprinkling in a bit of mutation to create a whole new set of creatures, and the cycle repeats. The behavior that genetic algorithms exhibit is called hill climbing. You can think of a creature's idealness as a function of n variables. The graph for this function would have many relative maximums and one absolute maximum. In the case where there were only two variables, you would see a graph with a bunch of hills (where the two parameters made a formidable opponent), a bunch of valleys (where the parameters made a bad opponent), and an absolute maximum (the top of the tallest mountain: the best possible creature). For each iteration, the creature that will survive will hopefully be the one that was the highest on the graph. Then the iteration continues, with a small mutation (you can think of this as sampling the area immediately around the creature). The winner of the next round will be a little bit better than its parent as it climbs the hill. When the children stop getting better, you know you have reached the top of a hill, a relative maximum. How do you know if you reached the absolute maximum, the tallest hill on the graph? It's extremely hard to do. If you increase the amount of mutation, you increase the area you sample around the creature, so you're more likely to happen to hit a point along the slope of the tallest mountain. However, the more you increase the sampling area, the less likely you are to birth a creature further up the mountain, so the function takes much longer to converge.
Rule-Based AI The world of reality is governed by a set of rules, rules that control everything from the rising and setting of the sun to the way cars work. The AI algorithms discussed up to this point aren't aware of any rules, so they would have a lot of difficulty knowing how to start a car, for example. Rule-based AI can help alleviate this problem. You define a set of rules that govern how things work in the world. The creature can analyze the set of rules to decide what to do. For example, let's say that a creature needs health. It knows that there is health in a certain room, but to get into the room the creature must open the door, which can only be done from a security station console. One way to implement this would be to hardcode the knowledge into the creature. It would run to the security station, open the door, run through it, and grab the health. However, a generic solution has a lot of advantages. The behavior it can exhibit isn't limited to just opening security doors. Anything you can describe with a set of rules is something it can figure out. See Listing 6.8 for a subset of the rules for a certain world. Listing 6.8: Some rules for an example world
302
IF [Health_Room == Visitable] THEN [Health == Gettable] IF [Security_Door == Door_Open] THEN [Health_Room == Visitable] IF [Today == Sunday] THEN [Tacos == 0.49] IF [Creature_Health < 0.25] THEN [Creature_State = FindGettableHealth] IF [Creature_Position NEAR Security_Console] THEN [Security_Console_Usable] IF [Security_Console_Usable] AND [Security_Door != Door_Open] THEN [Creature_Use(Security_Console)] IF [Security_Console_Used] THEN [Security_Door == Door_Open] IF [Creature_Move_To(Security_Console)] THEN [Creature_Position NEAR Security_Console]
Half the challenge in setting up rule-based systems is to come up with an efficient way to encode the rules. The other half is actually creating the rules. Luckily a lot of the rules, like the Creature_Move_To rule at the end of the list, can be automatically generated. How does the creature figure out what to do, given these rules? It has a goal in mind: getting health. It looks in the rules and finds the goal it wants, [Health == Gettable]. It then needs to satisfy the condition for that goal to be true, that is [Health_Room == Visitable]. The creature can query the game engine and ask it if the health room is visitable. When the creature finds out that it is not, it has a new goal: making the health room visitable. Searching the rules again, it finds that [Health_Room == Visitable] if [Security_Door == Door_Open]. Once again, it sees that the security door is not open, so it analyzes the rule set again, looking for a way to satisfy the condition. This process continues until the creature reaches the rule saying that if it moves to the security console, it will be near the security console. Finally, a command that it can do! It then uses path planning to get
303
to the security console, presses the button to open the security door, moves to the health room, and picks up the health. AI like this can be amazingly neat. Nowhere do you tell how to get the health. It actually figured out how to do it all by itself. If you could encode all the rules necessary to do anything in a particular world, then the AI would be able to figure out how to accomplish whatever goals it wanted. The only tricky thing is encoding this information in an efficient way. And if you think that's tricky, try getting the creature to develop its own rules as it goes along. If you can get that, your AI will always be learning, always improving.
Neural Networks One of the huge areas of research in AI is in neural networks (NNs). They take a very fundamental approach to the problem of artificial intelligence by trying to closely simulate intelligence, in the physical sense. Years of research have gone into studying how the brain actually works (it's mystifying that evolution managed to design an intelligence capable of analyzing itself). Researchers have discovered the basic building blocks of the brain and have found that, at a biological level, it is just a really, really (REALLY) dense graph. On the order of billions or trillions of nodes, and each node is connected to thousands of others. The difference between the brain and other types of graphs is that the brain is extremely connected. Thinking of several concepts brings up several other concepts, simply through the fact that the nodes are connected. As an example, think for a moment about an object that is leafy, green, and crunchy. You most likely thought about several things, maybe celery or some other vegetable. That's because there is a strong connection between the leafy part of your brain and things that are leafy. When the leafy neuron fires, it sends its signal to all the nodes it's connected to. The same goes for green and crunchy. Since, when you think of those things, they all fire and all send signals to nodes, some nodes receive enough energy to fire themselves, such as the celery node. Now, I'm not going to attempt to model the brain itself, but you can learn from it and build your own network of electronic neurons. Graphs that simulate brain activity in this way are generally called neural networks. Neural networks are still a very active area of research. In the last year or so, a team was able to use a new type of neural network to understand garbled human speech better than humans can! One of the big advantages of neural networks is that they can be trained to remember their past actions. You can teach them, giving them an input and then telling them the correct output. Do this enough times and the network can learn what the correct answer is.
304
However, that is a big piece of pie to bite down on. Instead, I'm going to delve into a higher-level discussion of neural networks, by explaining how they work sans training, and providing code for you to play with.
A Basic Neuron Think of a generic neuron in your brain as consisting of three biological parts: an axon, dendrites, and a soma. The processing unit is the soma. It takes input coming from the dendrites and outputs to the axon. The axon, in turn, is connected to the dendrites of other neurons, passing the signals on. These processes are all handled with chemicals in real neurons; a soma that fires is, in essence, sending a chemical down its axon that will meet up with other dendrites, sending the fired message to other neurons. Figure 6.18 shows what a real neuron looks like.
Figure 6.18: A biological neuron The digital version is very similar. There is a network of nodes connected by edges. When a node is processed, it takes all of the signals on the incoming edges and adds them together. One of these edges is a special bias or memory edge, which is just an edge that is always on. This value can change to modify the behavior of the network (the higher the bias value, the more likely the neuron is to fire). If the summation of the inputting nodes is above the threshold (usually 1.0), then the node sends a fire signal to each of its outgoing edges. The fire signal is not the result of the addition, as that may be much more than 1.0. It is always 1.0. Each edge also has a bias that can scale the signal being passed it higher or lower. Because of this, the input that arrives at a neuron can be just about any value, not just 1.0 (firing neurons) or 0 (non-firing neurons). They may be anywhere; if the edge bias was 5.0, for example, the neuron would receive 5.0 or 0, depending on whether the neuron attached to it fired or not. Using a bias on the edges can also make a fired neuron have a dampened effect on other neurons. The equation for the output of a neuron can be formalized as follows:
305
where you sum over the inputs n (the bias of the edge, multiplied by the output of the neuron attached to it) plus the weight of the bias node times the bias edge weight. Other types of responses to the inputs are possible; some systems use a Sigmoid exponential function like the one below. A continuous function such as this makes it easier to train certain types of networks (back propagation networks, for example), but for these purposes the all-or-nothing response will do the job.
One of the capabilities of the brain is the ability to imagine things given a few inputs. Imagine you hear the phrases "vegetable," "orange," and "eaten by rabbits." Your mind's eye conjures up an image of carrots. Imagine your neural network's inputs are these words and your outputs are names of different objects. When you hear the word "orange," somewhere in your network (and your brain) an "orange" neuron fires. It sends a fire signal to objects you have associated with the word "orange" (for example: carrots, oranges, orange crayons, an orange shirt). That signal alone probably won't be enough for any particular one of those other neurons to fire; they need other signals to help bring the total over the threshold. If you then hear another phrase, such as "eaten by rabbits," the "eaten by rabbits" neuron will fire off a signal to all the nodes associated with that word (for example: carrots, lettuce, boisterous English crusaders). Those two signals may be enough to have the neuron fire, sending an output of carrots. Figure 6.19 abstractly shows what is happening.
306
Figure 6.19: A subsection of a hypothetical neural network
Simple Neural Networks Neural networks are Turing-complete; that is, they can be used to perform any calculation that computers can do, given enough nodes and enough edges. Given that you can construct any processor using nothing but NAND gates, this doesn't seem like too ridiculous a conjecture. Let's look at some simpler neural networks before trying to tackle anything more complex. AND Binary logic seems like a good place to start. As a first stab at a neural net, let's try to design a neural net that can perform a binary AND. The network appears in Figure 6.20.
Figure 6.20: A neural network that can perform a binary AND function Note that the input nodes have a bias of 0.1. This is to help fuzzify the numbers a bit. You could make the network strict if you'd like (setting the bias to 0.0), but for many applications 0.9 is close enough to 1.0 to count as being 1.0. OR Binary OR is similar to AND; the middle edges just have a higher weight so that either one of them can activate the output node. The net appears in Figure 6.21.
307
Figure 6.21: A neural network that can perform a binary OR function XOR Handling XOR requires a bit more thought. Three nodes alone can't possibly handle XOR; you need to make another layer to the network. A semi-intuitive reasoning behind the workings of Figure 6.22: The top internal node will only be activated if both input nodes fire. The bottom one will fire if either of the input nodes fires. If both internal nodes fire, that means that both input nodes fired (a case you should not accept), which is correctly handled by having a large negative weight for the edge leading from the top internal node to the output node.
Figure 6.22: A neural network that can perform a binary XOR function
Training Neural Networks While it's outside the scope of this book, it's important to know one of the most important and interesting features about neural nets: They can be trained. Suppose you create a neural net to solve a certain
308
problem (or put another way, to give a certain output given a set of inputs). You can initially seed the network with random values for all of the edge biases and then have the network learn. Neural nets can be trained or can learn autonomously. An autonomously learning neural net would be, for example, an AI that was trying to escape from a maze. As it moves, it learns more information, but it has no way to check its answer as it goes along. These types of networks learn much slower than trained networks. Trained neural networks on the other hand have a cheat sheet; that is, they know the solution to each problem. They run an input and check their output against the correct answer. If it is wrong, the network modifies some of the weights so that it gets the correct answer the next time.
Using Neural Networks in Games Using a neural network to decide the high-level action to perform in lieu of NFAs has a lot of advantages. For example, the solutions are often much fuzzier. Reaching a certain state isn't as black and white as achieving a certain value in the string of inputs; it's the sum of a set of factors that all contribute to the behavior. As an example, let's say that you have a state that, when reached, causes your creature to flee its current location in search of health. You may want to do this in many cases. One example would be if there was a strong enemy nearby. Another would be if there was a mildly strong enemy nearby and the main character is low on health. You can probably conjure up a dozen other cases that would justify turning tail and fleeing. While it's possible to codify all of these cases separately into an NFA, it's rather tedious. It's better to have all of the input states (proximity of nearest enemy, strength of nearest enemy, health, ammo, etc.) become inputs into the neural network. Then you could just have an output node that, when fired, caused the creature to run for health. This way, the behavior emerges from the millions of different combinations for inputs. If enough factors contribute to the turn-and-flee state to make it fire, it will sum over the threshold and fire. A neural network that does this is exactly what I'm going to show you how to write.
Application: NeuralNet The NeuralNet sample application is a command-line application to show off a neural network simulator. The network is loaded off disk from a description file; input values for the network are requested from the user, then the network is run and the output appears on the console. I'll also build a sample network that simulates a simple creature AI. An example running of the network appears in Listing 6.9. In this example, the creature has low health, plenty of ammo, and an enemy nearby. The network decides to select the state [Flee_Enemy_ Towards_Health]. If this code were to be used in a game, state-setting functions would be called in lieu of printing out the names of the output states. Listing 6.9: Sample output of the neural net simulator
309
Advanced 3D Game Programming using DirectX 9.0 ----------------------------------------------
Neural Net Simulator
Using nn description file [creature.nn]
Neural Net Inputs: -----------------Ammo (0..1) 1 - Ammo (0..1) Proximity to enemy (0..1) 1 - Proximity to enemy (0..1) Health (0..1) 1 - Health (0..1)
Enter Inputs: ------------Enter floating point input for [Ammo (0..1)] 1.0
The NeuralNet description file (*.nn) details the network that the application will run. Each line that isn't a comment starts with a keyword describing the data contained in the line. The keywords appear in Table 6.2.
Table 6.2: Neural net description keywords NN_BEGIN
Defines the beginning of the neural network. Always the first line of the file. First token is the number of layers in the neural network. The input layer counts as one, and so does the output layer.
310
NN_END
Defines the ending of the neural network description.
NEURON
Declares a neuron. The first token is the name of the neuron, and the second is the bias of the neuron.
INPUT
Declares an input. The first token is the name of the neuron to receive the input, and the second token (enclosed in quotes) is the user-friendly name for the input. The list of inputs is iterated for user inputs prior to running the simulation.
DEFAULTOUT
The default output of the neural network. Only token is the text of the default output.
OUTPUT
Declares an output. The first token is the name of the neuron, the second is the text to print if the neuron fires, and the third is the bias of the neuron.
EDGE
Declares an edge. The first token is the name of the source node, the second token is the name of the destination node, and the third token is the floating-point weight of the edge.
The order in which the neurons appear in the file is pivotally important. They are appended to an STL vector as they are loaded in, and the vector is traversed when the network is run. Therefore, they should appear ordered in the file as they would appear left to right in the diagrams presented thus far (the input nodes at the beginning, the internal nodes in the middle, the output nodes at the end). Listing 6.10 shows the sample network description creature.nn. This is a simplistic creature AI that can attack, flee, and find items it needs. The network is simple enough that it's easy to see that adding more states wouldn't be too hard a task. It's important to note that this network is designed to have its inputs range from –1 to 1 (so having health input as 0 means the creature has about 50% health). Listing 6.10: creature.nn
# First line starts the NN loading and gives the # of layers. NN_BEGIN 2 #
311
# NEURONxyz # x = layer number # y = node name # z = node bias NEURON 0 health 0.0 NEURON 0 healthInv 0.0 NEURON 0 ammo 0.0 NEURON 0 ammoInv 0.0 NEURON 0 enemy 0.0 NEURON 0 enemyInv 0.0 NEURON 1 findHealth 0.2 NEURON 1 findAmmo 0.2 NEURON 1 attackEnemy 0.5 NEURON 1 fleeToHealth 0.5 NEURON 1 fleeToAmmo 0.5 # # DEFAULTOUT "string" # string = the default output DEFAULTOUT "Chill out" # #EDGE x y z # x = source neuron # y = dest neuron # z = edge weight # EDGE health attackEnemy 0.5 EDGE ammo attackEnemy 0.5 EDGE enemy attackEnemy 0.5 EDGE healthInv attackEnemy −0.5 EDGE ammoInv attackEnemy −0.5 EDGE enemyInv attackEnemy −0.6 #
312
EDGE healthInv findHealth 0.6 EDGE enemyInv findHealth 0.6 # EDGE ammoInv findAmmo 0.6 EDGE enemyInv findAmmo 0.6 # EDGE healthInv fleeToHealth 0.8 EDGE enemy fleeToHealth 0.5 # EDGE ammoInv fleeToAmmo 0.8 EDGE enemy fleeToAmmo 0.5 # # INPUT/OUTPUT x "y" # x = node for input/output # y = fancy name for the input/output INPUT health "Health (0..1)" INPUT healthInv "1 - Health (0..1)" INPUT ammo "Ammo (0..1)" INPUT ammoInv "1 - Ammo (0..1)" INPUT enemy "Proximity to enemy (0..1)" INPUT enemyInv "1 - Proximity to enemy (0..1)" OUTPUT findHealth "Find Health" OUTPUT findAmmo "Find Ammo" OUTPUT attackEnemy "Attack Nearest Enemy" OUTPUT fleeToHealth "Flee Enemy Towards Health" OUTPUT fleeToAmmo "Flee Enemy Towards Ammo" # NN_END
The source code for the neural network simulator appears in Listings 6.11 and 6.12.
313
Listing 6.11: NeuralNet.h
/******************************************************************* *
Advanced 3D Game Programming using DirectX 9.0
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
Desc: Sample AI code
* * copyright (c) 2002 by Peter A Walsh and Adrian Perez * See license.txt for modification and distribution information ******************************************************************/
#ifndef _NEURALNET_H #define _NEURALNET_H
#include <string> #include #include <map>
using namespace std;
#include "file.h"
class cNeuralNet { protected: class cNode; class cEdge;
public: string GetOutput();
314
void SendInput( const char* inputName, float amt );
void Load( cFile& file ); void Run(); void Clear(); cNeuralNet(); virtual ~cNeuralNet();
void ListInputs(); void GetInputs();
protected:
cNode* FindNode( const char* name );
class cNode { public: void Init( const char* name, float weight );
void Clear(); virtual void Run(); void AddOutEdge( cNode* target, float edgeWeight ); void SendInput( float in );
const char* GetName() const; float GetTotal() const; protected:
// Computes the output function given the total. virtual float CalcOutput();
315
string m_name; float m_weight; // initial bias in either direction float m_total; // total of the summed inputs vector< cEdge > m_outEdges;
};
class cEdge { cNode* m_pSrc; cNode* m_pDest; float m_weight; public:
cEdge( cNode* pSrc, cNode* pDst, float weight );
void Fire( float amount ); }; friend class cNode;
vector< vector< cNode* > > m_nodes;
// maps the names of output nodes to output strings. map< string, string > m_inputs; map< string, string > m_outputs;
string m_defaultOutput; };
inline const char* cNeuralNet::cNode::GetName() const {
316
return m_name.c_str(); }
inline float cNeuralNet::cNode::GetTotal() const { return m_total; }
#endif // _NEURALNET_H
Listing 6.12: NeuralNet.cpp
/******************************************************************* *
Advanced 3D Game Programming using DirectX 9.0
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
Desc: Sample AI code
* * copyright (c) 2002 by Peter A Walsh and Adrian Perez * See license.txt for modification and distribution information ******************************************************************/
using namespace std;
int main(int argc, char* argv[]) { // Sorry, I don't do cout. printf( "Advanced 3D Game Programming using DirectX 9.0\n" ); printf( "----------------------------------------------\n\n" ); printf( "Neural Net Simulator\n\n");
317
if( argc != 2 ) { printf("Usage: neuralnet filename.nn\n"); return 0; }
printf("Using nn description file [%s]\n\n", argv[1] );
cNeuralNet nn; cFile nnFile; nnFile.Open( argv[1] ); nn.Load( nnFile ); nnFile.Close();
int done = 0; while( !done ) { // Clear the totals nn.Clear();
// List the inputs for the net from the user nn.ListInputs();
// Get the inputs for the net from the user nn.GetInputs();
// Run the net nn.Run();
// Get the net's output. string output = nn.GetOutput();
318
printf("\nNeural Net output was [%s]\n", output.c_str() ); printf("\nRun Again? (y/n)\n"); char buff[80]; gets( buff );
if( !(buff[0] == 'y' || buff[0] == 'Y') ) { done = 1; } } return 0; }
cNeuralNet::cNeuralNet() { // no work needs to be done. }
cNeuralNet::~cNeuralNet() { // delete all of the nodes; each node will get its outgoing edges int numLayers = m_nodes.size(); for( int i=0; i
