3D Game Programming Using TheFly3D©

3D Game Programming Using TheFly3D©
王銓彰

課程大綱 Introduction to Game Development (3hr) Game System Analysis (3hr)
The Game Main Loop (3hr) 3D Game Engine Training (TheFly3D) (6hr) Game Mathematics (3hr) Geometry for Games (3hr) Advanced Scene Management System (3hr) Terrain (3hr) Game AI (9hr) Game Physics (3hr) Game FX (3hr) Characters (3hr) Network Gaming (3hr) Introduction to MMOG (3hr) The 2D Sprites (3hr)

課程要求 One Term Project Two Examinations
The Students will divide into several teams Use TheFly3D Game Engine to code a 3D Real-time Strategy Game The Teacher will Provide Graphics Materials Two Examinations Homework will be closely coupled with the term project

王銓彰目前學歷資歷數位內容學院專任講師 / 顧問資策會多媒體研究所專案顧問台灣大學土木工程學系畢業
97-03 昱泉國際股份有限公司技術長 96-96 虛擬實境電腦動畫股份有限公司研發經理 93-96 西基電腦動畫股份有限公司研發經理 90-93 國家高速電腦中心助理研究員 89-90 台灣大學土木工程學系 CAE Lab 研究助理

王銓彰 Game作品昱泉國際西基電腦動畫 DragonFly 3D Game Engine Lizard 3D Game Engine
M2神甲奇兵, VRLobby, 天劍記 Lizard 3D Game Engine 幻影特攻、笑傲江湖 I & II、神鵰俠侶 I & II、風雲、小李飛刀、笑傲江湖網路版、怪獸總動員、聖劍大陸、笑傲外傳西基電腦動畫 Ultimate Fighter – 1st Realtime 3D fighting game in Taiwan

王銓彰專長 (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)

Introduction To Game Development

Game Development Pipeline Game Software System Tools
Introduction to Game Dev Game Platform Game Types Game Team Game Development Pipeline Game Software System Tools

Game Platform PC Console Arcade Mobile Single player Match Makings
MMOG (Massive Multi-player Online Game) Web-based Games Console Sony PS2 MS Xbox Nintedo GameCube Arcade Mobile GBA Hand-held

Game Development on PC Designed for Office Application Not for Entertainment A Virtual Memory System Unlimited memory using But Video Memory is Limited PCI/AGP might be a Challenge Open Architecture Compatibility Test is Important Development is Easy to Setup

Game Development on Console
Specific Hardware Designed for Games Single User / Single Process OS In General no Hard Disk Drive (??) Closed System Very Native Coding Way Proprietary SDK Hardware related features Limited Resources Memory One Console runs, the others do!

Game Types RPG (Role playing games) AVG (Adventure games) RTS (Real-time strategy games) FPS (First-person shooting games) MMORPG SLG (???, 戰棋) Simulation Sports Puzzle games Table games

Game Team Members 開發團隊製作人執行製作人企劃團隊程式團隊美術團隊行銷業務團隊測試團隊遊戲審議委員會

Game Producer 遊戲製作人 Team Leader (always) 資源管理 (Resource Management) 行政管理 (Administration) 向上負責 (Upward Management) 專案管理 (Project Management)

遊戲執行製作人專案管理執行 (Project Management) Daily 運作 House Keeping Not full-time job position

遊戲企劃故事設計 (Story Telling) 腳本設計 (Scripting) 玩法設計 (Game Play Design) 關卡設計 (Level Design) 遊戲調適 (Game Tuning) 數值設定 (Numerical Setup) AI 設計 (Game AI) 音效設定 (Sound FX Setup) 場景設定 (Scene Setup)

遊戲美術場景 (Terrain) 人物 (Character) 建模 (Models) 材質 (Textures) 動作 (Motion / Animation) 特效 (FX) User Interface

遊戲程式遊戲程式 (Game Program) 遊戲開發工具 (Game Tools) Level Editor Scene Editor FX Editor Script Editor 遊戲Data Exporters from 3D Software 3dsMax / Maya / Softimage Game Engine Development Online Game Server Development

遊戲開發流程發想 (Idea) 提案 (Proposal) 製作 (Production) 整合 (Integration)
Basic Procedures for Game Development Idea Proposal Production Integration Testing Debug Tuning Concept Approval Prototype Pre-alpha Alpha Beta Final 發想 (Idea) 提案 (Proposal) 製作 (Production) 整合 (Integration) 測試 (Testing) 除錯 (Debug) 調適 (Tuning) > Concept Approval > 雛形 (Prototype) > Pre-alpha > Alpha > Beta

遊戲發想(Concept Design) 遊戲類型 (Game Types) 遊戲世界觀 (Game World) 故事 (Story) 遊戲特色 (Features) 遊戲玩法 (Game Play) 遊戲定位 (Game Product Positioning) Target player Marketing segmentation / positioning 風險評估 (Risk) SWOT (Strength/Weakness/Opportunity/Threat)

遊戲提案(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)

量產 ! 遊戲開發(Production) 美術量產製作 Modeling Textures Animation Motion FX
程式開發 (Coding) 企劃數值設定 … 量產 !

遊戲整合(Integration) 關卡串聯 (Level Integration) 數值調整 (Number Tuning) 音效置入 (Audio) 完成所有美術程式與美術結合 Focus Group (User Study) Release some playable levels for focus group

遊戲測試(Test) Alpha 測試除錯 (Debug) Beta 測試數值微調 Game play 微調對線上遊戲而言 (MMOG) 封閉測試 (Closed Beta) 開放測試 (Open Beta) 極限測試 (Critical Testing) 線上遊戲才有

Bug 分級 (Bug Classification) A Bug B Bug C Bug S Bug Principles
Bug Dispatch Debug Verify Bug FAQ Y Bug 分級 (Bug Classification) A Bug B Bug C Bug S Bug Principles Bug 分級從嚴 Tester vs Debugger ? N

Game Software System Game Play Layer Engine Layer System Layer Game
Fighting System FX System Game AI Script System NPC System Virtual Agent Trading System Story Game Play Layer Terrain Collision Character UI Dynamics Sound FX Engine Layer 3D Scene Mngmt 2D Sprite Gamepad Network Audio 3D Graphics API 2D API Input Device OS API System Layer Hardware

System Layer – APIs (1/2) 3D Graphics API 2D API Input Device Audio
DirectX 9.0 SDK – Direct3D OpenGL 2.0 2D API DirectX 9.0 SDK - DirectMedia Win32 GDI Input Device DirectX 9.0 SDK – DirectInput Audio DirectX 9.0 SDK – DirectSound / Direct3DSound / DirectMedia OpenAL

System Layer – APIs (2/2) OS API Network Win32 SDK MFC
DirectX 9.0 SDK – DirectPlay Socket library

3D Scene Management System Shaders 2D Sprite System Audio System
Engine Layer (1/2) 3D Scene Management System Scene Graph Shaders 2D Sprite System Audio System Gamepad Hotkey Mouse Timers Network DDK Interface

Advanced Scene Management – Space Partition
Engine Layer (2/2) Terrain Advanced Scene Management – Space Partition BSP Tree Octree Character System Motion Blending Techniques Dynamics Collision Detection SoundFX User Interface

