OpenGL游戏开发：Chris Seddon著

需积分: 3 82 浏览量更新于2024-08-02 收藏 4.44MB PDF 举报

"Wordware - OpenGL Game Development (2005) 是一本由Chris Seddon编写的关于使用OpenGL进行游戏开发的专业书籍。该书详细介绍了如何利用OpenGL这一强大的图形库来构建3D游戏。" 在计算机游戏编程领域，OpenGL是一个至关重要的工具，它是一个跨语言、跨平台的应用程序编程接口（API），专门用于生成2D和3D图像。OpenGL Game Development这本书旨在教导读者如何利用OpenGL的特性来创建动态和交互式的图形环境，特别关注于游戏开发。作者Chris Seddon通过这本书向读者传授了关于OpenGL的基础知识，包括但不限于顶点坐标系统、颜色、光照、纹理映射、深度缓冲以及视口和投影矩阵的设置。此外，书中可能还涵盖了高级主题，如着色器语言（GLSL）的使用，允许开发者编写自定义的顶点和片段着色器以实现更复杂的视觉效果。书中的内容可能还包括对3D模型的导入和处理，例如从3D建模软件（如Adobe Photoshop或3D Studio Max）导出的文件格式。此外，对于游戏性能优化，作者可能会讨论使用硬件加速技术，如3DNow! Technology（AMD的处理器扩展）来提升渲染速度。游戏开发不仅涉及图形技术，还需要了解如何与用户交互，因此，书中可能也讲解了如何利用输入设备（如键盘、鼠标）以及游戏控制器来处理用户输入。同时，考虑到多平台兼容性，可能会涵盖在不同的操作系统（如Windows、Linux）上部署OpenGL应用的技巧。书中的示例代码和项目可能基于DirectX和其他微软的技术，因为这些技术在2005年时是游戏开发的标准部分。DirectX是由微软提供的一个API集合，用于多媒体应用，包括游戏，它提供了音频、视频和图形的处理能力。此外，书中提及的Quake和Super Mario Bros是两个著名的游戏品牌，这可能意味着书中的实例或练习会引用这些经典游戏，帮助读者理解如何用OpenGL重制或创建类似的游戏体验。《OpenGL Game Development》是一本深入浅出的教程，适合那些希望掌握3D游戏编程技能，特别是通过OpenGL实现游戏世界的开发者。它不仅教导基本的图形编程概念，还涉及高级技术，为读者提供全面的游戏开发知识。

Chapter 1

Introducing Windows

Programming

In Chapter 1, we will learn about event-driven programming and how it

differs from conventional programming, the basic structure of a Windows

program, how to add buttons and menus, how to add functionality to but

tons, what resources are and how to use them, and finally, how to use

common controls in dialog boxes.

By the end of the chapter, the beginning structure for our map editor will

take shape and you will have the knowledge to write basic Windows

applications.

Concepts of Event-Driven Programming

Event-driven programming is a simple but powerful concept. When some-

thing is done, the computer will send an event to the handler, which will

process the event and do the actions associated with it. In Windows pro

gramming, event-driven programming is used to create graphical user

interfaces (GUIs) without the painstaking work of polling for every possible

click, press, and move the program allows. Instead, the software will auto

matically send a message saying, “Event X has happened.” A simple

example is where the developer has a button that will play a sound when

pressed. In some cases, the software specifications may require that the

developer continuously check if the button is pressed; however, when pro

gramming with events, the software could automatically send an event

message to the message handler saying, “Button X is down,” in which case

the sound would be played.

Unfortunately, the Windows operating system has more than just a

ButtonDown event. In a typical Windows program you could use dozens of

different events to create the perfect application or game. Almost every cor

ner of the Win32 graphical user interface has been covered with message

events, from program activation and keypresses to program display painting

and background timers. And just when you thought there wasn’t a specified

convention to the Windows API. The default parameters are very different.

There are now four parameters: two of the HINSTANCE type, an LPSTR,

and an int. With many Win32 variables you’ll notice an H in the front of the

name. For instance, the HINSTANCE type is a handle of an instance. An

instance is the program itself. For the first two parameters we use the

HINSTANCE type with the names hInstance and hPrevious, respectively.

The hInstance is the instance of the current program running, and the

hPrevious in 32-bit applications is always NULL. The third parameter is of

the LPSTR type. The LPSTR type is a pointer to a null-terminated string of

8-bit characters. The variable passes program arguments when started. This

is similar to the argv variable in regular C programs, with the exception that

it does not include the program name. The final parameter defines how the

program should be displayed when started.

The following code snippet displays the main entry point for Windows

applications.

int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevious, LPSTR lpCmdString,

int CmdShow)

Now that we have a main, we’re almost ready to start building a Windows

application. But first, we must discuss which headers to include. Rather than

including the standard I/O (stdio.h) and standard library (stdlib.h), we need

to include the Windows header (windows.h). This header includes links to

all relevant headers to compile a basic Windows program. With that in mind,

let’s create a new Windows application and use the code snippet from above

to begin programming. The following code snippet shows the main entry

point for a Windows program.

#include <windows.h>

int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevious, LPSTR lpCmdString,

int CmdShow)

{

return (1);

}

This code will compile in Visual C++; however, we are far from creating a

fully functional Windows application. Before creating a fully functional

Windows program, we must register a window class, which defines the

attributes of the window.

Registering a Window Class

The window class contains details such as the class name, menus, the call

back for messages, and several other pieces of data. To declare a window

class, we use the WNDCLASS type. A typical window class would look

like the following.

Introducing Windows Programming | 5

Creating the Map Editor

WNDCLASS wc;

