Transcript Document

3D Game
Programming
王銓彰
[email protected]
2005
1
課程大綱















Introduction to Game Development (3hr)
Game System Analysis (3hr)
The Game Main Loop (3hr)
3D Game Engine Training (Using TheFly3D) (6hr)
Game Mathematics & Geometry (3hr)
Terrain (3hr)
Character Motion (3hr)
Game Control System (3hr)
Advanced Scene Management System (3hr)
Game AI (6hr)
Game Physics (3hr)
Game FX (3hr)
Network Gaming (3hr)
MMOG (3hr)
Summary

Wang’s Method for Real-time 3D Game Development
2
課程要求

One term project





The students are in teams.
Use TheFly3D 3D engine to code a Real-time 3D Game.
 Action RPG
The teacher will provide graphics materials and setup the game
design.
Final examination
Homework will be closely coupled with the term project.
3
王銓彰 (1/3)

目前




學歷


數位內容學院 專任講師 / 顧問
宇峻奧汀 顧問
鈊象電子 3D技術顧問
台灣大學土木工程學系畢業
資歷






04-04 資策會網路多媒體研究所 專案顧問
97-04 昱泉國際股份有限公司 技術長
96-96 虛擬實境電腦動畫股份有限公司 研發經理
93-96 西基電腦動畫股份有限公司 研發經理
90-93 國家高速電腦中心 助理研究員
89-90 台灣大學土木工程學系 CAE Lab 研究助理
4
王銓彰 (2/3)

Game作品



Current
 TheFly3D 3D Engine
昱泉國際
 DragonFly 3D Game Engine
 M2神甲奇兵, VRLobby, 天劍記
 Lizard 3D Game Engine
 幻影特攻、笑傲江湖 I & II、神鵰俠侶 I & II、風雲、小李飛刀、
笑傲江湖網路版、怪獸總動員、聖劍大陸、笑傲外傳
西基電腦動畫
 Ultimate Fighter
 1st real-time 3D fighting game in Taiwan
5
王銓彰 (3/3)

專長 (Expertise)








3D Computer Graphics
Geometric Modeling
Numerical Methods
Character Animation
Photo-realistic Rendering
Real-time Shading
Volume Rendering
應用領域 (Applications)





即時3D遊戲開發 (Real-time 3D Game Development)
電腦動畫 (Computer Animation)
虛擬實境 (Virtual Reality)
電腦輔助設計 (Computer-aided Design, CAD)
科學視算 (Scientific Visualization)
6
1st
Introduction to
Game Development
7
Introduction to Game Development






Game
Game
Game
Game
Game
Tools
platform
types
team
development pipeline
software system
8
Game Platform

PC





Console





Single player
Match Makings
MMOG (Massive Multi-player Online Game)
Web-based Games
Sony PS2
MS Xbox
Nintendo GameCube
Arcade
Mobile




Nintendo GBA
Nintendo DS
Sony PSP
Hand-held
9
Game Development on PC



PC is designed for general office application.
Not for entertainment purpose
A virtual memory system


But video memory is limited.






For frame buffers, z buffers, textures, vertices, …
PCI / AGP might be a problem for performance.
Open architecture


Unlimited system memory
Hardware driver version issue
Different capabilities
Different performance
Compatibility test is very important.
Development is easy to setup.

Visual C/C++ with DirectX
10
Game Development for Consoles






Specific hardware designed for games
Single user OS
Single process OS
No hard disk drive (?)
Closed system
Native coding environment




Limited resources



Proprietary SDK
Hardware related features
C language with assembly
Memory for everything
 32M for PS2
 64M for Xbox
One console runs, the others do !
Use gamepad and no keyboard
11
Game Types











RPG (Role playing games)
AVG (Adventure games)
RTS (Real-time strategy games)
FPS (First-person shooting games)
RSLG (戰棋)
STG
Sports
Action
Puzzle games
Table games
MMORPG

Massive Multiple Player Online Role Playing Games
12
Game Team Members

開發團隊






行銷業務團隊



產品經理(PM)
測試團隊
遊戲審議委員會


製作人
執行製作人
企劃團隊
程式團隊
美術團隊
Game project approval
遊戲經營團隊



線上遊戲 game master (GM)
Customer services
MIS
13
Game Producer 遊戲製作人







Team leader (usually)
資源管理 (Resource management)
行政管理 (Administration)
專案管理 (Project management)
向上負責 (Upward management)
團隊的決策
風險管理
14
遊戲執行製作人


專案管理執行
Daily 運作





House keeping
Meeting coordinator
Schedule checking
Cross-domain communication
Usually not a full-time job position

A position for training and becoming a producer
15
遊戲企劃 (1/2)













故事設計 (Story telling)
腳本設計 (Scripting)
玩法設計 (Game play design)
角色設計(Character design)
動作設計(Animation design)
關卡設計 (Level design)
特效設計(Effect design)
物件設計
介面設計(User Interface design)
遊戲調適 (Game tuning)
數值設定 (Numerical setup)
AI 設計 (Game AI design)
音效設定 (Sound FX setup)
16
遊戲企劃 (2/2)



場景設定 (Scene setup)
Game document writing
Game quality checking
17
遊戲美術

Visual setup for game design



2D setup
3D setup
Graphics design and production








場景 (Terrain)
人物 (Character)
建模 (Models)
材質 (Textures)
動作 (Motion / Animation)
特效 (FX)
User Interface
行銷支援 (封面.海報..等)
18
遊戲程式


遊戲程式 (Game Program) 撰寫
遊戲開發工具 (Game Tools) 開發






遊戲Data exporters from 3D animation Software




Level editor
Scene editor
FX editor
Script editor
Game editor
3dsMax / Maya / Softimage
Game engine development
Game technique research
Online game server development
19
遊戲開發流程
Basic Procedures for Game Development
Idea
Proposal
Concept
Approval





Production
Prototype
發想 (Idea)
提案 (Proposal)
製作 (Production)
整合 (Integration)
測試 (Testing)
 除錯 (Debug)
 調適 (Tuning)
Integration
Pre-alpha
Testing
Debug
Alpha
Tuning
Beta
Final
> Concept approval
> 雛形 (prototype)
> Pre-alpha
> Alpha
> Beta
20
遊戲發想(Concept Design)






遊戲類型 (Game types)
遊戲世界觀 (Game world)
故事 (Story)
遊戲特色 (Features)
遊戲玩法 (Game play)
遊戲定位 (Game product positioning)




競爭對手評估
風險評估 (Risk)


Target player
Marketing segmentation / positioning
SWOT (Strength/Weakness/Opportunity/Threat) 分析
產出物

Concept Design Document (CDD)
21
遊戲提案(Proposal)





系統分析 (System analysis)
GDD 撰寫 (Game design document)
MDD 撰寫 (Media design document)
TDD 撰寫 (Technical design document)
遊戲專案建立 (Game project)






Schedule
Milestones / Check points
Risk management
測試計畫書
團隊建立 (Team building)
產出物




GDD
MDD
TDD
The Team
22
遊戲開發(Production)

美術量產製作








Modeling
Textures
Animation
Motion
FX
量產 !
程式開發 (Coding)
企劃數值設定
…
23
遊戲整合(Integration)







關卡串聯 (Level integration)
數值調整 (Number tuning)
音效置入 (Audio)
完成所有美術
程式與美術結合
Testing within the game team
Focus group (User study)



Release some playable levels for focus group.
Get the feedback from focus group to adjust the game play.
Invited outside game players but evaluation in-house
24
遊戲測試(Test)

Alpha 測試



Beta 測試




除錯 (Debug)
Make the game stable
數值微調
Game play 微調
對線上遊戲而言 (MMOG)
 封閉測試 (Closed beta)
 Invited game players
 開放測試 (Open beta)
 Free for public players
極限測試 (Critical testing)



Only for MMOG
Continuously implementing
For servers
25
Bugs

Bug 分級 (Bug Classification)





A Bug
B Bug
C Bug
S Bug
Bug
Bug Classification
Principles


Bug 分級從嚴
Tester vs Debugger
Bug Dispatch
Debug
N
?
Verify
Y
FAQ
26
Game Software System
Game
NPC System
Virtual Agent
Fighting System
Terrain
Trading System
FX System
Game AI
Collision Character Dynamics
3D Scene Mngmt
3D Graphics API
2D Sprite
Gamepad
2D API
Hardware
Story
Script System
Sound FX
Audio
Input Device
UI
Network
OS API
Game Play
Layer
Engine
Layer
System
Layer
27
System Layer – APIs (1/2)

3D Graphics API



2D API



DirectX 9.0 SDK - DirectMedia
Win32 GDI
Input device


DirectX 9.0 SDK – Direct3D
 Newest update : DirectX 9.0c SDK Update (June, 2005)
OpenGL
 2.0
DirectX 9.0 SDK – DirectInput
Audio


DirectX 9.0 SDK – DirectSound / Direct3DSound / DirectMedia
OpenAL
28
System Layer – APIs (2/2)

OS API



Win32 SDK
MFC
Network


DirectX 9.0 SDK – DirectPlay
Socket library
29
Engine Layer (1/2)

3D scene management system










Scene graph
Shaders
2D sprite system
Audio system
Gamepad
Hotkeys
Mouse
Timers
Network
DDK interface
30
Engine Layer (2/2)


Terrain system
Advanced scene management system



Character system






Bone-skin
Motion Blending
Dynamics


Space partition technique
 BSP Tree
Octree
Particle system
Rigid-body dynamics
Collision detection
Sound FX
User interface
31
Game Play Layer


NPC (Non-playable characters) management
Game AI










Path finding
Finite state machine (FSM)
Steering behavior
Avatar
Combat system
FX system
Script system
Trading system
Number system
…
32
Game Development Tools for Programming (1/2)

System Tools




Visual C/C++
 .Net 2003
 VC/C++ 7.1
 Visual C/C++ 6.0 + SP5
NuMega BoundsChecker
 Finding memory leaking
Intel vTune
 Finding computation performance bottlenecks
 for CPU
PIX
 Finding graphics performance bottlenecks
 For GPU
33
Game Development Tools for Programming (2/2)

SDKs



System API
 Win32 SDK or MFC
 DirectX SDK or OpenGL
 Socket library
Middleware (Game engine)
 Renderware
 Unreal
 …
Physics
 ODE
34
Game Development Tools for Artists

3D tools




2D tools



Discrete 3dsMax
Maya
Softimage XSI
Photoshop
Illustrator
Motion tools



Motion capture devices
Motion Builder
FiLMBOX
35
2nd
Game System Analysis
36
What Will We Talk



The idea about system analysis (SA)
Mind mapping
Case study - Term project
37
Why System Analysis (1/2)

For 程式結構 analysis



To identify 工作量




New game engine ?
Re-used code ?
Tools needed to be developed ?
For 資源 management




The main program
Game development tools
Total man month
How many programmers ?
How good the programmers ?
For job dependency analysis
Job A
Job B
Job D
Job C
38
Why System Analysis (2/2)

To do technical possibility analysis




Pre-processor for



技術可行性分析
R&D ?
Where is the technical bottleneck ?
Technical design document
Project management
Bridge from game design to programming
39
Something about System Analysis


No standard procedures or approaches
It’s not a theory.


Experience
You can use your own method/tool



UML
Mind mapping

心智圖法

This is the one we will use in this course
…
40
Wang’s System Analysis Steps





Brainstorming
Integration
Dependency analysis
Create the project
Technical design document (TDD) writing
41
Brainstorming



Based on the game design to put everything as many as
you could
Use mind mapping
Including




Game system
 Combat / Village / Puzzle / …
Program modulus
 Camera / PC control / NPC AI / UI / FX /…
Tools
 Level editor / Scene editor / …
Entities in games
 Characters / vehicle / terrain / audio / …
42
Integration




Confirm the resource limitation
Technical implement possibility
Put all related items together
Man month analysis



How many ?
Who ?
Jobs / System identification
43
Dependency Analysis

Sort the Jobs



By job dependency
By programmers’ schedule
Prototype for scheduling
44
System Analysis – Create the Project





Scheduling
Job assignment
Resource allocation
Check points
Milestones



Major check points
Output
Risk management


Alternatives
Risk management policy
45
Technical Design Document









Specification
Resources
Design in details
Implement methods (工法)
Algorithms
“Project”
Output in each milestone
SOP (optional)
TDD Template
46
Mind Map



心智圖法
A radiant thinking tool
Applications