NPC (Non-playable Characters) Game AI
Game Play Modula NPC (Non-playable Characters) Game AI Path Finding Finite State Machine … Avatar Combat System FX System Script System Trading System Number System

Game Development Tools
Visual C/C++ .Net 2003 Visual C/C SP5 DirectX Current 9.0c NuMega BoundsChecker Intel vTune 3D Tools 3dsMax/Maya/Softimage In-house Tools

Game System Analysis

What Will We Talk Here Idea about System Analysis (SA) Mind mapping Case Study - Our Term Project

Why System Analysis (1/2)
For 程式結構 Analysis Program modulus Tools To Identify 工作量 Programs/tools under development For 資源 management Man month How many programmers ? Development tools ? Specific tools ? For Job Dependency Analysis

Why System Analysis (2/2)
To make 技術可行性 Analysis R&D ? Pre-processor for Technical design document Project management Bridge from Game Design to Programming

Something about System Analysis
No Standard Procedures It’s Not a Theory, Just Something Must Be Done! You Can Have Your Own Method UML Mind mapping (心智圖法) This is the one we will use for this course …

My System Analysis Steps
Brainstorming Integration Dependency Analysis Create the Project Write the Technical Design Document (TDD)

Based on the Game Design to Put Everything As Many As You Could
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 / …

Confirm the Resource Limitation Technical Implement Possibility
Integration Confirm the Resource Limitation Technical Implement Possibility Put All Related Items Together Man Month Analysis How many ? Who ? Jobs/System Identification

Prototype for scheduling
Dependency Analysis Sort the Jobs By dependency By programmers Prototype for scheduling

System Analysis – Create the Project
Scheduling Job Assignment Resource Allocation Check points Milestones Risk Management Policy

Write the Technical Design Document
Specification Resources Design in details Implement Methods (工法) Algorithms The Project Output in Each Milestone SOP (optional)

Mind Map 心智圖法 A Radiant Thinking Tool Applications Reference 讀書心得
Proposal 上課筆記遊記 System Analysis … Reference Program Visio MindManager Tony Buzan, Barry Buzan, “The Mind Map Book: How to Use Radiant Thinking to Maximize Your Brain's Untapped Potential”

Mind Map Demo Using MindManager
Use MindManager X5 pro Developed By MindJet

Term Project System Analysis

Game Design (1/3) Real-time Strategy War Game Mission-based Levels Mouse-driven Controls Player vs Computer State-based AI Group Movement

Game Design (2/3) PC – Controlled by Player
“Blue Team” Move Attack AI Standby Anti-attack NPC – Controlled by Computer “Red Team” - Enemy Triggered by time table

Game Design (3/3) Game AI Finite state machine Path finding
Steering behavior Flocks / Schools / Herds AI Game Programming Wisdom, Charles River Media (1 & 2)

Use Mind Map Tool for SA Run MindManager.exe

Game Main Loop

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; }

