OpenGL游戏开发：Chris Seddon著

需积分: 9 24 浏览量更新于2024-07-29 收藏 5.97MB PDF 举报

"OpenGL Game Development (2005) 是一本由Chris Seddon编写的书籍，专注于使用OpenGL进行游戏开发。这本书由Wordware Publishing, Inc.出版，旨在教授读者如何利用OpenGL这一强大的图形库来创建计算机游戏。书中可能涵盖了基础的计算机图形学概念、OpenGL编程接口、游戏引擎设计以及与游戏开发相关的高级技术。该书适用于希望深入理解3D游戏开发的C++程序员。" OpenGL是开源的图形库，广泛用于创建高性能的2D和3D图形，尤其在科学可视化、工程设计和游戏开发等领域。它提供了一组低级的绘图函数，让开发者能够直接控制硬件，从而实现高效渲染。在本书中，作者Chris Seddon可能会讲解如何设置OpenGL环境，如何绘制基本几何形状，以及如何处理颜色、光照、纹理等图形效果。游戏开发是一个复杂的过程，涉及到多个方面，如物理模拟、人工智能、用户界面、音频处理等。OpenGL Game Development可能会介绍如何构建游戏框架，包括窗口系统、输入处理和时间管理。此外，还可能探讨了如何利用OpenGL加速3D图形渲染，以及如何与DirectX等其他平台API进行交互，以实现跨平台的游戏开发。 3DNow! Technology是AMD公司的商标，可能在书中提及与GPU优化相关的内容。Adobe Photoshop是图像编辑的行业标准，可能在讨论纹理制作和图像预处理时被引用。而DirectX是微软的多媒体应用程序接口，通常与游戏开发密切相关，特别是在Windows平台上。此书的出版年份为2005年，因此可能主要关注当时的OpenGL版本和技术，但基本概念和技术原理依然对现代游戏开发具有指导价值。对于想要进入游戏开发领域的C++程序员，理解和掌握OpenGL仍然是一个重要的学习步骤，尽管今天的开发环境中可能已经出现了许多高级的图形库和框架，如Unity和Unreal Engine。然而，这些基础知识将帮助开发者更好地理解底层工作原理，从而提升他们的编程技能和问题解决能力。

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页未读，继续阅读

meichen8050753

粉丝: 28
资源: 31

OpenGL游戏开发：Chris Seddon著

Wordware - OpenGL Game Development (2005) YYePG OCR 7.0-2.6 LotB.pdf

OpenGL开发源码，vs2005平台下的，自己写的，很好懂，初学者使用

OpenGL ES Game Development.pdf

Wordware,.OpenGL.Game.Development.

OpenGL游戏开发：Chris Seddon著

TeAM YYePG已停用，导致wintarget无法正常使用

SpringBoot 20道面试题和答案（2025最新版）.docx

【电力负荷预测】基于matlab灰狼算法优化长短时记忆网络GWO-LSTM电力负荷预测【含Matlab源码 1518期】.zip

SpringBoot-548大学生社团活动平台.zip

线程111111111111111

最新资源