讀書心得
Proposal
上課筆記
遊記
System Analysis
…
Reference


Programs
 Visio
 MindManager
Books
 Tony Buzan, Barry Buzan
 “The Mind Map Book: How to Use Radiant Thinking to
Maximize Your Brain's Untapped Potential”
47
48
49
Mind Map Demo Using MindManager


Use MindManager X5 pro
Developed by MindJet
50
3rd
The Game Main Loop
51
Win32 Application (1/3)
int APIENTRY WinMain(HINSTANCE hInst, HINSTANCE hPrevInst, LPSTR lpCmdLine, int nCmdShow)
{
WNDCLASSEX wc;
...
// register window class
ZeroMemory(&wc, sizeof(WNDCLASSEX));
wc.style
= CS_OWNDC | CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS;
wc.lpfnWndProc = KKMainProc;
...
RegisterClassEx(&wc);
...
// the main loop
KKMainLoop();
// unregister the window class
UnregisterClass(wc.lpszClassName, hInst);
return id;
}
52
Win32 Application (2/3)
LRESULT CALLBACK KKMainProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
LRESULT l = FALSE;
...
// switch for all incoming messages from WindowsXX
switch (uMsg) {
case WM_KEYDOWN:
...
l = TRUE;
break;
...
}
// echo the result
if (l) {
return l;
}
else {
return DefWindowProc(hWnd, uMsg, wParam, lParam);
}
}
53
Win32 Application (3/3)
void KKMainLoop()
{
MSG msg;
BOOL kkBeQuit = FALSE;
// the main loop
while (!kkBeQuit) {
// check window's messages
while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
if (msg.message == WM_QUIT) {
kkBeQuit = TRUE;
}
// invoke the WindowsX to handle the incoming messages
TranslateMessage(&msg);
DispatchMessage(&msg);
}
// do your jobs here, for example, check the timing and do something in regular
...
}
}
54
Event-driven Programming

Win32 programs are event-driven




We need an infinitive loop to check all incoming events.
In the loop :




Messages = events
So as all windows system (for example : X window)
Check if there are incoming events (messages)
Handle the events
Check the time and do something in regular
Incoming events :


Interrupts
System requests
55
Timers & Events (1/2)

Timers (do something in regular timing)




The sub-system to handle timing
Must be precise to at least 1 ms or less
 30fps = 1/30 second = 33.333… ms
On win32 platform, you can use “performance counter” instead of
the win32’s “WM_TIMER” message
 For windows9x, WM_TIMER = 18.2 fps (maximum)
Events



Input devices
 Mouse
 Keyboard
Something coming from network
System requests
 Re-draw
 Losing/getting the input focus
 …
56
Timers & Events (2/2)

Two types of jobs (Callbacks) to do (Call) :



In regular
 Timers callbacks
By requests
 Input device callbacks
So as the game main program


A game is an interactive application.
 Mouse
 Hotkeys
 Gamepads
A game is time-bound.
 Rendering locked in 30fps or 60fps
 Motion data produced in 30fps
 Game running in 30fps
57
Implement the Timer (1/6)

On PC platform : use “Performance Counter”


QueryPerformanceFrequency()
QueryPerformanceCounter()
// timers data structure
typedef struct {
BOOL beAble;
// is the timer is enabled/disabled ?
BOOL be1st;
// is this the 1st time for the timer to be checked
// after last initialization ?
BOOL beLockFps; // is locked on FPS ?
double initTime; // initial time
double timeInv;
// system ticks for one frame
double nxtTime; // next checking time
void (*timer)(int); // timer's callback
double resetTime; // reset time
} TIMERs, *TIMERptr;
58
Implement the Timer (2/6)
/*---------------------------------------------------------------------initialize a timer and bind a user-defined timer callback
------------------------------------------------------------------------*/
void FyBindTimer(DWORD id, float fps, void (*fun)(int), BOOL beLock)
{
if (id < 0 || id >= MAXTIMERS) return;
/* assign the timer's callback */
fyTimer[id].timer = fun;
/* set lock-to-fps flag */
fyTimer[id].beLockFps = beLock;
/* calculate the ticks for one frame */
fyTimer[id].timeInv = (double) (fyFreq) / (double) fps;
fyTimer[id].be1st = TRUE;
fyTimer[id].beAble = TRUE;
}
59
Implement the Timer (3/6)
/*-----------------------------------get current system clock tick
--------------------------------------*/
double FYGetCurrentSystemTick()
{
LARGE_INTEGER timeCount;
/* get current tick */
QueryPerformanceCounter(&timeCount);
return (double) timeCount.QuadPart;
}
/*
// get the system ticks for one second
QueryPerformanceFrequency(&timeFreq);
fyFreq = timeFreq.LowPart;
*/
60
Implement the Timer (4/6)
/*-----------------------------------------------------------invoke the TheFly3D system to handle the timers
--------------------------------------------------------------*/
void FyInvokeTheFly(BOOL beTimer)
{
MSG msg;
if (fyBeQuit) return;
while (!fyBeQuit) {
// check window's messages
while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
if (msg.message == WM_QUIT) fyBeQuit = TRUE;
TranslateMessage(&msg);
DispatchMessage(&msg);
}
// check the timer
if (beTimer && fyBeTimer) FYInvokeTimer();
}
}
61
Implement the Timer (5/6)
/*--------------------check all timers
----------------------*/
void FYInvokeTimer()
{
int i, skipS;
double dTime;
// get current time
dTime = FYGetCurrentSystemTick();
for (i = 0; i < MAXTIMERS; i++) {
if (fyTimer[i].beAble && fyTimer[i].timer != NULL) {
// for the first time .....
if (fyTimer[i].be1st) {
// initialize the timer
fyTimer[i].be1st = FALSE;
fyTimer[i].initTime = dTime;
fyTimer[i].nxtTime = dTime + fyTimer[i].timeInv;
(*(fyTimer[i].timer))(1);
}
62
Implement the Timer (6/6)
else {
if (fyTimer[i].beLockFps) {
if (dTime >= fyTimer[i].nxtTime) {
// calculate skip frames
skipS = (int)((dTime - fyTimer[i].nxtTime) / (double)fyTimer[i].timeInv) + 1;
// get next checking time
fyTimer[i].nxtTime += (double) (skipS * fyTimer[i].timeInv);
// check some abnormal conditions
...
// invoke the timer callback
(*(fyTimer[i].timer))(skipS);
}
}
else {
(*(fyTimer[i].timer))(1);
}
}
}
}
}
63
Game Loop (1/2)

Single player
Loop
Check game over
y
Exit the loop
n
Peek player input
Implement
timer callback
Rendering
64
Game Loop (2/2)

Network client
Loop
y
Check game over
Exit
n
Peek user input
Receive messages
From network
Timer callbacks
Send messages
To network
Rendering
65
Jobs in Regular (In Timers)





Check “Win/Lose”
Check “Quit”
Make objects moving …
Play character’s motion to the next frame
Play animation to the next frame










Models
Textures
…
Perform game logic calculation
Perform geometry associated calculation
 i.e. LOD
Perform AI “Thinking”
Perform collision detection
Perform the 3D rendering
Play FX
…
66
Jobs By Request

Mouse Input





Keyboard Input






Hotkey
Typing
Gamepad


Press/release the mouse button
Drag
Double-click
Move
Same behavior as the hotkey
Except looking not like the keyboard
Network
System
…
67
4th
TheFly3D Game Engine
68
The Main Program
void main(int argc, char **argv)
{
// create the game world & 3D scene
...
// set Hotkeys
FyDefineHotKey(FY_ESCAPE, QuitGame, FALSE);
...
// define some mouse functions
FyBindMouseFunction(LEFT_MOUSE, InitPivot, PivotCam, EndPivot, NULL);
...
// bind a timer for rendering, frame rate = 60 fps
FyBindTimer(0, 60.0f, RenderIt, TRUE);
// bind a timer for game AI, frame rate = 30 fps
FyBindTimer(1, 30.0f, GameAI, TRUE);
// invoke the system
FyInvokeTheFly(TRUE);
}
69
Hotkey Callback
//------------------// quit the game
//------------------void QuitGame(WORLDid gID, BYTE code, BOOL value)
{
if (code == FY_ESCAPE) {
if (value) {
FyWin32EndWorld(gID);
}
}
}
70
Mouse Callback
/*----------------------------------------initialize the pivot of the camera
------------------------------------------*/
void InitPivot(WORLDid g, int x, int y)
{
oldX = x;
oldY = y;
}
/*-----------------pivot the camera
-------------------*/
void PivotCam(WORLDid g, int x, int y)
{
FnModel model;
if (x != oldX) {
model.Object(cID);
model.Rotate(Z_AXIS, (float) (x - oldX), GLOBAL);
oldX = x;
}
if (y != oldY) {
model.Object(cID);
model.Rotate(X_AXIS, (float) (y - oldY), GLOBAL);
oldY = y;
}
}
71
The Timer Callback
//---------------------------------------------------------------------------------------// Render callback which will be invoked by TheFly3D every 1/60 second
//---------------------------------------------------------------------------------------void RenderIt(int skip)
{
FnViewport vp;
FnWorld gw;
// render the scene
vp.Object(vID);
vp.Render(cID, TRUE, TRUE);
// perform double-buffering
gw.Object(gID);
gw.SwapBuffers();
}
72
Introduction to TheFly3D

A real-time 3D graphics programming library


Using C++
Cross-platform




An API for 3D graphics developers
Provide a fundamental scene management system



Scene tree
Built-in visibility culling
According to the experiences from the author, some game
development features are added.




DirectX9.0c
OpenGL 1.5
Characters
Terrain system
…
Current version 0.8a1 (0920, 2005)

Shader has been added in D3D version
73
TheFly3D in A Chart
Game
NPC System
Virtual Agent
Trading System
Combat System
FX System
Terrain
Character Dynamics Sound FX
Collision
3D Scene Mngmt
3D Graphics API
2D Sprite
Game AI
Story
Gamepad
2D API
Hardware
Script System
UI
Audio
Network
Input Device
OS API
Game Play
Layer
Engine
Layer
System
Layer
Developing
Developed
74
Development Environment



.NET2003 Visual C++ 7.1
DirectX9.0c SDK (Dec, 2004)
Two include files : (must!)



TheFly.h
TheFlyWin32.h (Win32 version + D3D)
Linked libraries (API version)

TheFlyLibD_08_01.lib

d3d9.lib d3dx9.lib dsound.lib dxguid.lib winmm.lib
75
Create the Visual C++ Project for “TheFly3D”

Create folders for TheFly3D API







…\include
…\lib
New a Win32 application project
Set the additional include/library directories to TheFly3D
API
Add DirectX 9.0 SDK’s include/lib to additional search
directories
Add d3d9.lib d3dx9.lib dsound.lib dxguid.lib winmm.lib to
additional dependencies
Add TheFly.h, TheFlyWin32.h, TheFly3DLibD_xxxx.lib into
the project
76
The 1st TheFly3D Program – hello.cpp




Create
Create
Create
Create





a 3D world
a viewport
a scene
3D entities
A camera
A teapot model
A light source
Translate the camera to show the model
Bind callbacks to make the program interactive
77
Demo - Hello
Do it!
78
The Basics to Write TheFly3D Program

All Win32 code is transparent.



void main(int argc, char *argv[])
All Win32 & DirectX code are hidden within the engine.
ID & Function class




TheFly3D creates the objects for you.
 Return the object ID
TheFly3D owns the objects.
You have the right to handle the objects.
 Use function classes
No internal data structure & functions revealed
// create a viewport
vID = gw.CreateViewport(ox, oy, ww, hh);
FnViewport vp;
vp.Object(vID);
vp.SetBackgroundColor(0.3f, 0.3f, 0.0f);
79
Initialize TheFly3D

In general the 1st function to use TheFly3D is :