Win32 Application (2/3) LRESULT CALLBACK KKMainProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { LRESULT l = FALSE; ... // switch for all incoming messages from WindowsX switch (uMsg) { case WM_KEYDOWN: l = TRUE; break; } // echo the result if (l) { return l; else { return DefWindowProc(hWnd, uMsg, wParam, lParam);

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 ...

Event-driven Programming (1/3)
Win32 Programs Are Event-driven Messages = events So as all windows system (for example : X window) We Need a Loop to Check All Incoming Events The Loop Check all incoming events (messages) Handle the events Check timing and do something in regular Incoming Events Interrupts System requests

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 = … 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 …

Therefore, You Can Have Two Types of Jobs (Callbacks) to Do (Call) In regular Timers callbacks By requests Input device callbacks Same As a Game Main Program A game is an interactive application A game is time-bound Rendering in 30fps or 60fps Motion data in 30fps Game running in 30fps …

Implement the Timer (1/6)
Use Performance Counter on PC // 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;

/* 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; }

/* 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; */

/* 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); }

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); } (*(fyTimer[i].timer))(1);

/* 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();

Game Loop (1/2) Single Player Loop y n Check game over
Peek player input Implement timer callback Exit the loop Rendering Loop y n

Game Loop (2/2) Network Client Loop y n From network To network
Check game over Exit n Peek user input Receive messages From network Timer callbacks Send messages To network Rendering

Jobs in Regular (Typically)
Check Win/Loose Check Quit Objects Moving … Play Character’s Motion to Next Frame Play Animation to Next Frame Models Textures … Perform Some Game Calculation Perform Geometry Calculation LOD Perform AI “Thinking” Perform Collision Detection Perform the 3D Rendering

Jobs By Request (Typically)
Mouse Input Press/release the mouse button Drag Double-click Move Keyboard Input Hotkey Typing Gamepad Same as the hotkey Network System …

TheFly3D Game Engine - The Main Program

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); }

Hotkey Callback //------------------- // quit the game
void QuitGame(WORLDid gID, BYTE code, BOOL value) { if (code == FY_ESCAPE) { if (value) { FyWin32EndWorld(gID); }

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.Rotate(X_AXIS, (float) (y - oldY), GLOBAL); oldY = y;

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(); }

What will be included in TheFly3D
Game Combat System FX System Game AI Script System NPC System Virtual Agent Trading System Story Game Play Layer Terrain Collision Character Dynamics Sound FX UI Engine Layer 3D Scene Mngmt 2D Sprite Gamepad Audio Network 3D Graphics API 2D API Input Device OS API System Layer Hardware Under Development

Introduction to TheFly3D
3D Graphics/Game Programming Library Using C++ Based on DirectX9.0a Currently A Frame Work for 3D Graphics Developers According to the Experiences of the Author Some Game Development Features are added Scene Management System Scene tree Built-in Visibility Culling Characters Current version 0.5a1 (1009, 2004) Win32 version

Development Environment
.net2003 Visual C++ 7.1 DirectX9.0a SDK Include files TheFly.h TheFlyWin32.h (win32 version + D3D) Linked libraries TheFlyLibD_05a1.lib d3d9.lib d3dx9.lib

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 include/lib to additional search directories Add d3d9.lib d3dx9.lib to additional dependencies Add TheFly.h, TheFlyWin32.h, TheFlyLibD_xxxx.lib into the project

The 1st TheFly3D Program – hello.cpp
Create a 3D world Create a viewport Create a scene Create 3D entities A camera A teapot model A light source Translate the camera to show the model Bind callbacks to make the program interactive

Demo - Hello Do it!

The Basics to Write TheFly3D Program
All Win32 code is transparent here void main(int argc, char *argv[]) ID & Function class TheFly3D creates the objects for you Return the ID TheFly3D owns the objects You have the right to handle the objects Use function classes // create a viewport vID = gw.CreateViewport(ox, oy, ww, hh); FnViewport vp; vp.Object(vID); vp.SetBackgroundColor(0.3f, 0.3f, 0.0f);

The 1st function to use TheFly3D is
Initialize TheFly3D The 1st function to use TheFly3D is FyWin32CreateWorld() After the calling successfully, you can get the non-zero ID of a world object Assign the ID to a world function for manipulating the world object // create a new world WORLDid gID = FyWin32CreateWorld(Tester", 0, 0, 800, 600, 16, FALSE); FnWorld gw; gw.Object(gID); gw.SetEnvironmentLighting(0.5f, 0.5f, 0.8f); gw.SetTexturePath("Data\\textures");

A world is a set of layers where the 3D objects acts on
The World in TheFly3D A world is a set of layers where the 3D objects acts on A World 3D Graphics Layers Frame Buffers (front + back)

A 3D graphics layer is a projection of the rendering of a 3D world
The 3D Grpahics Layer A 3D graphics layer is a projection of the rendering of a 3D world The 3D world we call the “Scene” The place for projection we call the “Viewport” Backdrop Lights Camera 3D Models Board A 3D Scene

TheFly3D supports the multiple viewports
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 = 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);

Something about the Scene
A scene is not a “real” 3D object, just a “set” of 3D objects A scene provides multiple rendering group concept to handle the 1st priority sorting for the rendering of 3D objects

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 cameras, lights, 3D models, audio sources, billboards, etc., Models Cameras Lights Terrains Objects are created/deleted by his/her host scene Objects can be switched between scenes

The Objects Can … Can have shapes (geometric data) Can be grouped (hierarchy) Can move (transformation) Can look alike (clone or data sharing) Can perform (animation, deformation) Can be affected (lighted, listened) Can be changed (modification)

A Scene Object Parent Object Parameters Etc Motion Data Geometric Data
Hierarchy Parameters Etc Transformation Move Motion Data Animation Geometric Data Shape Clone

An object to carry a set of geometry data is a model object
You can load the model data from files TheFly3D loads .cw3 & .lz3 // create 3D entities nID = scene.CreateModel(ROOT); FnModel model; model.Object(nID); // load a teapot model.Load("Teapot.cw3");

A tree-based representation Simplified scene graph
TheFly3D Scene Tree A tree-based representation Simplified scene graph Root

TheFly3D Scene Tree Is Simplified Scene Graph
A tree-based representation Simplified scene graph Root

Object Hierarchy nID = scene.CreateModel(ROOT);
cID = scene.CreateCamera(ROOT); FnModel model; model.Object(nID); model.SetParent(cID); cID nID

Clone a Model Object instance MODELid nID = scene.CreateModel(ROOT);
FnModel model; model.Object(nID); MODELid nID1 = model.Instance(); nID nID1 Data instance

TheFly3D Model Functions (1/2)
void model.SetParent(parent_object_ID); void model.Show(be_show); void model.SetOpacity(opacity); opacity = 0.0 – 1.0 void model.SetRenderMode(mode); mode = WIREFRAME or TEXTURE MODELid clonedID = Model.Instance(); void model.ChangeScene(sID); BOOL model.Load(char *file); Load a .cw3 or .lz3 model file to a model object void model.ShowBoundingBox(beShow);

TheFly3D Model 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) (TEXTURE_ADDRESS_MODE, WRAP_TEXTURE / MIRROR_TEXTURE / CLAMP_TEXTURE / BORDER_TEXTURE / MIRROR_ONCE_TEXTURE) (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

Every model should have its own local coordinate system (local space)
The space when it’s modeled To its parent model, it is in the global space The space for reference x y z X Y Z

Three basic linear transformations
Translate Rotate Scale Principles Right-handed rule v’ = v M0 M1 Matrix in 12-element (I call the M12) z y x Rotation matrix a0 a1 a2 0 a3 a4 a5 0 a6 a7 a8 0 a9 a10 a11 1 Translation vector

model.Translate(dx, dy, dz, op);
Translation model.Translate(dx, dy, dz, op); x’ = x + dx y’ = y + dy z’ = z + dz (dx dy dz) dx dy dz T =

model.Rotate(Z_AXIS, 30.0f, op);
Rotation i.e. rotate with z axis model.Rotate(Z_AXIS, 30.0f, op); z x’ = x cosq – y sinq y’ = x sinq + y cosq z’ = z y cosq sinq 0 -sinq cosq 0 x Rz =

model.Scale(sx, sy, sz, op);
Scaling model.Scale(sx, sy, sz, op); x’ = x * sx y’ = y * sy z’ = z * sz sx 0 0 0 sy 0 0 0 sz T =

[ML] [M] [MG] Matrix Operations Matrix operation op = LOCAL
REPLACE, LOCAL, GLOBAL Z Y op = LOCAL X z op = REPLACE x [ML] [M] [MG] y op = GLOBAL Object Transformation Matrix

TheFly3D Model Transformation Functions
model.Translate(x, y, z, op); op = LOCAL, GLOBAL, or REPLACE model.Rotate(axis, angle, op); axis = X_AXIS, Y_AXIS, Z_AXIS model.Scale(sx, sy, sz, op); model.Quaternion(w, x, y, z, op); w : the scalar part of the quaternion x, y, z : the vector part of the quaternion The quaternion should be a unit quaternion model.SetMatrix(M12, op); M12 : a M12 matrix float *model.GetMatrix(); Get the pointer of the model object’s matrix

We use movements to control the 3D objects moving around in the scene.
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 / right … Turn right / left Move up Move right Move forward

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

We use Movements to control the 3D objects moving around in the scene.
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. Turn right / left Move up Move right Move forward

Move Forward new position = old position +
distance *(facing direction in unit)

The object has a local coordinate system.
Move Forward (2) The object has a local coordinate system. Align a local axis of the object with the facing direction Make a translation matrix to move the object align the axis Apply the matrix first before to apply the existing transformations Then the object is moving forward! FnModel model; model.Object(nID); model.Translate(0.0f, -dist, 0.0f, LOCAL);

Turn Right/Left An example -1 -1 -1
M = T1 * R1 * R2 * Rx(angle) * R2 * R1 * T1 T1 = / R1 = / cs2 -sn2 0 0 z sn2 cs2 0 0 -x -y -z 1 / / R2 = / cs1 0 -sn Rx = / y cs sn 0 sn1 0 cs sn cs 0 / /

The object has a local coordinate system.
Turn Right/Left (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 axis Apply the matrix first before to apply the existing transformations Then the object is turning! FnModel model; model.Object(nID); model.Rotate(Z_AXIS, -angle, LOCAL); // turn right

Move Forward – Graphics Approach
new position = old position + distance *(facing direction in unit)

Move Forward – Our Approach
The object model has a local coordinate system Align a local axis of the object with the facing direction Make a translation matrix to move the object align the axis Apply the matrix first before to apply the existing transformations Then the object is moving forward! FnModel model; model.Object(nID); model.Translate(0.0f, -dist, 0.0f, LOCAL);

Turn Right/Left – Graphics Approach
An example M = T1 * R1 * R2 * Rx(angle) * R2 * R1 * T1 T1 = / R1 = / cs2 -sn2 0 0 z sn2 cs2 0 0 -x -y -z 1 / / R2 = / cs1 0 -sn Rx = / y cs sn 0 sn1 0 cs sn cs 0 / /

Turn Right/Left – Our Approach
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 axis Apply the matrix first before to apply the existing transformations Then the object is turning! FnModel model; model.Object(nID); model.Rotate(Z_AXIS, -angle, LOCAL); // turn left

Terrain A terrain is a place for 3D objects to walk on A terrain is generated from a model object 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

Terrain in TheFly3D // create a terrain object
tID = scene.CreateTerrain(); FnTerrain t; t.Object(tID); // load a terrain model (just like a regular model) // but a terrain is invisible in default t.Load("test_terrain_following.cw3"); // generate the neighboring data for terrain following t.GenerateTerrainData();

Terrain Following Terrain Following (3D) offset Terrain Following (2D)

TheFly3D Model Movement Functions (1/2)
void model.GetPosition(pos); pos is a 3D vector to get the position of the model object void model.GetDirection(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); The position is related to its parent object void model.SetDirection(faceDIr, upDir); 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 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

Probe for a Model on Terrain
probeBack probeFront : terrain following check point

TheFly3D Model Movement Functions (2/2)
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. void model.TurnRight(float angle); Angle is in degree

Character Introduction

Motion Production – by 3D Tools
Keyframe System 3DS MAX Softimage Maya ... Low Cost (Relatively) Easy to Combine Animations Hard to Make “Good” Motions Long Production Time

Motion Production – by Motion Capture
Optical Magnetic ... Costly Investment Every Frame is a Keyframe Very Live Motion Need Post-processing for Games Hard to Combine Motions

A segmented character :
A character is composed by a set of models with motion data to simulate a live creature in real world A segmented character : head up arm hand body groin fore arm thigh foot shin

The scene tree of a segmented character :
Base groin body thigh_r head thigh_l up_arm_r shin_r up_arm_l shin_l fore_arm_l fore_arm_r foot_r hand_l hand_r foot_l

The Root-Base Concept (1/2)
Use root-base structure to construct the character Base Root (groin) Base

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.

A set of frames to describe a character’s motion Walk, run, attack, …
Motion Data - Pose A set of frames to describe a character’s motion 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

Load a Character FnScene scene; .lxx is a character
CHARACTERid actorID; Scene.Object(sceneID); actorID = scene.LoadCharacter("m012.lxx"); actorID = scene.LoadCharacter(“m60a3.lzc”); .lxx is a character description file which is a bone-skin character .lzc is a segmented character file

Play a Pose BLENDTREEid btID = actor.GetBlendTree(); FnBlendTree bt;
bt.Object(btID); aaaID = bt.CreateAnimationNode(2); // 2nd motion // start to play a pose (1st time) actor.PlayBlendNode(aaaID, (float) 0, START, TRUE); // continue to play a pose actor.PlayBlendNode(CURRENT_ONE, (float) skip, LOOP, TRUE);

Make a Character to Move Forward
FnCharacter actor; // play walking pose actor.Object(actorID); actor.PlayBlendNode(CURRENT_ONE, (float) skip, LOOP, TRUE); // move it forward actor.MoveForward(dist, beTF, be3D, offset);

TheFly3D Character Movement Functions (1/2)
void actor.GetPosition(pos); pos is a 3D vector to get the position of the character void actor.GetDirection(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); The position is related to its parent object void actor.SetDirection(faceDIr, upDir); 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

TheFly3D Character Movement Functions (2/2)
void actor.MoveForward(dist, beTerrainFollow, be3D, offset); If you just want to move the character forward but not on terrain, set beTerrainFollow 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

TheFly3D Character Functions
MODELid actor.GetBaseObject(); You can get the base object of the character MODELid actor.GetObjectByName(name); 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); The function is to play the motion for a specific frame Set beIncludeBase = TRUE to play the base object’s motion BLENDTREEid actor.GetBlendTree(); 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!

Game Mathematics

Fixed-point Real Numbers Triangle Mathematics Intersection Issues
Essential Mathematics for Game Development Matrices Vectors Fixed-point Real Numbers Triangle Mathematics Intersection Issues Euler Angles Angular Displacement Quaternion Differential Equation Basics

Matrices Matrix basics Definition Transpose Addition a11 .. a1n . .
am1 .. amn A = (aij) = C = A T cij = aji C = A + B cij = aij + bij

Scalar-matrix multiplication
Matrix-matrix multiplication C = aA cij = aaij r C = A B cij = Saikbkj k = 1

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

Translation Transformation
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 V’ = VT Tx Ty Tz 1 [x’ y’ z’ 1] = [x y z 1] = [x y z 1] T

Scaling Transformation
x’ = xSx y’ = ySy z’ = zSz V’ = VS Sx 0 Sy Sz 0 [x’ y’ z’ 1] = [x y z 1] = [x y z 1] S Here Sx, Sy and Sz are scaling factors.

Rotation Transformations
0 cosq sinq 0 0 -sinq cosq 0 Rx = Ry = Rz = cosq 0 -sinq 0 sinq 0 cosq 0 cosq sinq 0 0 -sinq cosq 0 0

Net Transformation matrix
Matrix multiplication are not commutative [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 [x” y” z” 1] = [x y z 1] M3 M1 M2 = M2 M1

A vector is an entity that possesses magnitude and direction.
Vectors 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)

Addition of vectors Length of vectors X = V + W = (x1, y1, z1)
= (v1 + w1, v2 + w2, v3 + w3) W V + W W V + W V V |V| = (v12 + v22 + v32)1/2 U = V / |V|

Cross product of vectors
Definition Application A normal vector to a polygon is calculated from 3 (non-collinear) vertices of the polygon. 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) Np polygon defined by 4 points V2 Np = V1 X V2 V1

J the Jacobian matrix, Ji(x) = dF(x) dxi
Normal vector transformation N(X) = detJ J-1T N(x) where X = F(x) J the Jacobian matrix, Ji(x) = dF(x) dxi "Global and Local Deformations of Solid Primitives" Alan H. Barr Computer Graphics Volume 18, Number 3 July 1984 (take scaling as example)

Dot product of vectors Definition Application |X| = V . W
= v1w1 + v2w2 + v3w3 V q W V . W cosq = |V||W|

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 1 1 1 8 fractional bits ă = 315, a =

Fixed Point Arithmetics (2/2)
Multiplication then Requires Rescaling Addition just Like Normal e = a.c = ă / 28 . ĉ / 28  ĕ = (ă . ĉ) / 28 e = a+c = ă / 28 + ĉ / 28  ĕ = ă + ĉ

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

Triangular Coordinate System
ha (xa,ya,za) Ac p hb Ab h (xb,yb,zb) Aa hc (xc,yc,zc) Aa Ab Ac h = ha hb hc where A = Aa + Ab + Ac If (Aa < 0 || Ab < 0 || Ac < 0) than the point is outside the triangle “Triangular Coordinate System” A A A

Triangle Area – 2D Area of a triangle in 2D xa ya A = ½ xb yb xc yc
= ½ (xa*yb + xb*yc + xc*ya – xb*ya – xc*yb – xa*yc) (xa,ya,za) (xb,yb,zb) (xc,yc,zc)

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; }

Triangular Coordinate System - Application
Terrain Following Hit Test Ray Cast Collision Detection

Intersection Ray Cast Containment Test

Ray Cast – The Ray x = x0 + (x1 – x0) t y = y0 + (y1 – y0) t, t = 0, z = z0 + (z1 – z0) t { Shot a Ray to Calculate the Intersection of the Ray with Models Use Parametric Equation for a Ray 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

Ray Cast – The Plane Each Triangle in the 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 Check the Intersect Point Within the Triangle or not by Using “Triangle Area Test” (p. 154)

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 = y , t = 0, { 8 “if the No. of intersection is odd, the point is inside, otherwise, is outside”

Same as the 2D containment test
“if the No. of intersection is odd, the point is inside, otherwise, is outside”

There are 6 possible ways to define a rotation
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 There are 6 possible ways to define a rotation 3! R(q1, q2, q3) represents an x-roll, followed by y-roll, followed by z-roll R(q1, q2, q3) = c2c c2s s s1s2c3-c1s3 s1s2s3+c1c3 s1c2 0 c1s2c3+s1s3 c1s2s3-s1c3 c1c2 0 where si = sinqi and ci = cosqi

Euler Angles & Interpolation
Interpolation happening on each angle Multiple routes for interpolation More keys for constrains R z z y y x x R

R(q, n), n is the rotation axis
Angular Displacement R(q, n), n is the rotation axis rh = (n.r)n rv = r - (n.r)n , rotate into position Rrv V = nxrv = nxr 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 rv V q r r Rr rh n n V rv q Rrv

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

Quaternion Algebra q1 = (s1, v1) and q2 = (s2, v2)
q3 = q1q2 = (s1s2 - v1.v2 , s1v2 + s2v1 + v1xv2) 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) Noncommutative

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)

Quaternion VS Rotation Matrix
1-2y2-2z2 2xy-2wz 2xz+2wy 0 2xy+2wz x2-2z2 2yz-2wx 0 2xz-2wy 2yz+2wx 1-2x2-2y2 0 q = (w,x,y,z)

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; } 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]; M0 M1 M2 0 M3 M4 M5 0 M6 M7 M8 0

Quaternion Interpolation
Spherical linear interpolation, slerp A P t B f sin((1 - t)f) sin(tf) slerp(q1, q2, t) = q q2 sinf sinf

Differential Equation Basics
Initial value problems ODE Ordinary differential equation Numerical solutions Euler’s method The midpoint method

Initial Value Problems
An ODE Vector field Solutions Symbolic solution Numerical solution . 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 . . Start here Follow the vectors …

Discrete time steps starting with initial value
Euler’s Method x(t + Dt) = x(t) + Dt f(x, t) A numerical solution A simplification from Tayler series Discrete time steps starting with initial value Simple but not accurate Bigger steps, bigger errors O(Dt2) errors Can be unstable Not even efficient

The Midpoint Method Error term . ..
Concept : x(t0 + h) = x(t0) + h x(t0) + h2/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

The Runge-Kutta Method
Midpoint = Runge-Kutta method of order 2 Runge-Kutta method of order 4 O(h5) k1 = h f(x0, t0) k2 = h f(x0 + k1/2, t0 + h/2) k3 = h f(x0 + k2/2, t0 + h/2) k4 = h f(x0 + k3, t0 + h) x(t0+h) = x0 + 1/6 k1 + 1/3 k2 + 1/3 k3 + 1/6 k4

Initial Value Problems - Application
Dynamics Particle system Game FX System

Game Geometry

Game Models Geometry Topology Property Motion Hierarchy
Position / vertex normals / vertex colors / texture coordinates Topology Primitive Lines / triangles / surfaces / … Property Materials Textures Motion Hierarchy Level-of-detail

Texture coordinates on vertex Skin weights
Geometry Data Vertex position (x, y, z, w) In model space or screen spane Vertex normal (nx, ny, nz) Vertex color (r, g, b) or (diffuse, specular) Texture coordinates on vertex (u1, v1), (u2, v2), … Skin weights (bone1, w1, bone2, w2, …)

Topology Data Lines Indexed triangles Triangle Strips / Fans Surfaces
Line segments Polyline Open / closed Indexed triangles Triangle Strips / Fans Surfaces Non-uniform Rational B Spline (NURBS) Subdivision

Indexed Triangles Geometric data Topology Vertex data
v0, v1, v2, v3, … (x, y, z, nx, ny, nz, tu, tv) or (x, y, z, cr, cg, cb, tu, tv, …) Topology Face v0 v3 v6 v7 Edge table polygon normal v0 vertex normal v7 v3 v6 Right-hand rule for index

Triangle Strips v0 , v1 , v2 , v3 , v4 , v5 , v6 , v7
“Get great performance to use triangle strips for rendering on current hardware

Property on Surface Material Textures Shaders

For fixed function rendering pipeline
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 For fixed function rendering pipeline

Textures Textures Single texture Texture coordinate animation
Texture animation Multiple textures Alphamap Lightmap Base color texture Material or vertex colors

Programmable Shading Language
Shaders Programmable Shading Language Vertex shader Pixel shader Procedural way to implement some process of rendering Transformation Lighting Texturing BRDF Rasterization Pixel fill-in

Shader Pipeline Geometry Stage Rasterizer Stage Vertex Data
Topology Data Classic Transform & Lighting Vertex Shader Geometry Stage Clipping & Viewport Mapping Texturing Pixel Shader Rasterizer Stage Fog Alpha, Stencil, Depth Testing

Powered by Shader Per-pixel lighting Procedural Morphing Motion blur
Volume / Height fog Volume lines Depth of field Fur fighting 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

Motion Data Time-dependent data Transformation data Formats Position
Orientation Formats Pivot Position vector Quaternion Eurler angles Angular displacement

Level-of-detail Discrete LOD Continuous LOD View-dependent LOD
Switch multiple resolution models run-timely Continuous LOD Use progressive mesh to dynamically reduce the rendered polygons View-dependent LOD Basically for terrain

Progressive Mesh Render a Model in Different Level-of-Detail at Runtime User-Controlledly or Automatically Change the Percentage of Rendered Vertices Use Collapse Map to Control the Simplification Process Collapse map Vertex list Triangle list Index 1 2 3 4 5 6 7 8 Map 1 2 3 4 5 6 7 8 2 5 1 3 8 6 4

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 level-of-detail Very good for fly-simulation-like application

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

A Model File Format, CW3 - Introduction
With .cw3 extension A generic file form used in TheFly3D ASCII format Current Version 1.0 alpha

A Model File Format, CW3 - Example
# CW3 model file, designed by Chuan-Chang Wang Model v 1 VertexType position color texture 2 2 2 UseVertexShader VertexColor_tex1.lvs Material 2 AnimTexture aaa 6 MultiTexture 2 a008 aaa00 Effect TextureMap 0 Lightmap 1 Vertex 1 6 Polygon 2 both both version vertex type vertex shader used materials vertices topology

Axis-aligned bounding box (AABB) Oriented bounding box (OBB)
Bounding Volume Bounding sphere Bounding cylinder Axis-aligned bounding box (AABB) Oriented bounding box (OBB) Discrete oriented polytope (k-DOP) Bounding Sphere AABB k-DOP Bounding Cylinder OBB

Bounding Volume - Application
Collision Detection Visibility Culling Hit Test

Application Example - Bounding Sphere
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)

Application Example - AABB
Axis-aligned bounding box (AABB) Simplified calculation using axis-alignment feature But need run-timely to track the bounding box AABB

Application Example - OBB
Oriented bounding box (OBB) Need intersection calculation using the transformed OBB geometric data 3D containment test Line intersection with plane For games,  OBB

Advanced Scene Management

This is a game-type-oriented issue Bounding Volume Hierarchies (BVHs)
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

Bounding Volume Hierarchies (BVHs)
Bounding spheres in hierarchy R B

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.

Axis-aligned BSP Tree plane0 plane3 1 2 plane2 plane1 3

Polygon-aligned BSP Tree
F A C G B A B C D E D E F G

Quickly to identify where you are
Why BSP Tree ? Quickly to identify where you are BSP = Sorting Need a pre-processor to generate the PVS 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, , (Proc. SIGGRAPH’80)

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

Quadtree - Example

Octree – Some Discussion
Data structure coherence Apply visibility culling from parents Split or not split ? Outdoor game scene ?

Culling means “remove from a flock” Visibility culling
Remove the object not in view frustum A “must” for game engine Backface culling Remove the polygons facing away from camera Hardware standard Occlusion culling Remove the objects hidden by the others

Culling (2/2) View frustum Occlusion culling eye Visibility Backface

BSP Implementation A Pre-processor BSP Walk Through
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

Input Output BSP Preprocessor (1/2) 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

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

BSP Challenges Effectiveness of PVS Data set Dynamic Objects Room size

Terrain

Introduction Game Type Oriented Terrain Terrain Following Path Finding
For visual (廣義的場景) Ground / Building / Static models / Dynamic models For terrain following Polygon mesh Grids For path finding Terrain Following Make a 3D entity walking on terrain Path Finding Find a path before walking

Terrain Formats Grid Height map ROAM Triangular Mesh 2D Quadtree
Procedural height map ROAM Real-time Optimally Adapting Meshes Triangular Mesh Procedurally generated Created by artists Perlin Noise

Grid Map 2D Grid Map Step Look Terrain Application
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

Almost as Same as 2D Grid Map but
Height Map Almost as Same as 2D Grid Map but Height on grid vertex Only height is saved Regular grid Irregular grid but structured Application As the base data structure for ROAM terrain Water simulation Top view

Real-time Optimally Adapting Mesh Application
ROAM Real-time Optimally Adapting Mesh Application Fly-simulation

Use quad tree to construct the level-of-detail of terrain
Chunked LOD Terrain Use quad tree to construct the level-of-detail of terrain A quad tree for LOD

Possibly the Most Popular Way for Games
Triangular Mesh Possibly the Most Popular Way for Games General Can be created by artists Multiple-layered Terrain

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

Create cohesive relationship between triangles using “half edge”
Use half-edge table to search the neighboring triangles Edge = two halves

Half-edge (2/2) http://www.flipcode.com/tutorials/tut_halfedge.shtml
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

Game AI Path Finding

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

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

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

A* Algorithm (3/4) if (NewNode is in Open) {
adjust NewNode’s position in Open } else { Push NewNode onto Open push Node onto Closed

Hierarchical Path Finding
A* Algorithm (4/4) State Location Neighboring states Search Space Related to terrain format Grids Triangles Points of visibility Cost Estimate Path Typical A* path Straight path Smooth path Hierarchical Path Finding

Search Space & Neighboring States (1/2)
Rectangular Grid Use grid center Quadtree Triangles or Convex Polygons Use edge mid-point Use triangle center Rectangular Grid Triangles Quadtree

Search Space & Neighboring States (2/2)
Points of Visibility Generalized Cylinders Use intersections Points of Visibility Generalized Cylinders

Cost Estimate Cost Function Minimum Cost Estimate CostFromStart
CostToGoal Minimum Cost 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”

Result Path Typical A* Path Straight Path Smooth Path

Catmull-Rom Spline Output_point = p1*(-0.5u3 +u2 - 0.5u) +
spline output_points p2 p3 p1 p4

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

Path Finding Challenges
Moving Goal Do you need to find path each frame ? Moving Obstacles Prediction Scheme Complexity of the Terrain Hierarchical path finding “Good” Path

Game AI Steering Behavior & Group Movement

Autonomous Characters
Introduction Reference Craig W. Reynolds 1987 “Flocks, Herds, and Schools: A Distributed Behavioral Model”, Siggraph’87 Proceedings 1999 “Steering Behaviors for Autonomous Characters”, GDC Proceedings* Autonomous Characters Autonomous agents NPCs in Games Related Work Robotics Artificial Intelligence (AI) Artificial Life

Motion Behavior Action Selection Steering Locomotion
A Hierarchy of Motion Behavior

Action Selection Game AI engine Scripting Assigned by player
State machine Discussed in next chapter Goals Planning Strategy Scripting Assigned by player

Discussed in This Chapter Path Determination
Steering Discussed in This Chapter Path Determination Path finding or path planning Discussed in the last chapter Behaviors Seek & flee Pursuit & evasion Obstacle Avoidance Wander Path following Unaligned collision avoidance Group Steering

Character Physically-based Models Movement Animation
Locomotion Character Physically-based Models Movement Turn Right, Move forward, … Animation Quaternion Implemented / Managed by Game Engine

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

A Simple Vehicle Model (2/2)
Local Space Origin Forward Up Side Steering Forces Asymmetrical Thrust Braking Steering Velocity Alignment No slide, spin, … Turn

Euler Integration Steer_force = Truncate(streer_direction, Max_force) Acceleration = Steer_force / mass Velocity = Truncate(Velocity + Acceleration, Max_speed) Position = Position + Velocity

Pursuit to a Static Target Seek Steering force
Seek & Flee Behaviors Pursuit to a Static Target Steer a character toward to a target position Seek Steering force desired_velocity = normalize(target - position)*max_speed steering = desired_velocity – velocity “A moth buzzing a light bulb” Flee Inverse of Seek Variants Arrival Pursuit to a moving target

Arrival Behavior 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

Pursuit & Evasion Behaviors
Target Character is Moving Apply Seek or Flee to the Target’s Predict Position Estimate the Prediction Interval T T = Dc D = distance(Pursur, Quarry) c = turning parameter Variants Offset pursuit “Fly by”

Obstacle Avoidance Behavior
Use Bounding Sphere Not Collision Detection Probe A cylinder lying along forward axis Diameter = character’s bounding sphere Length = speed (means Alert range) Find the most Threaten Obstacle Nearest intersected obstacle Steering

Wander Behavior Random Steering One Solution : Another one : Variants
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 Another one : Perlin noise Variants Explore Forage

Path Following Behavior
A Path Spine A spline or poly-line to define the path Pipe The tube or generated cylinder by a defined “radius” Following 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

Flow Field Following Behavior
A Flow Field Environment is Defined Virtual Reality Not common in games

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

Steering Behaviors for Groups of Characters
Steering Behaviors Determining How the Character Reacts to the Other Characters within His Local Neighborhood The Behaviors include Separation Cohesion Alignment

The Local Neighborhood of a Character
The Local Neighborhood is Defined A distance The field-of-view Angle The Neighborhood

Make a Character to Maintain a Distance from Others Nearby
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

Make a Character to Cohere with the others Nearby
Cohesion Behavior Make a Character to Cohere with the others Nearby Compute the cohesive forces within local neighborhood Compute the average position of the other nearbys Gravity center Apply “Seek” to the position

Make a Character to Align with the Others Nearby
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

Flocking Behavior Boids Model of Flocks Combination of
[Reynolds 87] Combination of Separation steering Cohesion steering Alignment steering For Each Combination A weight for combing A distance An Angle

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

A Simple Vehicle Model with Local Neighborhood
Behavior Conclusion A Simple Vehicle Model with Local Neighborhood Common Steering Behaviors 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 Behaviors

Game AI Finite State Machine

Introduction (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

Introduction (2/2) Practical Use Flow-chart Diagram State Transition
Behavior Transition Across states Conditions It’s all about driving behavior Flow-chart Diagram UML State Chart Arrow Rectangle

An Example of FSM As a Diagram
Monster in sight Gather Treasure Flee No monster Monster dead Cornered Fight

“Decision-Action” Model Behavior Transition
FSM for Games Character AI “Decision-Action” Model Behavior Mental State Transition Players’ action The other characters’ actions Some features in the game world

Implement FSM Code-based FSM Data-Driven FSM Simple Code One Up
Straightforward Most common Macro-assisted FSM Language Data-Driven FSM FSM Script Language

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; case 2: // Dead SlowlyRot(); }

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; case 2: // Dead SlowlyRot(); } // DO state transition based on computed input fsm->StateTransition(input);

Mealy & Moore Machines Mealy Machine Moore 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

FSM Language Use Macros
Coding a State Machine Directly Causes Lack of Structure Going complex when FSM at their largest Use Macro Beneficial Properties Structure Readability Debugging Simplicity

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) Attack(); SetState(0); State(2); RotSlowly(); EndStateMachine }

Data-Driven FSM Scripting Language Authoring Game
Text-based script file Transformed into C++ Integrated into source code Bytecode Interpreted by the game Authoring Compiler AI editing tool Game FSM script engine FSM interface

Data-Driven FSM Diagram
Authoring Games FSMs bytecode FSM Script Engine Compiler Artist, Designers, & Developers AI Editing Tool FSM Interface Condition & Action Code Game Engine Condition & Action Vocabulary

Used by Designers, Artists, or Developers
AI Editing Tool for FSM Pure Text Syntax ? Visual Graph with Text Used by Designers, Artists, or Developers Non-programmers Conditions & Action Vocabulary SeeEnemy CloseToEnemy Attack …

Facilitating the Binding between Vocabulary and Game World
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(…)

FSM Script Language Benefits
Accelerated Productivity Contributions from Artists & Designers Ease of Use Extensibility

Processing Models for FSMs
Processing the FSMs Evaluate the transition conditions for current state Perform any associated actions When and How ? Depend on the exact need of games Three Common FSM Processing Models Polling Event-driven Multithread

Polling Processing Model
Processing Each FSM at Regular Time Intervals Tied to game frame rate Or some desired FSM update frequency Limit one state transition in a cycle Give a FSM a time-bound Pros Straightforward Easy to implement Easy to debug Cons Inefficiency Some transition are not necessary to check every frame Careful Design to Your FSM

Event-driven Processing Model
Designed to Prevent from Wasted FSM Processing An FSM is Only Processed When It’s relevant Implementation 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 “As-needed” Approach Should be much more efficient than polling ? Tricky Balance for Fine-grained or Coarse-grained Events

Multithread Processing Model
Both Polling & Event-Driven are Serially Processed Multithread Processing Model 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 Pros 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

Interfacing with Game Engine (1/2)
FSMs Encapsulate Complex Behavior Logic Decision, condition, action, … Game Engine Does Corresponding 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

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(…);

FSM Efficiency & Optimization
Two Categories : Time spent Computational cost Scheduled Processing Priority for each FSM Different update frequency Load Balancing Scheme Collecting statistics of past performance & extrapolating Time-bound for Each FSM Do careful design At the design level Level-of-detail FSMs

Simplify the FSM When the Player Won’t Notice the Differences
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

Extending the Basic FSM
Extending States Begin-end block 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 BeginDoAction(); DoActions(); EndDoAction();

A Hierarchical FSM Example
Monster in sight Gather Treasure No monster Flee Monster dead Fight Cornered Find Treasure Active FSM Go To Treasure Gather Treasure Find Treasure Live Take Treasure Stack

Another Hierarchical FSM Example
Done Patrol Done Noise Investigate Saw Enemy Attack Saw Enemy Patrol Go to A Look for Intruders Go to B Look for Intruders noise noise Investigate Report Noise Go Over To Noise Look for Intruders False Alarm!

Rule-based Inference Engine Neural Network References
More Topics in Game AI Scripting Goal-based Planning Rule-based Inference Engine Neural Network References Game Gems AI Game Programming Wisdom

Game Physics

Introduction to Game Physics
Traditional Game Physics Particle system Rigid body dynamics Flexible body dynamics Some State-of-art Topics Car physics Fluid dynamics Rag-doll physics Physics Rigid body kinematics Newton’s Laws Forces Momenta Energy

Basic Concepts from Physics (1/2)
Newton’s Laws 1st Law “靜者恆靜，動者恆成等速度運動” 2nd Law F = ma = mdv/dt 3rd Law 作用力與反作用力 Forces Gravity / Spring forces / Friction / Viscosity Torque  = r X F Equilibrium

Basic Concepts from Physics (2/2)
Momenta Linear momentum Angular momentum Moment of inertia

Particles are objects with Mass Position Velocity Respond to forces
Particle Dynamics Particles are objects with Mass Position Velocity Respond to forces But no spatial extent (no size!) Point mass Based on Newton Laws f = ma x = f / m v = f / m, x = v .. . .

Basic Particle System x v f m typedef struct { float m; /* mass */
float *x; /* position */ float *v; /* velocity */ float *f; /* force accumulator */ } *Particle; Particle *p /* array of pointers to particles */ int n; /* number of particles */ float t; /* simulation clock */ } *ParticleSystem; states x v f m x v f m x v f m x v f m x v f m Particle n time …

