Upload
oliver-gallagher
View
225
Download
0
Embed Size (px)
Citation preview
Real-Time Shading Using Programmable Graphics Hardware
Introduction, Setup and Examples
Wan-Chun MaNational Taiwan University
Course Infomation Instructor
Wan-Chun Ma, Alex Dept. of Computer Science and Information Engineering, Nati
onal Taiwan University http://graphics.csie.ntu.edu.tw/~firebird
Course 4/28, 5/5, 5/12, 5/14 Suggested readings
R. Fernando and M. J. Kilgard. The Cg Tutorial: The Definitive Guide to Programmable Real-Time Graphics, Addison-Wesley, 2003 (beginners only!)
R. J. Rost. OpenGL Shading Language, Addison-Wesley, 2004 http://graphics.csie.ntu.edu.tw/~firebird/dokuwiki/doku.php?
id=tech:courses:dci_rts:home
The Student... The student should be familiar with
C/C++ programmingGraphics basics
Transformations in 3D (translation, rotation, modelview, projection)
Rasterization Texturing
OpenGL GLUT, GLUI Use texturing in OpenGL
Today’s Schedule Introduction Setup of Programming Environment Real-Time Shading Examples
Introduction
Evolution of GPUs
Virtual FighterSEGA
Dead or Alive 3Temco
Dawn DemoNVIDIA
NV1 Xbox (NV2A) GeForce FX (NV30)
50K triangles/sec1M pixel ops/sec1M transistors
100M triangles/sec1G pixel ops/sec20M transistors
200M triangles/sec2G pixel ops/sec120M transistors
1995 2001 2003
The 5 Generations of GPU 1st generation (up to 1998)
NVIDIA TNT2, ATI Rage, 3dfx Voodoo3 Lack of transform vertices of 3D objects. Vertex
transformation are done by CPU Limited math operations for combining textures to
compute the color of pixels
2nd generation (1999-2000) NVIDIA GeForce 256, GeForce 2, ATI Radeon 7500 GPU has the ability to do transformation and lighting. Bot
h OpenGL and DirectX 7 support vertex transformation by hardware
Configurable (in driver level) but not programmable
The 5 Generations of GPU 3rd generation (2001)
NVIDIA GeForce 3, GeForce 4 Ti, Xbox, ATI Radeon 8500 Vertex programmability: DirectX 8 vertex shader and OpenG
L ARB vertex program Pixel-level configurable
4th generation (2002) NVIDIA GeForce FX, ATI Radeon 9700 Vertex and pixel programmability High-level shading language (NVIDIA Cg, Microsoft HLSL, Ope
nGL GLSL)
5th generation (2004) NVIDIA GeForce 6, ATI Radeon X Infinite length shader program Dynamic flow control
GPU Model (Old) Fixed function pipeline
GPU Model (Current) Programmability!
GPU Process
VertexProcessin
g
FragmentProcessing
Programming GPU However, programming in assembly
is painfulDP3 R0, c[11].xyzx, c[11].xyzx;RSQ R0, R0.x;MUL R0, R0.x, c[11].xyzx;MOV R1, c[3];MUL R1, R1.x, c[0].xyzx;DP3 R2, R1.xyzx, R1.xyzx;RSQ R2, R2.x;MUL R1, R2.x, R1.xyzx;ADD R2, R0.xyzx, R1.xyzx;DP3 R3, R2.xyzx, R2.xyzx;RSQ R3, R3.x;MUL R2, R3.x, R2.xyzx;DP3 R2, R1.xyzx, R2.xyzx;MAX R2, c[3].z, R2.x;MOV R2.z, c[3].y;MOV R2.w, c[3].y;LIT R2, R2;
DX8 shader instructions Basic: mov, add, mul, mad, rsq… Vector operation: dp3, dp4… Miscellaneous: lit, exp, log, min, max, te
x…
Oh my god!
Programming GPU The need of high level shading
languageCompile
DP3 R0, c[11].xyzx, c[11].xyzx;RSQ R0, R0.x;MUL R0, R0.x, c[11].xyzx;MOV R1, c[3];MUL R1, R1.x, c[0].xyzx;DP3 R2, R1.xyzx, R1.xyzx;RSQ R2, R2.x;MUL R1, R2.x, R1.xyzx;ADD R2, R0.xyzx, R1.xyzx;DP3 R3, R2.xyzx, R2.xyzx;RSQ R3, R3.x;MUL R2, R3.x, R2.xyzx;DP3 R2, R1.xyzx, R2.xyzx;MAX R2, c[3].z, R2.x;MOV R2.z, c[3].y;MOV R2.w, c[3].y;LIT R2, R2;
// A Phong model shaderCOLOR c = k_a + k_d * dot(N, L) + k_s * pow(max(0, dot(N, H)), k_exp);
High level shading language Easier to read and modify Cross-platform Code reuse
Cg: A Shading Language Cg is a high level language from NVIDIA for pro
gramming GPUs, developed in close collaboration with Microsoft
Cg stands for “C for Graphics”
Cg enables a dramatic productivity increase for graphics development developers of: Games CAD tools Scientific visualizations
Cg: A C-like Language Syntax, operators, functions from C Conditionals and flow control (for, if) Particularly suitable for GPUs:
Express data flow of pipeline/stream architecture of GPUs (e.g. vertex-to-pixel)
Vector and matrix operations Support hardware data types for maximum performance Exposes GPU functions for convenience and speed:
Intrinsic: (mul, dot, sqrt, exp, pow) Built-in: extremely useful and GPU optimized math, utility and g
eometric functions (noise, ddx, ddy, reflect) Compiler uses hardware profiles to subset Cg as requi
red for particular hardware feature sets
Cg Workflow Architecture
Cg WorkflowShader Development Application
Cg program source code
// Diffuse lightingfloat d = dot(normalize(N), normalize(L));if (d < 0) d = 0;c = d*tex2D(texture, T)*diffuse;
1. Load/bind program
2. Specify program parameter
3. Specify vertex inputs
4. Render
Cg Compiler
Shader program assembly code
DP3 r0.x, f[TEX0], f[TEX0];RSQ r0.x, r0.x;MUL r0, r0.x, f[TEX0];DP3 r1.x, f[TEX1], f[TEX1];RSQ r1.x, r1.x;MUL r1, r1.x, f[TEX1];DP3 r0, r0, r1;MAX r0.x, r0.x, 1.0;MUL r0, r0.x, DIFFUSE;TEX r1, f[TEX1], 0, 2D;MUL r0, r0, r1;
Shader Compiler
Shader binary0000h: 54 68 69 73 20 69 73 20 65 2D 54 65 58 2C 20 560010h: 65 72 73 69 6F 6E 20 33 2E 31 34 31 35 39 32 2D0020h: 32 2E 31 20 28 4D 69 4B 54 65 58 20 32 2E 34 290030h: 20 28 70 72 65 6C 6F 61 64 65 64 20 66 6F 72 6D0040h: 61 74 3D 6C 61 74 65 78 20 32 30 30 34 2E 36 2E
What Cg can do? Real-time visual effects
What Cg can do? Lots of effects…
Coffee Break Next section: Setup of Programming
Environment
Setup of Programming Environment
Requirement Hardware
The computer should be equipped with programmable graphics hardware
NVIDIA FX, NVIDIA 6, ATI 9x00, ATI X series
SoftwareMicrosoft Visual Studio .NET 2003GLUT, GLUI...
Installation Cg Toolkit 1.3 (10MB)
http://developer.nvidia.com/object/cg_toolkit.html
Check the “Cg Installer for Windows”
NVIDIA SDK 9.0 (340MB, not required) http://developer.nvidia.com/object/sdk_home.ht
ml
FX Composer 1.6 (60MB, not required) http://developer.nvidia.com/object/fx_composer_
home.html Check the “FX Composer 1.6 Installer”
Installation If default installation locations are
used, all the packages are installed in the folder of C:\Program Files\NVIDIA Corporation\
C:\Program Files\NVIDIA Corporation\Cg\NVIDIA FX Composer\SDK 9.0\
My Stuff Several useful codes I collect
http://graphics.csie.ntu.edu.tw/~firebird/download/dci_rts/class.zip
Download it and unpack it into a folder, sayD:\My Projects\Class\Any folder is ok, but remember where
you put it
VC++ Directories Execute visual studio
Tools, Options, Projects, VC++ DirectoriesShow the directories for: Include files
D:\My Project\Class (remember My Stuff?) C:\Program Files\NVIDIA Corporation\Cg\include
Library files C:\Program Files\NVIDIA Corporation\Cg\lib
Ready to Go A small engine
http://graphics.csie.ntu.edu.tw/~firebird/download/dci_rts/env.zip
I will use this engine for shader development during these courses
The first examplehttp://graphics.csie.ntu.edu.tw/~firebird/do
wnload/dci_rts/ex01.zip
Compilation cgc –profile profiles filename
profiles: graphics hardware profiles Vertex: arbvp1, vp20, vp30, vp40... Fragment: arbfp1, fp20, fp30, fp40...
filename: filename of the shader
Examplescgc –profile vp30 test_vtx.cxxcgc –profile fp30 test_frg.cxx
Debugging Debugging is very hard (it is GPU, not
CPU) However, you may still use
intermediate visualization to debug your programOutput intermediate data (e.g. position,
normal, textures…) as color
Coffee Break Next section: Real-time Shading
Examples
Real-Time Shading Examples
Progression Games push hardware, hardware
advances games
Effects in Games
Shadows
Level of detail
Reflection
Shading
Smoke
Effects in Games
Bump mapping
Light mapping
Per-pixel lighting
Multi-texturing
Multi-pass Rendering The rendering pass is not fixed
anymore. A single rendering pass may consists of many functional programs
Multi-pass Rendering Each different program (effect) is
handled individually, and finally summed up to become rendering result
Cg Samples Check out the effect samples in
NVIDIA SDK Browser
The First Cg Example A Phong model shader with color textur
e
ShadersVertex: ex1_vtx.cxxFragment: ex1_frg.cxx
TextureDiffuse: wood.bmp
Vertex Shader
struct v2f{float4 P2D : POSITION; // projected 2D positionfloat4 C : COLOR0; // colorfloat4 T : TEXCOORD0; // texture coordfloat3 P3D : TEXCOORD1; // vertex 3D positionfloat3 N : TEXCOORD2; // normalfloat3 G : TEXCOORD3; // tangentfloat3 B : TEXCOORD4; // binormal};
Vertex-to-fragment data structure
Vertex Shader Main (application-to-vertex)
argumentsv2f main(float4 C : COLOR,float4 P : POSITION,float4 N : NORMAL,float4 T : TEXCOORD0,uniform float4x4 ModelViewProj,uniform float4x4 ModelView,uniform float4x4 ModelViewIT)
Vertex Shader Main body
{v2f OUT;OUT.P2D = mul(ModelViewProj, P);OUT.P3D = P.xyz;OUT.T = T;OUT.N = normalize(N.xyz); // normalOUT.G = normalize(2.0*C.xyz - 1.0); // tangentOUT.B = normalize(cross(OUT.G, OUT.N));return OUT;}
Fragment Shader Fragment-to-screen data structure
struct f2s{float4 C : COLOR0;};
Fragment Shader Main (vertex-to-fragment) arguments
f2s main(v2f IN,uniform sampler2D tex01, // texture 01uniform float3 L,uniform float3 V)
Fragment Shader Main body
{f2s OUT; OUT.rgb = 0;L = normalize(L); V = normalize(V);float3 H = normalize(L+V);float diff = dot(normalize(IN.N), L);if(diff > 0){
float spec = 2*pow(dot(IN.N, H), 128);OUT.C.rgb = diff*tex2D(tex01, IN.T.xy) + spec;
}return OUT;}
Result
Try This... Output red color for all fragments
{f2s OUT; OUT.rgb = 0;// L = normalize(L); V = normalize(V);// float3 H = normalize(L+V);// float diff = dot(normalize(IN.N), L);// if(diff > 0)// {
// float spec = 2*pow(dot(IN.N, H), 128);OUT.C.rgb = float3(1.0, 0.0, 0.0);
// }return OUT;}
Try This... Visualize normal vectors
{f2s OUT; OUT.rgb = 0;// L = normalize(L); V = normalize(V);// float3 H = normalize(L+V);// float diff = dot(normalize(IN.N), L);// if(diff > 0)// {
// float spec = 2*pow(dot(IN.N, H), 128);OUT.C.rgb = (IN.N+1)/2;
// }return OUT;}
End