FyWin32CreateWorld()
After the calling successfully, you can get the non-zero ID
(WORLDid) of a world object.
Assign the ID to a world function class object for
manipulating the world.
// create a new world
WORLDid gID = FyWin32CreateWorld(“Tester", 0, 0, 800, 600, 16, FALSE);
FnWorld gw;
gw.Object(gID);
gw.SetTexturePath("Data\\textures");
80
The World in TheFly3D

A world is a set of graphics layers where the 3D objects
acts on.
A World
3D Graphics Layers
Frame Buffers
(front + back)
81
The 3D Graphics Layer


A 3D graphics layer is a projection of the rendering of a 3D
view.
The set of the 3D objects in the view :


We call it the “Scene”.
The projection we call the “Viewport”
Backdrop
Lights
Camera
3D Models
Board
A 3D Scene
82
The Viewports & Scenes



TheFly3D supports the multiple viewports.
A scene can be rendered on different viewports.
Viewports & scenes are created by the world object.
// create a new world
WORLDid gID;
gID = FyWin32CreateWorld(Tester", 0, 0, 800, 600, 16, FALSE);
FnWorld world;
world.Object(gID);
SCENEid sID = world.CreateScene();
VIEWPORTid vID = world.CreateViewport(0, 0, 400, 300);
world.DeleteScene(sID);
world.DeleteViewport(vID);
83
The Scene


A scene is not a “real” 3D object, just a “set” of 3D
objects.
A scene provides multiple rendering groups to handle the
priority sorting for the rendering of 3D objects.




There are three object lists within a rendering group.
 Invisible list
 Opacity list
 Semi-transparent list
The objects are rendered by the order of rendering groups.
In the same rendering group, the opaque objects are rendered first.
And the semi-transparent objects are sorted and rendered from far
to near…
84
The 3D Entities – Objects


A 3D scene is constructed by a set of “objects” which are
the basic entities in a scene.
An object is a carrier to carry real 3D data including :










Model geometry
Camera data
Lighting data
Terrain data
Particle emitters
Forces
Audio
Objects are created/deleted by its host scene.
Objects can be switched between scenes.
Objects should be assigned to a rendering group.
85
The Objects Can …







Can
Can
Can
Can
Can
Can
Can
have shapes (geometric data)
be grouped (hierarchy)
move (transformation)
look alike (clone or data sharing)
perform (animation or deformation)
be affected (lighted, listened)
be changed dynamically (modification)
86
A Scene Object
Hierarchy
Parent Object
Parameters
Etc
Transformation
Move
Animation
Motion Data
Shape
Geometric Data
Clone
87
A Model Object



An object to carry a set of geometry data is a model
object
You can load the model data from files.
TheFly3D loads .cw3 model files in default.
// create 3D entities
nID = scene.CreateObject(ROOT);
FnObject model;
model.Object(nID);
// load a teapot
model.Load("Teapot.cw3");
88
TheFly3D Scene Tree
A tree-based representation
 Simplified scene graph

Root
89
TheFly3D Scene Tree Is Simplified Scene Graph


A tree-based representation
Simplified scene graph
Root
90
Object Hierarchy
nID = scene.CreateObject(ROOT);
cID = scene.CreateCamera(ROOT);
FnObject model;
model.Object(nID);
model.SetParent(cID);
cID
nID
91
Clone a Model Object
OBJECTid nID = scene.CreateObject(ROOT);
FnObject model;
model.Object(nID);
OBJECTid nID1 = model.Instance();
nID
nID1
Data
instance
92
TheFly3D Major Model Object Functions (1/2)



void model.SetParent(parent_object_ID);
void model.Show(be_show);
void model.SetOpacity(opacity);


void model.SetRenderMode(mode);





mode = WIREFRAME or TEXTURE
OBJECTid clonedID = model.Instance();
void model.ChangeScene(sID);
BOOL model.Load(char *file);


opacity = 0.0 – 1.0
Load a .cw3 model file to a model object
void model.ShowBoundingBox(beShow);
void model.Translate(x, y, z, op);
93
TheFly3D Major Model Object Functions (2/2)

model.SetRenderOption(item, value);

(item, value) =
 (Z_BUFFER, TRUE/FALSE)
 (Z_BUFFER_WRITE, TRUE/FALSE)
 (ALPHA, TRUE/FALSE)
 Add/remove the model to/from alpha sorting list
 (FOG, TRUE/FALSE)
 (SPECULAR, TRUE/FALSE)
 (LIGHTING, TRUE/FALSE)
 (ANTIALIASING, TRUE, FALSE)
 (SOURCE_BLEND_MODE BLEND_ZERO / BLEND_ONE /
BLEND_SRC_COLOR / BLEND_INV_SRC_COLOR /
BLEND_SRC_ALPHA / BLEND_INV_SRC_ALPHA /
BLEND_DEST_ALPHA / BLEND_INV_DEST_ALPHA /
BLEND_DEST_COLOR / BLEND_INV_DEST_COLOR /
BLEND_SRC_ALPHA_SAT / BLEND_BOTH_SRC_ALPHA /
BLEND_BOTH_INV_SRC_ALPHA)
 (DESTINATION_BLEND_MODE values are same as the
SOURCE_BLEND_MODE)
94
Coordinate System

Every model should have its own local coordinate system.



To its parent model, it is in the global space.


Local space
Model space
 The space when it’s modeled
Global space
 The space for reference
World space

The global space of the “Root”
z
Z
Y
X
y
x
95
Transformation

Three basic linear transformations used in TheFly3D.




Translate
Rotate
Scale
Principles :



Right-handed rule
v’ = v M0 M1
Matrix in 12-element (I call the M12)
Rotation matrix
Translation vector
a0
a3
a6
a9
a1 a2 0
a4 a5 0
a7 a8 0
a10 a11 1
96
Translation
model.Translate(dx, dy, dz, op);
x’ = x + dx
y’ = y + dy
z’ = z + dz
T =
1
0
0
dx
0
1
0
dy
(dx dy dz)
0
0
1
dz
97
Rotation
i.e. rotate with z axis
model.Rotate(Z_AXIS, 30.0f, op);
x’ = x cosq – y sinq
y’ = x sinq + y cosq
z’ = z
Rz =
cosq
-sinq
0
0
sinq
cosq
0
0
0
0
1
0
z
y
x
98
Scaling
model.Scale(sx, sy, sz, op);
x’ = x * sx
y’ = y * sy
z’ = z * sz
T =
sx
0
0
0
0
sy
0
0
0
0
sz
0
99
Matrix Operations

Matrix operation

Z
REPLACE, LOCAL, GLOBAL
Y
op = LOCAL
X
op = REPLACE
[ML] [M] [MG]
z
x
y
op = GLOBAL
Object Transformation Matrix
100
TheFly3D Model Transformation Functions

model.Translate(x, y, z, op);


model.Rotate(axis, angle, op);






w : the scalar part of the quaternion
x, y, z : the vector part of the quaternion
The quaternion should be a unit quaternion
op = LOCAL, GLOBAL, or REPLACE
model.SetMatrix(M12, op);



op = LOCAL, GLOBAL, or REPLACE
model.Quaternion(w, x, y, z, op);


op = LOCAL, GLOBAL, or REPLACE
axis = X_AXIS, Y_AXIS, Z_AXIS
model.Scale(sx, sy, sz, op);


op = LOCAL, GLOBAL, or REPLACE
M12 : an M12 matrix
op = LOCAL, GLOBAL, or REPLACE
float *model.GetMatrix();

Get the pointer of the model object’s matrix
101
Transformations vs Movements
Transformation is the term used in
computer graphics but not friendly for
games.
 We use movements to control the 3D
objects moving around in the scene.







Move forward
Move right
Move up
Turn right
Turn left
…
Turn right / left
Move up
Move right
Move forward
102
Facing Direction and Up Direction
Each object is modeled with a facing direction and up
direction “visually”
 In TheFly3D, we use –y axis as the default facing direction
for a model, z axis as the default up direction
 But for a camera :



-z axis is the facing direction
y axis is the up direction
z
y
x
z up + facing to -y
103
Move Forward (1/2)
new position = old position +
distance *(facing direction in unit)
104
Move Forward (2/2)
The object has a local coordinate system.
 Align a local axis of the object with the facing direction
 Make a translation to move the object align the local
axis
 Apply the matrix first before to apply the existing
transformations (op = LOCAL)
 Then the object is moving forward!

FnObject model;
model.Object(nID);
model.Translate(0.0f, -dist, 0.0f, LOCAL); // facing to -y
105
Turn Right/Left (1/2)

An example : (rotate with an arbitrary axis)
-1
-1
-1
M = T1 * R1 * R2 * Rx(angle) * R2 * R1 * T1
T1 = / 1 0 0
0 1 0
0 0 1
-x -y -z
0
0
0
1 /
R1 = / cs2 -sn2 0 0
-z
sn2 cs2 0 0
0
0 1 0
0
0 0 1 /
R2 = / cs1 0 -sn1 0
y
0 1
0 0
sn1 0 cs1 0
0 0
0 1 /
Rx = / 1
0 0 0
0 cs sn 0
0 -sn cs 0
0
0 0 1 /
106
Turn Right/Left (2/2)
The object has a local coordinate system
 Align a local axis of the object with the up direction
 Make a rotation matrix to turn the object along the local
axis
 Apply the matrix first before to apply the existing
transformations
 Then the object is turning !

FnObject model;
model.Object(nID);
model.Rotate(Z_AXIS, -angle, LOCAL); // turn right
107
Terrain




A terrain is a place for 3D objects to walk on
A terrain can be generated from a model file
Neighboring triangles are the next searching target for
current triangle for terrain following
A terrain for terrain following is not the same as the
terrain in visual
108
Generate Terrain in TheFly3D
// create a terrain object
tID = scene.CreateTerrain();
FnTerrain t;
t.Object(tID);
// load a terrain model (just like a regular object)
// but a terrain is invisible in default
t.Load("test_terrain_following.cw3");
// generate the neighboring data for terrain following
// otherwise, the terrain model is for visual only
t.GenerateTerrainData();
109
Put a Model on Terrain Using TheFly3D
// if tID is the terrain object (OBJECTid)
// load a model
OBJECTid nID = scene.CreateObject(ROOT);
FnObject obj;
obj.Object(nID);
// put the model on terrain
float pos[3];
pos[0] = x;
pos[1] = y;
pos[2] = 10000.0f; // should be higher than the terrain!
obj.SetPosition(pos);
obj.PutOnTerrain(tID, be3D, offset, rangeF, rangeB, angle);
110
Terrain Following
Terrain Following (3D)
offset
Terrain Following (2D)
offset
111
Probe for a Model on Terrain
probeBack
probeFront
: terrain following check point
112
TheFly3D Model Movement Functions (1/3)

void model.GetPosition(pos)


void model.GetDirection(faceDir, upDir)


The position is related to its parent object
void model.SetDirection(faceDIr, upDir)


If you just want to get one of the directions, just send NULL pointer
to the one that you do not want to query
void model.SetPosition(pos)


pos is a 3D vector to get the position of the model object
If you just want to set one of the directions, just send NULL pointer
to the one that you do not want to set
Void model.SetDirectionAlignment(fDAxis, uDAxis)

You can change the local axes for facing and up directions
113
TheFly3D Model Movement Functions (2/3)

BOOL model.PutOnTerrain(tID, be3D, offset, probeFront,
probeBack, probeAngle, hightLimit)






tID is a terrain object
be3D = TRUE for 3D terrain following
Offset is the height above the terrain
hightLimit is the terrain following height limit
Return TURE if you successfully put the model on a terrain
int model.MoveForward(dist, beTerrainFollow, be3D, offset)



If you just want to move the model forward but not on terrain, set
beTerrainFollow to FALSE
You should put a model on terrain first. Then you can move it forward
on terrain.
Return value :
 WALK (ok for moving)
 BOUNDARY (hit the terrain boundary)
 BLOCK (not implemented yet, for collision)
 DO_NOTHING (something wrong …)
114
TheFly3D Model Movement Functions (3/3)

int MoveRight(dist, beTerrainFollow, be3D, offset)


void model.TurnRight(float angle)


Same as the MoveForward except moving in right-hand direction
Angle is in degree format
int model.GetCurrentTerrainTriangle()

Get current triangle ID in terrain, where the model is standing
115
A Character
116
Character with motion
117
Introduction to Characters


The characters are the actors of the games.
Three types of characters implemented in games :





Segmented
Mesh
Bone-skin
Root-base concept
Production :


3D animation tools
Motion capture (MoCap)
 For motion data
Base
118
A Segmented Character

A character is composed by a set of models with motion
data to simulate a live creature in real world

Benefits



Hierarchical structure
Easy to implement in a scene tree
Drawbacks

Segment-like
119

The scene tree of a segmented character :
head
up arm
hand
body
fore arm
groin
Base
thigh
groin
foot
shin
body
head
thigh_r
thigh_l
up_arm_r
shin_r
up_arm_l
shin_l
fore_arm_l
hand_l
fore_arm_r
hand_r
foot_r
foot_l
120
A Mesh Character

Vertex animation on skins



Benefits



Animated positional data on skins
3D warping
Easy to implement
Flexible mesh in animation
Drawbacks



No hierarchy
Each frame is independent.
Massive dataset
121
A Bone-skin Character

Bone-skin skeleton



Hierarchical bones
Skin deformation run-timely
Benefits



Bone A
Hierarchical structure
Not segmented look
Drawbacks


More complicated than the other solutions
Skin deformation need more CPU cost than
transformation only
Skin
Bone B
122
Motion Production – by 3D Animation Tools (1/2)

Keyframe system



3ds MAX
Softimage
Maya
123
Motion Production – by 3D Animation Tools (2/2)





Low cost (relatively)
Easy to combine animations
Hand-made animations
Hard to make “good” motions
Long production time
124
Motion Production – by Motion Capture (1/2)

Motion Capture


“MoCap” in short
Types :



Optical
Magnetic
...
125
Motion Production – by Motion Capture (2/2)

Expensive solution



Every frame is a keyframe
Very live motion


Noise !
Need post-processing for games





Hardware and software
Patching the data
Re-keyframing
Cleaning noise
Re-targeting
Hard to combine motions
126
The Root-Base Concept (1/2)

Use root-base structure to construct the character
Base
Root
(groin)
Base
127
The Root-Base Concept (2/2)








A character has some models to be the geometry roots of
the character system.
The root plays as the gravity center of the character.
The root can be translated and rotated.
The others are joints.
The joints can rotate only.
A ghost object is added to be the parent of the root, which
is the base of the character.
The base is the center for the character’s movement.
We move the base to perform character’s moves.
128
Motion Data - Pose




A set of frames to describe a character’s motion
For examples : Walk, run, attack, …
Keyframed or non-keyframed
Motion data in




Position (pivot) + quaternion
Position (pivot) + Euler angles
Position (pivot) + (q, n)
Matrix
walk
run
attack
fall
129
Load a Character
FnScene scene;
CHARACTERid actorID;
.cwc is a character
description file.
scene.Object(sceneID);
actorID = scene.LoadCharacter(“fm.cwc");
130
Play a Pose
BLENDTREEid btID = actor.GetBlendTree();
FnBlendTree bt;
bt.Object(btID);
// the 2nd motion definition
BLENDNODEid aaaID;
aaaID = bt.CreateAnimationNode(2);
// start to play a pose (1st time)
actor.PlayBlendNode(aaaID, (float) 0, START, TRUE);
// continue to play a pose
actor.PlayBlendNode(CURRENT, (float) skip, LOOP, TRUE);
131
Make a Character to Move Forward
FnCharacter actor;
// play walking pose
actor.Object(actorID);
actor.PlayBlendNode(CURRENT, (float) skip, LOOP, TRUE);
// move it forward
actor.MoveForward(dist, beTF, be3D, offset);
132
TheFly3D Character Movement Functions (1/2)

void actor.GetPosition(pos)


void actor.GetDirection(faceDir, upDir)


The position is related to its parent object
void actor.SetDirection(faceDIr, upDir)


If you just want to get one of the directions, just send NULL pointer
to the one that you do not want to query
void actor.SetPosition(pos)


pos is a 3D vector to get the position of the character
If you just want to set one of the directions, just send NULL pointer
to the one that you do not want to set
BOOL actor.PutOnTerrain(tID, be3D, offset, probeFront,
probeBack, probeAngle, hightLimit)





tID is a terrain object
be3D = TRUE for 3D terrain following
Offset is the height above the terrain
hightLimit is the terrain following height limit
Return TURE if you successfully put the character on a terrain
133
TheFly3D Character Movement Functions (2/2)

void actor.MoveForward(dist, beTF, be3D, offset)




If you just want to move the character forward but not on terrain,
set beTF to FALSE
You should put a character on terrain first. Then you can move it
forward on terrain.
A character is always using his local -y-axis as facing direction
void actor.TurnRight(float angle)


Angle is in degree
A character is always using his local z-axis as up direction
134
TheFly3D Character Functions

OBJECTid actor.GetBaseObject()


OBJECTid actor.GetObjectByName(name)




The function is to play the motion for a specific frame
Set beIncludeBase = TRUE to play the base object’s motion
BLENDTREEid actor.GetBlendTree()



You can get the each model part of the character by its name in
character file
For a bone-skin character, this function can get the bones in the
skeleton
BOOL actor.PlayFrame(frame, beIncludeBase)


You can get the base object of the character
Get the character’s blend tree data
You can define all poses in a blend tree (blend nodes)
float actor.PlayBlendNode(btNodeID, skipFrame, mode,
beIncludeBase)



All poses for a character is defined as a blend node
Skip frames can be floating-point
Mode can be ONCE or LOOP!
135
5th
Game Mathematics
136
Essential Mathematics for Game Development









Matrices
Vectors
Fixed-point Real Numbers
Triangle Mathematics
Intersection Issues
Euler Angles
Angular Displacement
Quaternion
Differential Equation Basics
137
Matrices (1/7)

Matrix basics



Definition
A
=
(aij) =
C
=
A
C
=
A + B
a11 .. a1n
.
.
.
.
am1 .. amn
Transpose
T
cij = aji
Addition
cij = aij + bij
138
Matrices (2/7)

Scalar-matrix multiplication
C

=
aA
cij = aaij
Matrix-matrix multiplication
C
=
A B
cij
r
= Saikbkj
k = 1
139
Matrices (3/7)

Transformations in Matrix form

A point or a vector is a row matrix (de facto convention)
V = [x y z]

Using matrix notation, a point V is transformed under translation,
scaling and rotation as :
V’ = V + D
V’ = VS
V’ = VR
where D is a translation vector and
S and R are scaling and rotation matrices
140
Matrices (4/7)

To make translation be a linear transformation, we introduce the
homogeneous coordinate system
V (x, y, z, w)

, where w is always 1
Translation Transformation
x’ = x + Tx
y’ = y + Ty
z’ = z + Tz
[x’ y’ z’ 1] = [x y z 1]
V’ = VT
1
0
0
Tx
0
0
1
0
0
1
Ty Tz
0
0
0
1
= [x y z 1] T
141
Matrices (5/7)

Scaling Transformation
x’ = xSx
y’ = ySy
z’ = zSz
V’ = VS
Sx
[x’ y’ z’ 1] = [x y z 1] 0
0
0
0
Sy
0
0
0
0
Sz
0
0
0
0
1
= [x y z 1] S
Here Sx, Sy and Sz are scaling factors.
142
Matrices (6/7)

Rotation Transformations
Rx
Ry
Rz
=
1
0
0
0 cosq sinq
0 -sinq cosq
0
0
0
0
0
0
1
=
cosq
0
sinq
0
0 -sinq
1
0
0 cosq
0
0
0
0
0
1
=
cosq sinq 0
-sinq cosq 0
0
0
1
0
0
0
0
0
0
1
143
Matrices (7/7)

Net Transformation matrix
[x’ y’ z’ 1] = [x y z 1] M1
and
[x” y” z” 1] = [x’ y’ z’ 1] M2
then the transformation matrices can be concatenated
M3 = M1 M2
and
[x” y” z” 1] = [x y z 1] M3

Matrix multiplication are not commutative
M1 M2 = M2 M1
144
Vectors (1/5)


A vector is an entity that possesses magnitude and
direction.
A 3D vector is a triple :


V = (v1, v2, v3), where each component vi is a scalar.
A ray (directed line segment), that possesses position,
magnitude and direction.
(x1,y1,z1)
V = (x2-x1, y2-y1, z2-z1)
(x2,y2,z2)
145
Vectors (2/5)

Addition of vectors
X = V + W
= (x1, y1, z1)
= (v1 + w1, v2 + w2, v3 + w3)
W
V + W
W
V

V + W
V
Length of vectors
|V| = (v12 + v22 + v32)1/2
U
= V / |V|
146
Vectors (3/5)

Cross product of vectors

Definition
X = V X W
= (v2w3-v3w2)i + (v3w1-v1w3)j + (v1w2-v2w1)k
where i, j and k are standard unit vectors :
i = (1, 0, 0), j = (0, 1, 0), k = (0, 0, 1)

Application
 A normal vector to a polygon is calculated from 3 (noncollinear) vertices of the polygon.
Np
V2
polygon defined by 4 points
Np = V1 X V2
V1
147
Vectors (4/5)

Transformation of the normal vectors
N(X) = detJ J-1T N(x)
where X = F(x)
dF(x)
J the Jacobian matrix, Ji(x) =
dxi
"Global and Local Deformations of Solid Primitives"
Alan H. Barr
Computer Graphics Volume 18, Number 3 July 1984
148
Vectors (5/5)

Dot product of vectors

Definition
|X| = V . W
= v1w1 + v2w2 + v3w3

Application
V
q
cosq =
W
V
.
W
|V||W|
149
Fixed Point Arithmetics (1/2)

Fixed point arithmetics : n bits (signed) integer


Example : N = 16 gives range –32768  ă  32767
We can use fixed scale to get the decimals.
a = ă / 28
8 integer bits
11
1
8 fractional bits
ă = 315, a = 1.2305
150
Fixed Point Arithmetics (2/2)

Multiplication then requires rescaling
e = a. c = ă / 2 8 . ĉ / 2 8
 ĕ = (ă . ĉ) / 28

Addition just like normal
e = a+c = ă / 28 + ĉ / 28
ĕ=ă+ĉ
151
Fixed Point Arithmetics - Application

Compression for floating-point real numbers




4 bytes reduced to 2 bytes
Lost some accuracy but affordable
Network data transfer
Software 3D rendering (without hardware-assistant)
152
Triangular Coordinate System
ha
(xa,ya,za)
Ac p
hb
h
(xb,yb,zb)
Ab
Aa
hc (x ,y ,z )
c
h=
Aa
A
ha +
Ab
A
hb +
c
Ac
A
c
hc
where A = Aa + Ab + Ac
If (Aa < 0 || Ab < 0 || Ac < 0) than
the point is outside the triangle
“Triangular Coordinate System”
153
Triangle Area – 2D
Area of a triangle in 2D
A=½
xa ya
xb yb
xc yc
xa ya
= ½ (xa*yb + xb*yc + xc*ya – xb*ya – xc*yb – xa*yc)
(xa,ya,za)
(xb,yb,zb)
(xc,yc,zc)
154
Triangle Area – 3D
Area of a triangle in 3D
A = ½ (N. Sum(Pi1 cross Pi2))
where (i1, i2) = (a,b), (b,c), (c,a)
float GmArea3(float *x0, float *x1, float *x2, float *n)
{
float area, len, sum1, sum2, sum0;
len = (float) sqrt(n[0] * n[0] + n[1] * n[1] + n[2] * n[2]) * 2.0f;
/* find sum of cross products */
sum0 = x1[1] * (-x0[2] + x2[2]) + x2[1] * (-x1[2] + x0[2]) +
x0[1] * (-x2[2] + x1[2]);
sum1 = x1[2] * (-x0[0] + x2[0]) + x2[2] * (-x1[0] + x0[0]) +
x0[2] * (-x2[0] + x1[0]);
sum2 = x1[0] * (-x0[1] + x2[1]) + x2[0] * (-x1[1] + x0[1]) +
x0[0] * (-x2[1] + x1[1]);
/* find the area */
return = (sum0 * n[0] + sum1 * n[1] + sum2 * n[2]) / len;
}
155
Triangular Coordinate System - Application

Terrain following


Hit test


Intersection of a ray from camera to a screen position with a
triangle
Ray cast


Interpolating the height of arbitrary point within the triangle
Intersection of a ray with a triangle
Collision detection

Intersection
156
Intersection


Ray cast
Containment test
157
Ray Cast – The Ray


Cast a ray to calculate the intersection of the ray with models
Use parametric equation for a ray
{



x = x0 + (x1 – x0) t
y = y0 + (y1 – y0) t,
z = z0 + (z1 – z0) t
t = 0, 8
When t = 0, the ray is on the start point (x0,y0,z0)
Only the t  0 is the answer candidate
The smallest positive t is the answer
158
Ray Cast – The Plane







Each triangle in the 3D models has its plane equation.
Use ax + by + cz + d = 0 as the plane equation.
(a, b, c) is the plane normal vector.
|d| is the distance of the plane to origin.
Substitute the ray equation into the plane.
Solve the t to find the intersect point.
Check the intersect point within the triangle or not by
using “Triangle Area Test” (p. 155)
159
2D Containment Test
Intersection = 1, inside
Intersection = 2, outside
(x0, y0)
Intersection = 0, outside
Trick : Parametric equation for a ray which is parallel to the x-axis
{
x = x0 + t
y = y0
, t = 0, 8
“if the No. of intersection is odd, the point is inside,
otherwise, is outside”
160
3D Containment Test

Same as the 2D containment test
“if the No. of intersection is odd, the point is inside,
otherwise, is outside”
161
Euler Angles

A rotation is described as a sequence of rotations about
three mutually orthogonal coordinates axes fixed in space

X-roll, Y-roll, Z-roll
R(q1, q2, q3) represents an x-roll, followed by y-roll, followed by z-roll
R(q1, q2, q3) =
c 2c 3
c 2s 3
s1s2c3-c1s3 s1s2s3+c1c3
c1s2c3+s1s3 c1s2s3-s1c3
0
0
where si = sinqi and ci = cosqi

-s2
s 1c 2
c 1c 2
0
0
0
0
1
There are 6 possible ways to define a rotation.

3!
162
Euler Angles & Interpolation


Interpolation happening on each angle
Multiple routes for interpolation
More keys for constrains
R
z
z
y
x
y
x
R

163
Angular Displacement

R(q, n), n is the rotation axis.
rv
q
r
r Rr
rh
V = nxrv = nxr
n
n
rv
V
rh = (n.r)n
rv = r - (n.r)n , rotate into position Rrv
q
V
Rrv
Rrv = (cosq)rv + (sinq)V
->
Rr = Rrh + Rrv
= rh + (cosq)rv + (sinq)V
= (n.r)n + (cosq) (r - (n.r)n) + (sinq) nxr
= (cosq)r + (1-cosq) n (n.r) + (sinq) nxr
164
Quaternion








Sir William Hamilton (1843)
From Complex numbers (a + ib), i 2 = -1
16,October, 1843, Broome Bridge in Dublin
1 real + 3 imaginary = 1 quaternion
q = a + bi + cj + dk
i2 = j2 = k2 = -1
ij = k & ji = -k, cyclic permutation i-j-k-i
q = (s, v), where (s, v) = s + vxi + vyj + vzk
165
Quaternion Algebra
q1 = (s1, v1) and q2 = (s2, v2)
q3 = q1q2 = (s1s2 - v1.v2 , s1v2 + s2v1 + v1xv2)
Noncommutative
Conjugate of q = (s, v), q = (s, -v)
qq = s2 + |v|2 = |q|2
A unit quaternion q = (s, v), where qq = 1
A pure quaternion p = (0, v)
166
Quaternion VS Angular Displacement
Take a pure quaternion p = (0, r)
and a unit quaternion q = (s, v) where qq = 1
and define Rq(p) = qpq-1 where q-1 = q for a unit quaternion
Rq(p) = (0, (s2 - v.v)r + 2v(v.r) + 2svxr)
Let q = (cosq, sinq n),
|n| = 1
Rq(p) = (0, (cos2q - sin2q)r + 2sin2q n(n.r) + 2cosqsinq nxr)
= (0, cos2qr + (1 - cos2q)n(n.r) + sin2q nxr)
Conclusion :
The act of rotating a vector r by an angular displacement (q, n)
is the same as taking this displacement, ‘lifting’ it into
quaternion space, by using a unit quaternion (cos(q/2),
sin(q/2)n)
167
Quaternion VS Rotation Matrix
q = (w,x,y,z)
1-2y2-2z2 2xy-2wz 2xz+2wy
2xy+2wz 1-2x2-2z2 2yz-2wx
2xz-2wy 2yz+2wx 1-2x2-2y2
0
0
0
0
0
0
1
168
float tr, s;
tr = m[0] + m[4] + m[8];
if (tr > 0.0f) {
s = (float) sqrt(tr + 1.0f);
q->w = s/2.0f;
s = 0.5f/s;
q->x = (m[7] - m[5])*s;
q->y = (m[2] - m[6])*s;
q->z = (m[3] - m[1])*s;
M0 M1 M2 0
M3 M4 M5 0
M6 M7 M8 0
0 0 0 1
}
else {
float qq[4];
int i, j, k;
int nxt[3] = {1, 2, 0};
i = 0;
if (m[4] > m[0]) i = 1;
if (m[8] > m[i*3+i]) i = 2;
j = nxt[i]; k = nxt[j];
s = (float) sqrt((m[i*3+i] - (m[j*3+j] + m[k*3+k])) + 1.0f);
qq[i] = s*0.5f;
if (s != 0.0f) s = 0.5f/s;
qq[3] = (m[j+k*3] - m[k+j*3])*s;
qq[j] = (m[i+j*3] + m[j+i*3])*s;
qq[k] = (m[i+k*3] + m[k+i*3])*s;
q->w = qq[3];
q->x = qq[0];
q->y = qq[1];
q->z = qq[2];
}
169
Quaternion Interpolation

Spherical linear interpolation, slerp
A
P
B
t
f
slerp(q1, q2, t) = q1
sin((1 - t)f)
sinf
+ q2
sin(tf)
sinf
170
Differential Equation Basics


Initial value problems
ODE


Ordinary differential equation
Numerical solutions


Euler’s method
The midpoint method
171
Initial Value Problems

An ODE
.
x = f (x, t)
where f is a known function
.
x is the state of the system, x is the x’s time derivative
.
x & x are vectors
x(t0) = x0, initial condition


Vector field
Solutions


Symbolic solution
Numerical solution
Start here
Follow the vectors …
172
Euler’s Method
x(t + Dt) = x(t) + Dt f(x, t)

A numerical solution



Discrete time steps starting with initial value
Simple but not accurate




A simplification from Tayler series
Bigger steps, bigger errors
O(Dt2) errors
Can be unstable
Not even efficient
173
The Midpoint Method
Error term
.
..
2
Concept : x(t0 + h) = x(t0) + h x(t0) + h /2 x(t0) + O(h3)
Result : x(t0+h) = x(t0) + h(f(x0 + h/2 f(x0))
Method : a. Compute an Euler step
Dx = Dt f(x, t)
b. Evaluate f at the midpoint
fmid = f((x+Dx)/2, (t+Dt)/2)
c. Take a step using the midpoint
x(t+Dt) = x(t) + Dt fmid
c
b
a
174
The Runge-Kutta Method


Midpoint = Runge-Kutta method of order 2
Runge-Kutta method of order 4

O(h5)
k1
k2
k3
k4
=
=
=
=
h
h
h
h
f(x0, t0)
f(x0 + k1/2, t0 + h/2)
f(x0 + k2/2, t0 + h/2)
f(x0 + k3, t0 + h)
x(t0+h) = x0 + 1/6 k1 + 1/3 k2 + 1/3 k3 + 1/6 k4
175
Initial Value Problems - Application

Dynamics



Particle system
Game FX system
Fluid simulation
176
6th
Game Geometry
177
Game Models

Geometry






Topology





Primitive
 Lines / triangles / surfaces / …
Property


Position
vertex normals
vertex colors
texture coordinates
Tangent / Bi-normal
Materials
Textures
Motion
Hierarchy
Level-of-detail
178
Geometry Data

Vertex position



Vertex normal


N
(u1, v1), (u2, v2), …
T
Skin weights


(r, g, b) or (diffuse, specular)
Texture coordinates on vertex


(nx, ny, nz)
Vertex color


(x, y, z, w)
In model space or screen space
(bone1, w1, bone2, w2, …)
Bn
Tangent and bi-normal
179
Topology Data

Lines





Indexed triangles
Triangle strips / fans
Surfaces


Line segments
Polyline
 Open / closed
Non-uniform Rational B Spline (NURBS)
Subdivision
180
Indexed Triangles

Geometric data





Vertex data
v0, v1, v2, v3, …
(x, y, z, nx, ny, nz, tu, tv)
or (x, y, z, cr, cg, cb, tu, tv, …)
polygon normal
Topology


Face v0 v3 v6 v7
Edge table
v0
vertex normal
v7
v3
v6
Right-hand rule for index
181
Triangle Strips
v0
v2
v6
v4
T0
T4
T2
T1
T5
T3
v5
v1
v7
v3
v0 , v1 , v2 , v3 , v4 , v5 , v6 , v7
“Get great performance to use triangle strips for
rendering on current hardware
182
Property on Surface



Material
Textures
Shaders
183
Materials

Material





Ambient
 Environment
 Non-lighted area
Diffuse
 Dynamic lighting
Emissive
 Self-lighting
Specular with shineness
 Hi-light
 View-dependent
 Not good for hardware rendering
Local illumination
184
Textures

Textures





Single texture
Texture coordinate animation
Texture animation
Multiple textures
Alphamap
Lightmap
Base color texture
Material or vertex colors
185
Shaders

Programmable shading language



Vertex shader
Pixel shader
Procedural way to implement some process of rendering







Transformation
Lighting
Texturing
BRDF
Rasterization
Pixel fill-in
Post-processing for rendering
186
Shader Pipeline
Vertex Data
Topology Data
Classic
Transform &
Lighting
Vertex Shader
Geometry
Stage
Clipping & Viewport Mapping
Texturing
Pixel Shader
Fog
Rasterizer
Stage
Alpha, Stencil, Depth Testing
187
Powered by Shader

















Per-pixel lighting
Motion blur
Volume / Height fog
Volume lines
Depth of field
Fur rendering
Reflection / Refraction
NPR
Shadow
Linear algebra operators
Perlin noise
Quaternion
Sparse matrix solvers
Skin bone deformation
Normal map
Displacement map
Particle shader


Procedural Morphing
Water Simulation
188
Motion Data


Time-dependent data
Transformation data



Position
Orientation
Formats





Pivot
Position vector
Quaternion
Eurler angles
Angular displacement
189
Level-of-detail

Discrete LOD


Continuous LOD


Switch multiple resolution models run-timely
Use progressive mesh to dynamically reduce the rendered polygons
View-dependent LOD

Basically for terrain
190
Progressive Mesh



Render a model in different Level-of-Detail at run time
User-controlledly or automatically change the percentage
of rendered vertices
Use collapse map to control the simplification process
Collapse map
Index
0
1
2
3
4
5
6
7
8
Map
0
1
1
2
3
0
4
5
6
Vertex list
0
1
2
3
4
5
6
7
8
Triangle list
0
2
5
0
1
2
3
5
8
0
6
0
4
191
View-dependent LOD for Terrain - ROAM





Real-time Optimal Adapting Meshes (ROAM)
Use height map
Run-timely to re-construct the active (for rendering)
geometric topology (re-mesh) to get an optimal mesh
(polygon count) to improve the rendering performance
Someone calls this technique as the view-dependent levelof-detail
Very good for fly-simulation-like application
192
Level-of-detail Suggestion



Apply progressive mesh for multi-resolution model generation
Use in-game discrete LOD for performance tuning
Why ?


For modern game API / platform, dynamic vertex update is costly on
performance
Lock video memory stall CPU/GPU performance
193
Bounding Volume





Bounding sphere
Bounding cylinder
Axis-aligned bounding box (AABB)
Oriented bounding box (OBB)
Discrete oriented polytope (k-DOP)
Bounding Sphere
Bounding Cylinder
AABB
k-DOP
OBB
194
Bounding Volume - Application




Collision detection
Visibility culling
Hit test
Steering behavior

In “Game AI” section
195
Application Example - Bounding Sphere
B2
B1
D
c2
c1
Bounding sphere B1(c1, r1), B2(c2, r2)
If the distance between two bounding spheres is
larger than the sum of radius of the spheres, than
these two objects have no chance to collide.
D > Sum(r1, r2)
196
Application Example - AABB

Axis-aligned bounding box (AABB)


Simplified calculation using axis-alignment feature
But need run-timely to track the bounding box
AABB
197
Application Example - OBB

Oriented bounding box (OBB)


Need intersection calculation using the transformed OBB
geometric data
 3D containment test
 Line intersection with plane
OBB
For games, 
198
7th
Terrain
199
Introduction


Very game type oriented data
Terrain




Terrain following


For visual purpose
 Ground / Building / Static models / Dynamic models
For terrain following
 Polygon mesh
 Grids
For path finding
 Polygon mesh
 Grids
Make a 3D entity (character or model) walking on terrain
Path finding



Find a “shortest” path to walk before moving
Will be taught in Game AI section.
A* algorithm
200
Terrain Formats

Grid



Height map



Procedural height map
Using noise function to generate the height
ROAM


2D
Quadtree
Real-time Optimally Adapting Meshes
Triangular mesh


Perlin Noise
Procedurally generated
Created by artists
201
Grid Map

2D grid map


Rectangular or Hexagonal grids
Attributes
 Height
 Walkable or not
 Texture pattern ID

Step look terrain

Application


2D games
3D games with god view
 2D tile-based game terrain
202
Height Map

Almost as same as 2D grid map but :"





Height on grid vertex
Only height is saved
Regular grid
Irregular grid but structured
Top view
Application


As the base data structure for ROAM terrain
Water simulation
203
ROAM

Real-time optimally adapting mesh


http://www.llnl.gov/graphics/ROAM/
Application

Fly-simulation
204
Chunked LOD Terrain

Use quad tree to construct the level-of-detail of terrain

A quad tree for LOD
205
Triangular Mesh

Possibly the most popular way for 3D games



General
Can be created by artists
Multiple-layered terrain issue
206
Terrain Following Using Triangular Mesh

Solve the terrain height for the object to stand on.


Use the triangular coordinate system (p. 154)
Find the next neighboring triangle

Half-edge data structure
207
Half-edge (1/2)


Create cohesive relationship between triangles using “half
edge”
Use half-edge table to search the neighboring triangles
Edge = two halves
208
Half-edge (2/2)
struct HE_edge
{
HE_vert* vert; // vertex at the end of the half-edge
HE_edge* pair; // oppositely oriented adjacent half-edge
HE_face* face; // face the half-edge borders
HE_edge* next; // next half-edge around the face
};
struct HE_vert
{
float x;
float y;
float z;
HE_edge* edge; // one of the half-edges
// emantating from the vertex
};
struct HE_face
{
HE_edge* edge; // one of the half-edges bordering the face
};
http://www.flipcode.com/tutorials/tut_halfedge.shtml
209
8th
Character Motion
210
A Segmented Character

A character is composed by a set of models with motion
data to simulate a live creature in real world
211
A Mesh Character

Vertex animation on skins


Animated positional data on skins
3D warping
212
A Bone-skin Character

Bone-Skin Skeleton


Hierarchical bones
Skin deformation run-timely
Bone A
Skin
Bone B
213
Motion Data



Euler angles
Angular displacement
Quaternion


Can achieve the interpolation by “Slerp”
But finally they will be converted into “matrix”
214
Optical Motion Capture


Device
Data acquired




From skin to joint (Mocap)
From joint to skeleton (Post-processing)
From skeleton to skin (In-game)
The shooting plan
215
Mocap Devices
216
Data Acquirement During the Mocap
Raw Data (Positional Data)
Bio-Data
Joint
End Point
217
Bone-skin Implementation In Game
Skeletons
Skin
Bone-Skin
Skeletons
218
Planning a Mocap Shoot
 Starting out – reviewing
the animation list and
flowchart
219
220
 Creating a shot list
 Create a database
 File names
 Preliminary shot list
A Data Record of Shot List
221
A Shoot List
222
 Getting ready for the shoot
 When to Shoot ?
 Find a Studio
 Make Sure No Technical Blocks
 Casting
 Preparing a shooting schedule
 Organize the Shot List
 Daily Schedule
 Do You Need a Rehearsal Day ?
 Take care of your performer
223
A Daily Schedule
224
225
226
Apply Motion for Characters

Apply motion data on bones
(x,y,z,q,axis)
A
(q,axis)
Joint = pivot(px,py,pz) in A
B
<v’> = <V> [RB][TB][RA][TA]
From pivot
From position
227
Motion Editing



To create more animation from limited work
Run-time or pre-processing
Issues :





Motion re-targeting
 Run-time
Re-key-framing
 Pre-processing
Interpolation between frames
 Run-time
Motion blending
 Run-time
Motion connection
 Run-time
228
A Pose Definition Example
start_frame
raw_start_frame
end_frame
walk
raw_end_frame
cut_frame
Parameter {
raw_start_frame
raw_end_frame
start_frame
end_frame
cut_frame
play_speed
length
transition_mode
}
229
Play a Pose
walk
0
4
8
Frame 5.3
1.
2.
3.
4.
5.
6.
If the motion data is in quaternion form
Get the motion data on frame 5 & 6
Convert the data into quaternion format
Apply slerp(5, 6, 0.3) to get the interpolation on frame 5.3
Convert the result of step 3 into a rotation matrix
Apply the matrix to the object for its transformation
230
Pose Connection
cut_frame
Pose 1
start_frame
Pose 2
length
231
Pose Blending



Motion blending in run-time
Quaternion is used
“Blend Tree”



Cross fade
Countinuous blending
Feather blending
232
Blend Tree

Reference





Game Developers Conference 2003
Proceedings CD, Programming Track
“Animation Blending : Achieving Inverse Kinematics and More”
Jerry Edsall
Mech Warrior blend tree
Walk
Forward
Motion
Fall Transition
Run
Fall
Down
233
Cross Fade
1
Pose 1
0
1
Pose2
0
234
Continuous Blending
1
Pose 1
0
1
Pose 2
0
235
Feather Blending

左右搏擊
Pose 1
Pose 2
Pose 3
236
Skin Deformation

Weights to assign the influences of the deformation by
bones on skin vertices





1-weight
2-weight
N-weight
CPU cost
Another way to perform the skin deformation calculation is
using vertex shader
237
Bone A
(root object)
base
1.
2.
3.
4.
5.
base
Bone B
(Bone A’s child)
Apply motion data to bones
Convert the vertex from “base” space to its associated
bone’s space using the natural pose’s inverse
transformation
Multiple the influence weight
Accumulate all influences
Then the vertex is deformed by the bone in “base” space
238
A two-weight skin vertex example
Mb = RbTpivot
Ma = RaTposition
Mvb = Mnb-1 MbMa
Mva = Mna-1Ma
vin_base = vs*waMva +
vs*wbMvb
239
9th
Game Control
240
Game Control System (1/2)



Game control is the interface between the game and the
user.
Game control is not only input device control but also the
camera control
Input device control


On PC
 Mouse
 Keyboard
 Gamepad
On game console
 Gamepad buttons
 0 or 255
 Joystick
 0 - 255
241
Game Control System (2/2)

Camera control





First-personal view
Third-personal view
God view
Pre-set camera view
Etc
242
Mouse Control (1/3)

Mouse is a 2D device.




Mouse can :




2-axis moving
Related movement
2 or 3 buttons
Move
Drag
Double-click
Behaviors



Hit test
Selection
Pilot
 Position & orientation
243
Mouse Control (2/3)

Typical game types using mouse control



Typical game play examples :







Real-time strategy games
Role Playing Game
Path finding for playable character
Hitting the enemy
Selecting a group of units
Orientating the camera in FPS games
Menu selection
…
Features

Always coupling with god-view camera control
 Viewing from the top of game world
244
Mouse Control (3/3)


Easy to hand on
 一鼠到底
Slow action
 Compared with joystick
 Value range from -32727 - 32727
245
Keyboard Control (1/3)


Standard PC input device
Simulating the gamepads usually



Hotkey system



Each key has two states.
 Pressed
 Released
256 keys
Behaviors



Not every PC game player having gamepad
Using keyboard as the alternative device
Key presses/released
ASCII code
One hotkey can represent a command
246
Keyboard Control (2/3)

Communication tool


Typical game types using keyboard





Typing messages
MMORPG
 Needs chatting with friends
Real-time strategy games
 Hotkey system
First-person shooting games
Fighting games
Typical game play examples :


Chatting
Character controls
 Move forward
 Turning
247
Keyboard Control (3/3)

Features


Shortcut for a sequence of actions
 Commands
 Menu selection
But a little bit complicated for players
 256 keys
248
Gamepad Control (1/3)

A small “keyboard” designed for game playing




Gamepad can map to the hotkey system
Same behaviors
Less than 20 keys
Majors keys :
249
Gamepad Control (2/3)

Recent gamepad capable of two extra digital joysticks



Typical game types using gamepad


For buttons
 Value range : 0 or 255
For joystick
 Value range : 0 to 255
Almost all types of games except
 Need typing
 Need large-range selection for game units
Typical game play examples :

Character controls
 Move forward
 Turn
250
Gamepad Control (3/3)



Combat system in a fighting game
 Move forward
 Turn
…
Features


Designed for game playing
 Look and feel
Easy to hand-on
 If you not to challenge the players’ usual practice
251
Camera Control

Types








First-personal view
Third-personal view but following the playable character
God view
 Fixed
 Following the playable character
Fixed view
 Pre-rendered background
Pre-set view
…
Very sensitive to game play design & game control
Camera control is not an independent system
252
God-view Camera Example
Age of Empire 3
253
Case Study – Third-personal View (1/6)

Use arrow keys on keyboard or gamepad

Basic key assignments :



Up key to move the playable character forward
Down key to turn character facing to the camera and move forward
Left & right keys to turn the character to left or right
254
Case Study – Third-personal View (2/6)


The camera following the character to move
And keeping a range of distance, a reasonable height and
look-down angle with the character.
Camera
q
PC
Height
Distance
255
Case Study – Third-personal View (3/6)

Detailed key assignments :


Up key
 Turn the character facing back to the camera
 Move the character forward
 If the distance between the character and the camera is larger
a pre-set range, move the camera forward to keep the distance.
 At the same time, the height to the ground will be changed to
synchronize with the character.
Down key
 Turn the character facing to the camera
 Move the character forward
 The camera will move backward to keep a distance with the
character.
 The height to the ground will be changed to synchronize with
the character.
256
Case Study – Third-personal View (4/6)

If the camera is blocked by obstacle to move backward, raise
the height of the camera but keep the eyes on the character.
PC
Camera
257
Case Study – Third-personal View (5/6)

Right key
 Turn the character facing to the right of the camera.
 Take the camera’s position as a circle center and the distance
between the camera and the character as the radius.
 Set the circle as the movement orbit.
 Let the character move on the orbit.
 When the character moving, turn the camera to right to keep
eyes on the character.
258
Case Study – Third-personal View (6/6)
When the character hitting the obstacle, let the character keep
on turning and moving, use the same approach in “Down key”
step to raise the camera.
Left key
 As same as “Right key” step except the left direction.



Reference game examples:






Sprinter cell 3
PSO
Prince of Persia(波斯王子)
The Legend of Zelda (薩爾達傳說)
…
Demo : 1st DCI students’ work : iRobot
259
Bounding Volume





Bounding sphere
Bounding cylinder
Axis-aligned bounding box (AABB)
Oriented bounding box (OBB)
Discrete oriented polytope (k-DOP)
Bounding Sphere
Bounding Cylinder
AABB
k-DOP
OBB
260
Bounding Volume - Application




Collision detection
Visibility culling
Hit test
Steering behavior

In “Game AI” section
261
Application Example - Bounding Sphere
B2
B1
D
c2
c1
Bounding sphere B1(c1, r1), B2(c2, r2)
If the distance between two bounding spheres is
larger than the sum of radius of the spheres, than
these two objects have no chance to collide.
D > Sum(r1, r2)
262
Application Example - AABB

Axis-aligned bounding box (AABB)


Simplified calculation using axis-alignment feature
But need run-timely to track the bounding box
AABB
263
Application Example - OBB

Oriented bounding box (OBB)


Need intersection calculation using the transformed OBB
geometric data
 3D containment test
 Line intersection with plane
OBB
For games, 
264
Advanced Scene Graphs



This is a game-type-oriented issue
Bounding Volume Hierarchies (BVHs)
Binary space partition trees (BSP Trees)




“Quake”
Octree
PVS
Culling Skills
265
Bounding Volume Hierarchies (BVHs)

Bounding spheres in hierarchy
R
B
266
BSP Tree

Two varients



Axis-aligned
Polygon-aligned
The trees are created by using a plane to divide the space
into two, and then sorting the geometry into two spaces.
267
Axis-aligned BSP Tree
0
plane
plane
3
plane1
2
1
0
plane2
3
268
Polygon-aligned BSP Tree
F
A
C
G
B
A
B
C
D
E
D
E
F
G
269
Why BSP Tree ?

Quickly to identify where you are


Need a pre-processor to generate the PVS




BSP = Sorting
Visibility culling + occlusion culling
PVS : Possible Visible Set
Optimized for in-door game environment
[Fuch80]



Fuchs, H.,
On Visible Surface Generation by a Priori Tree Structures,
Computer Graphics, 14, 124-33, (Proc. SIGGRAPH’80)
270
Octree & Quadtree





Very similar to axis-aligned BSP tree.
Except that a box is split simultaneously along all three
axes.
The split point must be the center of the box.
This creates eight new boxes.
Quadtree is the 2D version of octree.
271
Quadtree - Example
272
Octree – Some Discussion




Data structure coherence
Apply visibility culling from parents
Split or not split ?
Outdoor game scene ?
273
Culling (1/2)


Culling means “remove from a flock”
Visibility culling



Backface culling



Remove the object not in view frustum
A “must” for game engine
Remove the polygons facing away from camera
Hardware standard
Occlusion culling

Remove the objects hidden by the others
274
Culling (2/2)
View frustum
Occlusion
culling
eye
Visibility
culling
Backface
culling
275
BSP Implementation

A Pre-processor




Space partition the scene data from artist
Generate the BSP data structure
Generate the PVS
BSP walk through


Identify the room where you are
Show/hide the rooms according to the PVS
276
BSP Preprocessor (1/2)

Input





A scene from artist
Cutting planes (optional)
 Can be procedurally generated by algorithm
Cutting policy
 Split or not split
Ray casting resolution for PVS
Output

A BSP file
 BSP Tree
 PVS
 Geometry Data
277
BSP Preprocessor (2/2)

Process





Generate the BSP tree according to the cutting policy
Split or sort the geometry into BSP room (leaves)
For each “room”, ray cast all rooms to generate the possible visible
room set
3D
Time consuming
278
BSP Challenges

Effectiveness of PVS



Data set
Dynamic objects
Room size
279
Game AI
280
Contents




Search
Path finding
Steering behavior
Finite state machines
281
Search

What we will talk about




Blind search



Breadth-first search
Depth-first search
Heuristic search


Blind search
Heuristic search
Adversary search
A*
Adversary search

Minimax
282
Introduction to Search
 Using tree diagram (usually) to describe a search
problem

Search starts




d=2
d=3
d = 0, 1, 2, …
Input


c3
c2
c1, c2, c3…
Search problem

c1
Depth


Goal node g
d=1
Successors


Node i
Goal

i
g
d=4
Description of the initial and goal nodes
A procedure that produces the successors of an arbitrary node
Output

A legal sequence of nodes starting with the initial node and
ending with the goal node.
283
Search Examples in Traditional AI

Game playing



Chess
Backgammon
Finding a path to goal


The towers of Hanoi
Sliding tile puzzles


8 puzzles
Simply finding a goal

n-queens
284
Search Algorithm
1. Set L to be a list of the initial nodes. At any given
point in time, L is a list of nodes that have not yet
been examined.
2. If L is empty, failed. Otherwise, pick a node n
from L.
3. If n is the goal node, stop and return it and the
path from the initial node to n
4. Otherwise, remove n from L and add to L all of n’s
children, labeling each with its path from the
initial node.
5. Return to step 2
285
Depth-First Search (1/3)



Always exploring the child of the most recently
expanded node
Terminal nodes being examined from left to right
If the node has no children, the procedure backs up
a minimum amount before choosing another node to
examine.
1
d=1
9
8
2
3
7
10
4
5
6
11
g
d=2
d=3
d=4
286
Depth-First Search (2/3)



We stop the search when we select the goal node g.
Depth-first search can be implemented by pushing
the children of a given node onto the front of the
list L in step 4 of page 6
And always choosing the first node on L as the one
to expand.
287
Depth-First Search (3/3)

Algorithm




Set L to be a list of the initial nodes in the problem
Let n be the first node on L. If L is empty, fail.
If n is a goal node, stop and return it and path from the
initial node to n.
Otherwise, remove n from L and add to the front of L all
of n’s children, labelling each with its path from the
initial node. Return to step 2.
288
Breadth-First Search (1/2)


The tree examined from top to down, so every node
at depth d is examined before any node at depth d
+ 1.
We can implement breadth-first search by adding
the new nodes to the end of the list L.
1
2
5
d=1
4
3
6
7
9
8
g
10 11
12
d=2
d=3
d=4
289
Breadth-First Search (2/2)

Algorithm




Set L to be a list of the initial nodes in the problem
Let n be the first node on L. If L is empty, fail.
If n is a goal node, stop and return it and path from the
initial node to n.
Otherwise, remove n from L and add to the end of L all of
n’s children, labelling each with its path from the initial
node. Return to step 2.
290
Heuristic Search (1/2)



Neither depth-first nor breadth-first search
Exploring the tree in anything resembling an
optimal order.
Minimizing the cost to solve the problem
1
d=1
2
3
d=3
g
4
d=2
d=4
291
Heuristic Search (2/2)

When we picking a node from the list L in step 2 of
search procedure, what we will do is to remove
steadily from the root node toward the goal by
always selecting a node that is as close to the goal
as possible.

Estimated by distance and minimizing the cost?

A* !
292
Adversary Search



Assumptions
 Two-person games in which the players alternate moves.
 They are games of “perfect” information, where the
knowledge available to each player is the same.
Examples :
 Tic-tac-toe
 Checkers
 Chess
 Go
 Othello
 Backgammon
Imperfect information
 Pokers
 Bridge
293
Minimax (1/6)
Nodes with the maximizer
to move are square; nodes
with the minimizer to move
are circles
“ply”
a
b
e
-1
max
c
d
f
-1
g
1
i -1
h
min
max
j
k
min
1
l
1
Maximizer to achieve the
Outcome of 1; minimizer to
Achieve the outcome of -1
m
-1
1
n
o
p
-1
1
q
max
r
1
min
-1
294
Minimax (2/6)
The maximizer wins!
1
a
-1
-1 e
c 1
b
f
-1
d
min
-1
g 1
1
max
1
i -1
h
max
j
k
min
1
l
1
m
-1
1
n
o
p
-1
1
q
max
r
1
min
-1
295
Minimax (3/6)

Basic idea
1.
2.
3.
4.
Expand the entire tree below n
Evaluate the terminal nodes as wins for the minimizer
or maximizer.
Select an unlabelled node all of whose children have
been assigned values. If there is no such node, return
the value assigned to the node n.
If the selected node is one at which the minimizer
moves, assign it a value that is the minimum of the
values of its children. If it is a maximizing node, assign
it a value that is the maximum of the children’s values.
Return to step 3.
296
Minimax (4/6)

The algorithm
1.
2.
3.
4.
5.
Set L = { n }, the unexpanded nodes in the tree
Let x be the 1st node on L. If x = n and there is a value assigned to
it, return this value.
If x has been assigned a value vx, let p be the parent of x and vp
the value currently assigned to p. If p is a minimizing node, set vp
= min(vp, vx). If p is a maximizing node, set vp = max(vp, vx).
Remove x from L and return to step 2.
If x has not been assigned a value and is a terminal node, assign it
the value 1 or -1 depending on whether it is a win for the
maximizer or minimizer respectively. Assign x the value 0 if the
position is a draw. Leave x on L and return to step 2.
If x has not been assigned a value and is a nonterminal node, set vx
to be –∞ if x is a maximizing node and + ∞ if x is a minimizing node.
Add the children of x to the front of L and return to step 2.
297
Minimax (5/6)

Some issues


Draw
Estimated value e(n)





e(n) =
e(n) =
e(n) =
e(n) =
1 : the node is a win for maximizer
-1 : the node is a win for minimizer
0 : that is a draw
-1 ~ 1 : the others
When to decide stop the tree expanding further ?
298
Minimax (6/6)

The algorithm (final)
1.
Set L = { n }, the unexpanded nodes in the tree
2.
Let x be the 1st node on L. If x = n and there is a value assigned to
it, return this value.
3.
If x has been assigned a value vx, let p be the parent of x and vp
the value currently assigned to p. If p is a minimizing node, set vp
= min(vp, vx). If p is a maximizing node, set vp = max(vp, vx).
Remove x from L and return to step 2.
4.
If x has not been assigned a value and either x is a terminal node
or we have decided not to expand the tree further, compute its
value using the evaluation function. Leave x on L and return to
step 2.
5.
Otherwise, set vx to be –∞ if x is a maximizing node and + ∞ if x is a
minimizing node. Add the children of x to the front of L and return
to step 2.
299
Introduction to Path Finding


A common situation of game AI
Path planning


From start position to the goal
Most popular technique

A* (A Star)
 1968
 A search algorithm
 Favorite teaching example : 15-pizzule
 Algorithm that searches in a state space for the least costly path
from start state to a goal state by examining the neighboring
states
300
A* Algorithm (1/4)
The A* Algorithm
Open : priorityqueue of searchnode
Closed : list of searchnode
AStarSearch( location StartLoc, location GoalLoc, agenttype Agent) {
clear Open & Closed
// initialize a start node
StartNode.Loc = StartLoc;
StartNode.CostFromStart = 0;
StartNode.CostToGoal = PathCostEstimate(StartLoc, GoalLoc, Agent);
StartNode.TotalCost = StartNode.CostToGoal ;
StartNode.Parent = NULL;
push StartNode on Open;
// process the list until success or failure
while Open is not empty {
pop Node from Open // node has the lowest TotalCost
301
A* Algorithm (2/4)
// if at a goal, we’re done
if (Node is a goal node) {
construct a path backward from Node to StartLoc
return SUCCESS;
}
else {
for each successor NewNode of Node {
NewCost = Node.CostFromStart + TraverseCost(Node, NewNode, Agent);
// ignore this node if exists and no improvement
if (NewNode is in Open or Closed) and
(NewNode.CostFromStart <= NewCost) {
continue;
}
else { // store the new or improved information
NewNode.Parent = Node;
NewNode.CostFromStart = NewCost;
NewNode.CostToGoal = PathCostEstimate(NewNode.Loc, GoalLoc, Agent);
NewNode.TotalCost = NewNode.CostFromStart + NewNode.CostToGoal;
if (NewNode is in Closed) {
remove NewNode from Closed
}
302
A* Algorithm (3/4)
if (NewNode is in Open) {
adjust NewNode’s position in Open
}
else {
Push NewNode onto Open
}
}
}
}
push Node onto Closed
}
}
303
A* Algorithm (4/4)

State



Search space






Related to terrain format
Grids
Triangles
Points of visibility
Cost estimate
Path




Location
Neighboring states
Typical A* path
Straight path
Smooth path
Hierarchical path finding
304
Search Space & Neighboring States (1/2)

Rectangular grid


Quadtree


Use grid center
Use grid center
Triangles or convex polygons


Use edge mid-point
Use triangle center
Triangles
Rectangular Grid
Quadtree
305
Search Space & Neighboring States (2/2)


Points of visibility
Generalized cylinders

Use intersections
Points of Visibility
Generalized Cylinders
306
Cost Estimate

Cost function



Minimum cost








CostFromStart
CostToGoal
Distance traveled
Time of traveled
Movement points expended
Fuel consumed
Penalties for passing through undesired area
Bonuses for passing through desired area
…
Estimate

To goal “distance”
307
Result Path
Typical A* Path
Straight Path
Smooth Path
308
Catmull-Rom Spline
Output_point = p1*(-0.5u3 +u2 - 0.5u) +
p2*(1.5u3 – 2.5u2 + 1) +
p3*(-1.5u3 + 2u2 + 0.5u) +
p4*(0.5u3 – 0.5u2)
spline output_points
p2
p1
p3
p4
309
Hierarchical Path Finding

Break the terrain for path finding to several ones
hierarchically




Room-to-room
3D layered terrain
Terrain LOD
Pros


Speedup the search
Solve the problem of layered path finding
310
Path Finding Challenges

Moving goal


Moving obstacles


Prediction Scheme
Complexity of the terrain


Do you need to find path each frame ?
Hierarchical path finding
“Good” path
311
Motion Behavior



Action selection
Steering
Locomotion
A Hierarchy of Motion Behavior
312
Action Selection

Game AI engine






State machine
 Discussed in “Finite State Machine” section
Goals
Planning
Strategy
Scripting
Assigned by players

Players’ input
313
Steering

Path determination



Behaviors







Path finding or path planning
Discussed in “Path Finding”
Seek & flee
Pursuit & evasion
Obstacle avoidance
Wander
Path following
Unaligned collision avoidance
Group steering
314
Locomotion


Character physically-based models
Movement


Animation


Turn right, move forward, …
By artists
Implemented / managed by game engine
315
A Simple Vehicle Model (1/2)

A point mass



Linear momentum
No rotational momentum
Parameters





Mass
Position
Velocity
 Modified by applied forces
 Max speed
 Top speed of a vehicle
Max steering force
 Self-applied
Orientation
 Car
 Aircraft
316
A Simple Vehicle Model (2/2)

Local space





Steering forces


Origin
Forward
Up
Side
Asymmetrical
 Thrust
 Braking
 Steering
Velocity alignment


No slide, spin, …
Turn
317
Euler Integration

The approach :




Steer_force = Truncate(streer_direction, Max_force)
Acceleration = Steer_force / mass
Velocity = Truncate(Velocity + Acceleration, Max_speed)
Position = Position + Velocity
318
Seek & Flee Behaviors

Pursuit to a static target



“A moth buzzing a light bulb”
Flee


Inverse of seek
Variants



Steer a character toward to a target position
Arrival
Pursuit to a moving target
Seek Steering force


desired_velocity = normalize(target - position)*max_speed
steering = desired_velocity – velocity
319
Arrival Behavior

One of the idea : a stopping radius


Outside the radius, arrival is identical to seek
Inside the radius, the speed is ramped down to zero
 target_offset = target – position
 distance = length(target_offset)
 ramped_speed = max_speed*(distance/slowing_distance)
 clipped_speed = minimum(ramped_speed, max_speed)
 desired_velocity = (clipped_speed/distance)*target_offset
 steering = desired_velocity – velocity
320
Pursuit & Evasion Behaviors

Target is moving
Apply seek or flee to the target’s predicted position

Estimate the prediction interval T





T = Dc
D = distance(pursur, quarry)
c = turning parameter
Variants

Offset pursuit
 “Fly by”
321
Obstacle Avoidance Behavior


Use bounding sphere
Not collision detection
steering force

Probe




Find the most threaten obstacle


A cylinder lying along forward axis
Diameter = character’s bounding sphere
Length = speed (means Alert range)
Nearest intersected obstacle
Steering
322
Wander Behavior


Random steering
One solution :



Another one :


Retain steering direction state
 Constrain steering force to the sphere surface located
slightly ahead of the character
Make small random displacements to it each frame
 A small sphere on sphere surface to indicate and
constrain the displacement
Perlin noise
Variants

Explore
323
Path Following Behavior

The path



Following


Spine
 A spline or poly-line to define the path
Pipe
 The tube or generated cylinder by a defined “radius”
A velocity-based prediction position
 Inside the tube
 Do nothing about steering
 Outside the tube
 “Seek” to the on-path projection
Variants


Wall following
Containment
324
Flow Field Following Behavior


A flow field environment is defined.
Virtual reality

Not common in games
325
Unaligned Collision Avoidance Behavior


Turn away from possible collision
Predict the potential collision


Use bounding spheres
If possibly collide,


Apply the steering on both characters
Steering direction is possible collision result
 Use “future” possible position
 The connected line between two sphere centers
326
Steering Behaviors for Groups of Characters


Steering behaviors determining how the character reacts to
the other characters within his/her local neighborhood
The behaviors including :



Separation
Cohesion
Alignment
327
The Local Neighborhood of a Character

The local neighborhood is defined as :


A distance
The field-of-view
 Angle
The Neighborhood
328
Separation Behavior

Make a character to maintain a distance from others nearby.

Compute the repulsive forces within local neighborhood
 Calculate the position vector for each nearby
 Normalize it
 Weight the magnitude with distance
 1/distance
 Sum the result forces
 Negate it
329
Cohesion Behavior

Make a character to cohere with the others nearby

Compute the cohesive forces within local neighborhood
 Compute the average position of the others nearby
 Gravity center
 Apply “Seek” to the position
330
Alignment Behavior

Make a character to align with the others nearby

Compute the steering force
 Average the together velocity of all other characters nearby
 The result is the desired velocity
 Correct the current velocity to the desired one with the steering
force
331
Flocking Behavior

“Boids Model of Flocks”


Combination of :




[Reynolds 87]
Separation steering
Cohesion steering
Alignment steering
For each combination including :



A weight for combing
A distance
An Angle
332
Leader Following Behavior

Follow a leader



Stay with the leader
 “Pursuit” behavior (Arrival style)
Stay out of the leader’s way
 Defined as “next position” with an extension
 “Evasion” behavior when inside the above area
“Separation” behavior for the followers
333
Behavior Conclusion


A simple vehicle model with local neighborhood
Common steering behaviors including :










Seek
Flee
Pursuit
Evasion
Offset pursuit
Arrival
Obstacle avoidance
Wander
Path following
 Wall following
 Containment
 Flow field following
 Unaligned collision avoidance
 Separation
 Cohesion
 Alignment
 Flocking
 Leader following
Combining the above behaviors in your application
334
Introduction to FSM (1/2)

Finite State Machine (FSM) is the most commonly used game
AI technology today.





Simple
Efficient
Easily extensible
Powerful enough to handle a wide variety of situations
Theory (simplified)



A set states, S
An input vocabulary, I
Transition function, T(s, i)
 Map a state and an input to another state
335
Introduction FSM (2/2)

Practical use




State
 Behavior
Transition
 Across states
 Conditions
It’s all about driving behavior
Flow-chart diagram

UML State chart
 Arrow
 Transition
 Rectangle
 State
336
An Example of FSM As a Diagram
Monster in sight
Gather
Treasure
Flee
No monster
Fight
337
FSM for Games



Character AI
“Decision-Action” model
Behavior


Mental state
Transition



Players’ action
The other characters’ actions
Some features in the game world
338
Implement FSM

Code-based FSM



Simple Code One Up
 Straightforward
 Most common
Macro-assisted FSM Language
Data-Driven FSM

FSM Script Language
339
Coding an FSM – Code Example 1
void RunLogic(int *state)
{
switch(*state)
{
case 0: // Wander
Wander();
if (SeeEnemy()) *state = 1;
if (Dead()) *state = 2;
break;
case 1: // Attack
Attack();
*state = 0;
if (Dead()) *state = 2;
break;
case 2: // Dead
SlowlyRot();
break;
}
}
340
Coding an FSM – Code Example 2
void RunLogic(FSM *fsm)
{
// Do action based on the state and determine next input
input = 0;
switch(fsm->GetStateID())
{
case 0: // Wander
Wander();
if (SeeEnemy()) input = SEE_ENEMY;
if (Dead()) input = DEAD;
break;
case 1: // Attack
Attack();
input = WANDER;
if (Dead()) input = DEAD;
break;
case 2: // Dead
SlowlyRot();
break;
}
// DO state transition based on computed input
fsm->StateTransition(input);
}
341
Mealy & Moore Machines

Mealy machine


A Mealy machine is an FSM whose actions are performed on
transitions
Moore machine


A Moore machine’s actions reside in states
More intuitive for game developers
342
FSM Language Use Macros

Coding a state machine directly causes lack of structure



Use macros
Beneficial properties




Going complex when FSM at their largest
Structure
Readability
Debugging
Simplicity
343
FSM Language Use Macros – An Example
#define BeginStateMachine …
#define State(a) …
…
bool MyStateMachine::States(StateMachineEvent event,
int state)
{
BeginStateMachine
State(0)
OnUpdate
Wander();
if (SeeEnemy()) SetState(1);
if (Dead()) SetState(2);
State(1)
OnUpdate
Attack();
SetState(0);
if (Dead()) SetState(2);
State(2);
OnUpdate
RotSlowly();
EndStateMachine
}
344
Data-Driven FSM

Scripting language



Authoring



Text-based script file
Transformed into
 C++
 Integrated into source code
 Bytecode
 Interpreted by the game
Compiler
AI editing tool
Game


FSM script engine
FSM interface
345
Data-Driven FSM Diagram
Authoring
Artist,
Designers, &
Developers
FSMs
AI Editing
Tool
Condition &
Action
Vocabulary
Compiler
Games
bytecode
FSM Script
Engine
FSM Interface
Condition &
Action Code
Game Engine
346
AI Editing Tool for FSM

Pure text



Visual graph with text
Used by Designers, Artists, or Developers


Syntax ?
Non-programmers
Conditions & action vocabulary




SeeEnemy
CloseToEnemy
Attack
…
347
FSM Interface



Facilitating the binding between vocabulary and game world
Glue layer that implements the condition & action
vocabulary in the game world
Native conditions


SeeEnemy(), CloseToEnemy()
Action library

Attack(…)
348
FSM Script Language Benefits




Accelerated productivity
Contributions from artists & designers
Ease of use
Extensibility
349
Processing Models for FSMs

Processing the FSMs



When and how ?


Evaluate the transition conditions for current state
Perform any associated actions
Depend on the exact need of games
Three common FSM processing models



Polling
Event-driven
Multithread
350
Polling Processing Model

Processing each FSM at regular time intervals





Pros




Straightforward
Easy to implement
Easy to debug
Cons


Tied to game frame rate
Or some desired FSM update frequency
Limit one state transition in a cycle
Give a FSM a time-bound
Inefficiency
 Some transition are not necessary to check every frame
Careful design to your FSM
351
Event-driven Processing Model



Designed to prevent from wasted FSM processing
An FSM is only processed when it’s relevant
Implementation





“As-needed” approach


A Publish-subscribe messaging system (Observer pattern)
Allows the engine to send events to individual FSMs
An FSM subscribes only to the events that have the potential to
change the current state
When an event is generated, the FSMs subscribed to that events are
all processed
Should be much more efficient than polling ?
Tricky balance for fine-grained or coarse-grained events
352
Multithread Processing Model


Both polling & event-driven are serially processed
Multithread processing model





Pros


Each FSM is assigned to its own thread for processing
Game engine is running in another separate thread
All FSM processing is effectively concurrent and continuous
Communication between threads must be thread-safe
 Using standard locking & synchronization mechanisms
FSM as an autonomous agent who can constantly and independently
examine and react to his environment
Cons


Overhead when many simultaneous characters active
Multithreaded programming is difficult
353
Interfacing with Game Engine (1/2)

FSMs encapsulate complex behavior logic


Game engine does corresponding


Decision, condition, action, …
Character animation, movements, sounds, …
The interface :



Code each action as a function
 Need recompile if any code is changed
 ie., FleeWolf()
Callbacks
 Function pointers
 ie., actionFunction[fleeWolf]()
Container method
 actionFunctions->FleeWolf();
 DLL
354
Interfacing with Game Engine (2/2)

Take TheFly3D as example:
class AArmyUnit : public FnCharacter
{
…
void DoAttack(…);
}
AArmyUnit *army;
army->Object(…);
army->MoveForward(dist, …);
…
army->DoAttack(…);
355
FSM Efficiency & Optimization

Two categories :



Scheduled processing




Collecting statistics of past performance & extrapolating
Time-bound for each FSM
Do careful design


Priority for each FSM
Different update frequency
Load balancing scheme


Time spent
Computational cost
At the design level
Level-of-detail FSMs
356
Level-Of-Detail FSMs

Simplify the FSM when the player won’t notice the
differences



Outside the player’s perceptual range
Just like the LOD technique used in 3D game engine
Three design keys :



Decide how many LOD levels
 How much development time available ?
 The approximation extent
LOD selection policy
 The distance between the NPC with the player ?
 If the NPC can “see” the player ?
 Be careful the problem of “visible discontinuous behavior”
What kind of approximations
 Cheaper and less accurate solution
357
Extending the Basic FSM

Extending states

Begin-end block
BeginDoAction();
DoActions();
EndDoAction();

Stacks & FSMs




Stack-based “history” of FSMs
 “Remember” the sequence of states passed through
 “Retrace” its steps at will
Hierarchical FSM
Polymorphic FSMs
Fuzzy State Machine

Combined with fuzzy logic
358
A Hierarchical FSM Example
Monster in sight
Gather
Treasure
No monster
Flee
Fight
Go To
Treasure
Find
Treasure
Find
Treasure
Gather
Treasure
Active FSM
Live
Take
Treasure
Stack
359
Another Hierarchical FSM Example
Done
Done
Patrol
Noise
Saw Enemy
Investigate
Attack
Saw Enemy
Patrol
Go to A
Look for
Intruders
noise
Investigate
Report
Noise
Go to B
Look for
Intruders
noise
Go Over
To Noise
Look for
Intruders
False
Alarm!
360
More Topics in Game AI





Scripting
Goal-based planning
Rule-based inference engine
Neural network
References


Game Programming Gems
AI Game Programming Wisdom
361