/* gather states from the particles */
void ParticleGetState(ParticleSystem p, float *dst) { int i; for (i = 0; i < p->n; i++) { *(dst++) = p->p[I]->x[0]; *(dst++) = p->p[I]->x[1]; *(dst++) = p->p[I]->x[2]; *(dst++) = p->p[I]->v[0]; *(dst++) = p->p[I]->v[1]; *(dst++) = p->p[I]->v[2]; } }

/* scatter states into the particles */
void ParticleSetState(ParticleSystem p, float *src) { int i; for (i = 0; i < p->n; i++) { p->p[i]->x[0] = *(src++); p->p[i]->x[1] = *(src++); p->p[i]->x[2] = *(src++); p->p[i]->v[0] = *(src++); p->p[i]->v[1] = *(src++); p->p[i]->v[2] = *(src++); } }

/* calculate derivative, place in dst */
void ParticleDerivative(ParticleSystem p, float *dst) { int i; ClearForce(p); ComputeForce(p); for (i = 0; i < p->n; i++) { *(dst++) = p->p[i]->v[0]; *(dst++) = p->p[i]->v[1]; *(dst++) = p->p[i]->v[2]; *(dst++) = p->p[i]->f[0]/p->p[i]->m; *(dst++) = p->p[i]->f[1]/p->p[i]->m; *(dst++) = p->p[i]->f[2]/p->p[i]->m; } }