wc.cbClsExtra = 0;

wc.cbWndExtra = 0;

wc.hbrBackground = (HBRUSH)GetStockObject(LTGRAY_BRUSH);

wc.hCursor = LoadCursor (NULL, IDC_ARROW);

wc.hIcon = LoadIcon (NULL, IDI_APPLICATION);

wc.hInstance = hInstance;

wc.lpfnWndProc = WndProc;

wc.lpszClassName = "ME";

wc.lpszMenuName = NULL;

wc.style = CS_OWNDC | CS_HREDRAW | CS_VREDRAW;

Starting from the top, we set the variable cbClsExtra to 0 because we do not

want to allocate extra bytes of memory beyond the WNDCLASS size. The

cbWndExtra variable is set to 0 because we do not need extra memory allo

cated for the window instance. The hbrBackground variable sets the

background color for the window. We use the function GetStockObject to

retrieve a predefined stock brush, which in this case was light gray, and cast

it as an HBRUSH type. The HBRUSH is a handle to a brush object. Rather

than using LTGRAY_BRUSH, we could have used one of the following

colors:

Dark gray (DKGRAY_BRUSH)

Black (BLACK_BRUSH)

White (WHITE_BRUSH)

However, light gray is one of the routine background colors, so let’s stick to

the basics.

The hCursor variable sets the default cursor for the window. In our case

we load a default cursor using the function LoadCursor. This function

requires two parameters, the first being the current instance, which should be

NULL, and the second being the resource ID of the cursor, which in this

case is IDC_ARROW. The hIcon variable sets the default icon for the appli

cation. To set this variable we must use the function LoadIcon, which returns

the handle of an icon. The first parameter for the LoadIcon function is the

current program instance, which is NULL. The second parameter is the

resource ID of the icon, which is IDI_APPLICATION. In both the LoadIcon

and LoadCursor functions, the first parameter is of the HINSTANCE type.

We set this first parameter as NULL to indicate we want to use the standard

Windows icons/cursors rather than specifying custom resources. The

hInstance variable requires the handle of this instance, which is the

hInstance from our WinMain.

The lpfnWndProc variable is the pointer to the window procedure, which

is our message handler. As discussed before, our message handler will pro

cess any messages sent by the system. The lpszClassName variable is the

name of the window class, which in our case is ME, short for Map Editor.

Later, when we are going to create a window, we will need to reuse this

6 | Chapter 1

Part I

name, so it is a good idea to keep it simple. The next variable, lpszMenu

Name, controls the menu that is to be loaded for the window class. We do

not need this parameter, so we can set it to NULL. And finally, the last vari

able in the WNDCLASS structure we must fill in indicates the style of the

window class. A wide variety of options can be used for the style. I’ve cho

sen the basic values of CS_HREDRAW and CS_VREDRAW, which will

redraw the screen when the width or height of the client window has been

changed, and I’ve also requested CS_OWNDC, which gives each registered

class a unique device context.

Now that all the fields in the WNDCLASS structure are filled in, it is

time to register a new window class by calling the function RegisterClass

and passing the wc variable we just filled in. If the registration of the class is

successful, a non-zero number will be returned. If the function fails, 0 will

be returned. With this in mind, the next piece of source code attempts to reg

ister a window class and displays an error message if it fails.

if (!RegisterClass(&wc))

{

MessageBox (NULL,"Error: Cannot Register Class", "ERROR!", MB_OK);

return (0);

}

As you can see, registering the window class is fairly simple. To display the

error message, I simply used the MessageBox function to display a basic

error message. The MessageBox function requires four parameters: a handle

to a window (HWND), two null-terminated strings of the LPCTSTR type,

which include the main message and the caption text respectively, and an int

for the type. We don’t need any elaborate message boxes for the time being,

so a basic MB_OK or OK button message box will suit our current needs.

Creating a Window

After registering the window class we must create a window on the screen

using the CreateWindow function. There are 11 simple parameters in this

function, the first being the LPCTSTR lpClassName, which as the parameter

name suggests is our class name, "ME". The second parameter is another

LPCTSTR called lpWindowName, which is a string identifying the name of

the window in the title bar. For this parameter we will use the value "Map

Editor". After the lpWindowName parameter, we set the style of the window

using DWORD styles. There are many options to choose from when setting

the style of the window; we will use the default options WS_OVER-

LAPPEDWINDOW and WS_VISIBLE for simplicity’s sake. The

WS_OVERLAPPEDWINDOW style creates a window with a title bar and

Minimize and Maximize buttons. The WS_VISIBLE style allows the win

dow to be visible upon creation. The next two parameters are of the int type

and identify the starting X and Y coordinates for the window. After the

Introducing Windows Programming | 7

Creating the Map Editor

剩余496页未读，继续阅读

archimedes_zht

粉丝: 105
资源: 171

OpenGL游戏开发：Chris Seddon著

Wordware,.OpenGL.Game.Development.

Wordware - Strategy Game Programming with DirectX 9.0

OpenGL Game Development

Wordware.Publishing.Learn.Microsoft.Excel.2002.VBA.Programming.With.XML.And.ASP.eBook-LiB.pdf

wordware publishing - lightwave 3d 8. 1001 tips & tricks.zip

Wordware.Publishing.Vector.Game.Math.Processors

Wordware.Introduction.to.3D.Game.Programming.with.DirectX.10.Oct.2008

Wordware.Publishing.32.64-BIT.80x86.Assembly.Language.Architecture.chm

Introduction.to.3D.Game.Programming.with.DirectX.9.pdf

C++.Advanced.3D.Game.Programming.with.DirectX.9.0[www.TopSage.com].pdf

最新资源