/* Euler Solver */ void EulerStep(ParticleSystem p, float DeltaT) { ParticleDeriv(p, temp1); ScaleVector(temp1, DeltaT); ParticleGetState(p, temp2); AddVector(temp1, temp2, temp2); ParticleSetState(p, temp2); p->t += DeltaT; }

Rigid Body Dynamics Mass of a Body Force Torque Inertia Tensor
Mass center Force Linear momentum P(t) = M v(t) Velocity (v) Torque Angular momentum L(t) = I w(t) Local rotation (w) Inertia Tensor Reference www-2.cs.cmu.edu/afs/cs/user/baraff/www/pbm

Flexible Body Dynamics (1/2)
Particle-Spring Model F = k x Not a stress-strain model Lack of Elasticity, Plasticity, & Viscous-Elasticity Can be unstable

Flexible Body Dynamics (2/2)
Finite Element Method 有限元素法 Solver for ODE/PDE Boundary conditions Energy equation Stress-strain model Very complicated computing process Conservation of Energy

Advanced Topics in Game Physics
Fracture Mechanics (破壞力學模擬) Fluid Dynamics (流體力學) Car Dynamics (車輛動力學) Rag-doll Physics (人體物理模擬)

Game FX

Introduction to Game FX
Improve the Visual & Sound Game Effects Includes Combat FX Environment FX Character FX Scene FX Sound FX FX Editor Needed General 3D animation tools can not do it Key-frame system is not working FX animation is always Procedurally Related to the previous frame Small Work But Large Effect

FX Editing Tool

Combat FX During the Combat After the Combat FX Editor
Weapon motion blur Weapon effect Skill effect After the Combat Damage effect FX Editor

Combat FX Example

Motion Blur – Image Solution
Computer Animation : Image solution Blending rendered image sequence Render too many frames Divide the frames Average Done!

Motion Blur – Geometry Solution
In Games, Use Transparent Objects to Simulate the Motion Blur “False” Motion Blur Tracking the motion path of the object Connecting them as a triangular mesh Use time-dependent semi-transparency to simulate the “blur” The path can be smoothed using Catmull-Rom spline Local stability of the curve

FX Uses Texture Animation
Almost All Game FXs Use this Trick Geometry Object on which the Texture Animation Playing Billboard 3D Plate Cylinder Sphere Revolving a cross section curve Texture Sequence with Color-key Semi-transparent Textures Alpha blending Source color added to background Demo!!!!

Particle System for FXs in Combat
The FXs Fire / exposure / smoke / dust Initial Value + Time dependency Combined with Billboard FX Billboard to play the texture animation Particle system to calculate the motion path Gravity is the major force used Emitter pattern Single emitter Area emitter Emitter on vertices Demo !!!

Environment FX Weather Fog Day & Night Use particle system
Rain Snow Wind Fog Traditional fog From near to far Hardware standard feature Volume fog Layered fog Use vertex shader Day & Night

Rendering Effects on Skins
Character FX Fatality Case by case and need creative solutions Rendering Effects on Skins Environment mapping Bump map Normal map Multiple texture map Flexible body Flexible body dynamics Fur Real-time fur rendering …

Scene FX – Sky Box Use a very large box or dome-like model to surround the whole game scene Use textures on the box or dome as the backdrop Use multiple textures and texture coordinates animation to simulate the moving of the clouds

Scene FX – Len’s Flare Runtime calculate the position and orientation of the camera with the sun Put textures to simulate the len’s flare

Scene FX – Light Scattering
Atmospheric Light Scattering Caused by dust, molecules, or water vapor These can cause light to be: Scattered into the line of sight (in-scattering) Scattered out of the line of sight (out-scattering) Absorbed altogether (absorption) Skylight and sun light Can be Implemented by Vertex Shader

Scene FX – Light Scattering Examples
Without scattering With scattering

Characters

The Characters are the Actors of the Games.
Introduction The Characters are the Actors of the Games. Three Types of Characters : Segmented Mesh Bone-skin Root-base Concept (P ) Production : 3D animation tools 3dsMax Maya Softimage … Motion capture (Mocap) For motion data Base

A Segmented Character A character is composed by a set of models with motion data to simulate a live creature in real world P Benefits Hierarchical structure Easy to implement in a scene tree Drawbacks Segment-like

Vertex animation on skins
A Mesh Character Vertex animation on skins Animated positional data on skins 3D warping Benefits Easy to implement Flexible mesh in animation Drawbacks No hierarchy No keyframes Massive dataset

A Bone-skin Character Bone-Skin Skeleton Benefits Drawbacks
Hierarchical bones Skin deformation run-timely Benefits Hierarchical structure Not segmented look Drawbacks More complicated than the other solutions Skin deformation need more CPU cost than transformation only Bone A Skin Bone B

But Finally They Will Be Converted into “Matrix”
Motion Data Euler Angles Angular Displacement Quaternion Slerp But Finally They Will Be Converted into “Matrix”

Optical Motion Capture
Data Acquired From skin to joint (Mocap) From joint to skeleton (Post-processing) From skeleton to skin (In-game) Device The Shooting Plan

Data Acquirement During the Mocap
Raw Data (Positional Data) Joint End Point Bio-Data

Bone-skin Implementation In Game
Skeletons Skin Skeletons Bone-Skin

Mocap Devices

Planning a Mocap Shoot Starting Out – Reviewing the Animation List and Flowchart

Creating a Shot List Create a Database File Names
Preliminary Shot List A Data Record of Shot List

A Shoot List

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

A Daily Schedule

Apply motion data on bones
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

To Create More Animation from Limited Ones Run-time or Pre-processing
Motion Editing To Create More Animation from Limited Ones Run-time or Pre-processing Issues : Motion re-targeting Run-time Re-key-framing Pre-processing Interpolation Motion blending

A Set of Frame Data to Describe the Character’s Motion
Poses A Set of Frame Data to Describe the Character’s Motion Walk, Run, Attack, … Keyframed or Non-keyframed walk run attack fall

A Pose Definition Example
start_frame end_frame walk raw_start_frame raw_end_frame cut_frame Parameter { raw_start_frame raw_end_frame start_frame end_frame cut_frame play_speed length transition_mode }

Play a Pose If the motion data is in quaternion form
walk 4 8 Frame 5.3 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

Pose Connection cut_frame Pose 1 start_frame Pose 2 length

Motion blending in run-time Quaternion is used “Blend Tree”
Pose Blending Motion blending in run-time Quaternion is used “Blend Tree” Cross fade Countinuous blending Feather blending

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

Cross Fade 1 Pose 1 1 Pose2

Continuous Blending 1 Pose 1 1 Pose 2

Feather Blending 左右搏擊 Pose 1 Pose 2 Pose 3

Skin Deformation Weights to Assign the Influences of the Deformation by Bones on Skin Vertices 1-weight 2-weight N-weight CPU cost It’s Very Good for GPU to Perform the Calculation Using Vertex Shader on DirectX

Bone A (root object) base Bone B base (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

A two-weight skin vertex example
Mb = RbTpivot Ma = RaTposition Mvb = Mnb-1 MbMa Mva = Mna-1Ma vin_base = vs*waMva + vs*wbMvb

Network Gaming

3D Game Programming Using TheFly3D©

Similar presentations

Presentation on theme: "3D Game Programming Using TheFly3D©"— Presentation transcript:

Similar presentations

About project

Feedback

Log in

Auth with social network:

3D Game Programming Using TheFly3D©

Similar presentations

Presentation on theme: "3D Game Programming Using TheFly3D©"— Presentation transcript:

Similar presentations

About project

Feedback