Evolution of GPUs Chris Seitz

Transcription

1 Evolution of GPUs Chris Seitz

2 Overview Concepts: Real-time rendering Hardware graphics pipeline Evolution of the PC hardware graphics pipeline: : Texture mapping and z-buffer 1998: Multitexturing : Transform and lighting 2001: Programmable vertex shader : Programmable pixel shader 2004: Shader model 3.0 and 64-bit color support

3 Real-Time Rendering Graphics hardware enables real-time rendering Real-time means display rate at more than 10 images per second 3D Scene = Collection of 3D primitives (triangles, lines, points) Image = Array of pixels

4 PC Architecture Motherboard CPU System Memory Bus Port (PCI, AGP, PCIe) Graphics Board Video Memory GPU

5 Hardware Graphics Pipeline Application Stage 3D Triangles Geometry Stage 2D Triangles Rasterization Stage Pixels For each triangle vertex: For each triangle: Transform Rasterize position: triangle 3D -> screen Compute Interpolate vertex attributes attributes Shade pixels Resolve visibility

6 Real-time Graphics 1997: RIVA 128 3M Transistors

7 Real-time Graphics 2004: UnReal Engine 3.0 Images Courtesy of Epic Games

8 95-98: Texture Mapping & Z-Buffer CPU GPU Application / Geometry Stage Rasterizer Rasterization Stage Texture Unit Raster Operations Unit 2D Triangles Bus Textures (PCI) 2D Triangles Textures Frame Buffer System Memory Video Memory

9 Raster Operations Unit (ROP) Rasterizer Texture Unit Fragments Raster Operations Unit Fragment Screen Position (x, y) tested against scissor rectangle tested against reference value Scissor Test Alpha Test Frame Buffer Alpha Value a Depth z Color (r, g, b) stencil buffer value at (x, y) tested against reference value tested against z-buffer value at (x, y) (Visibility test) Stencil Test Z Test Alpha Blending Stencil Buffer Z-Buffer Color Buffer Pixels blended with color buffer value at (x, y) K src * Color src + K dst * Color src (src = fragment, dst = color buffer)

10 Texture Mapping Triangle Mesh (with UV coordinates) Base Texture + = Sampling Magnification, Minification Filtering Bilinear, Trilinear, Anisotropic Mipmapping Perspective Correct Interpolation

11 Texture Mapping: Mipmapping & Filtering or Bilinear Filtering Trilinear Filtering

12 Filtering Examples Point Bilinear Trilinear Anisotropic (4X) & Trilinear

13 Incoming

14 Riva TNT 7M Transistors Multitexture

15 1998: Multitexturing CPU GPU Application / Geometry Stage Rasterizer Rasterization Stage Multi Texture Unit Raster Operations Unit 2D Triangles Textures Bus (AGP) 2D Triangles 2 Textures Frame Buffer System Memory Video Memory

16 Multitexturing Base Texture modulated by Light Map X = from UT2004 (c) Epic Games Inc. Used with permission

17 GeForce M Transistors Hardware Transform & Lighting

18 : Transform and Lighting CPU GPU Fixed Function Pipeline Application Stage Geometry Stage Rasterization Stage Transform & Lighting Unit Rasterizer Texture Unit Register Combiner Raster Operations Unit 3D Triangles Textures Bus (AGP) 3D Triangles Textures Frame Buffer System Memory Video Memory

19 Transform and Lighting Unit (TnL) Transform and Lighting Unit Transform Model or Object Space Model-View Matrix Camera or Eye Space Projection Matrix World Matrix World Space View Matrix Lighting Material Properties Light Properties Vertex Color Projection or Clip Space Perspective Division & Viewport Matrix Screen or Window Space Vertex Diffuse & Specular Color

20 Wanda and Bubble

21 GeForce 2 Pixel Shading Multitexture

22

23 GeForce 3 Programmable Vertex Shading

24 2001: Programmable Vertex Shader CPU GPU Application Stage Geometry Stage Vertex Shader (no flow control) Rasterizer w/ Z-Cull Rasterization Stage Texture Unit (4 Textures) Register Combiner Raster Operations Unit 3D Triangles Textures Bus (AGP) 3D Triangles Textures Frame Buffer System Memory Video Memory

25 Vertex Shader A programmable processor for any per-vertex computation void VertexShader( // Input per vertex in float4 positioninmodelspace, in float2 texturecoordinates, in float3 normal, ) { } // Input per batch of triangles uniform float4x4 modeltoprojection, uniform float3 lightdirection, // Output per vertex out float4 positioninprojectionspace, out float2 texturecoordinatesoutput, out float3 color // Vertex transformation positioninprojectionspace = mul(modeltoprojection, positioninmodelspace); // Texture coordinates copy texturecoordinatesoutput = texturecoordinates; // Vertex color computation color = dot(lightdirection, normal);

26 Bump Mapping Bump mapping involves fetching the per-pixel normal from a normal map texture (instead of using the interpolated vertex normal) in order to compute lighting at a given pixel + = Diffuse light Normal Map Diffuse light with bumps

27 Cubic Texture Mapping Cubemap (x,y,z) x z y Environment Mapping Reflection vector is used to lookup into the cubemap Cubemap lookup in direction (x, y, z)

28

29 Projective Texture Mapping Projected Texture (x, y, z, w) (x/w, y/w) Texture Projection Projective Texture lookup

30 Volume Texture Mapping z (x,y,z) y Volume Texture 3D Noise x Solid Textures Noise Perturbation Volume Texture lookup with position (x, y, z)

31 Hardware Shadow Mapping Shadow Map Computation z/w The shadow map contains the depth (z/w) of the 3D points visible from the light s point of view: Spot light (x, y, z, w) (x/w, y/w) Shadow Rendering shadow map A 3D point (x, y, z, w) is in shadow if: z/w < value of shadow map at (x/w, y/w) A hardware shadow map lookup value Spot light (x/w, y/w) (x, y, z, w) returns the value of this comparison between 0 and 1

32 Antialiasing: Examples

33 Antialiasing: Supersampling & Multisampling Supersampling: Compute color and Z at higher resolution and display averaged color to smooth out the visual artifacts Multisampling: Same thing except only Z is computed at higher resolution Multisampling performs antialiasing on primitive edges only

34 X-Isle: Dinosaur Isle Image courtesy of Crytek

35 GeForce 4 Multiple Vertex and Pixel Shaders

36 Wolfman

37 GeForce FX - >100M Transistors Programmable Pixel Shading (DirectX 9.0) Scalable Architecture

38 02-03: Programmable Pixel Shader CPU GPU Application Stage Geometry Stage Vertex Shader (static & dynamic flow control) Rasterizer w/ Z-Cull Rasterization Stage Texture Unit (16 textures) Pixel Shader (static flow control) Raster Operations Unit 3D Triangles Textures Bus (AGP) 3D Triangles Textures Frame Buffer System Memory Video Memory

39

40 PC Graphics Software Architecture CPU GPU Application 3D API (OpenGL or DirectX) BUS Commands Programs Vertex Shader Pixel Shader Frame Buffer Geometry Driver Textures Vertex Program Pixel Program The application, 3D API and driver are written in C or C++ The vertex and pixel programs are written in a high-level shading language (DirectX HLSL, OpenGL Shading Language, Cg) Pushbuffer: Contains the commands to be executed on the GPU

41 Pixel Shader A programmable processor for any per-pixel computation void PixelShader( // Input per pixel in float2 texturecoordinates, in float3 normal, // Input per batch of triangles uniform sampler2d basetexture, uniform float3 lightdirection, ) { // Output per pixel out float3 color // Texture lookup float3 basecolor = tex2d(basetexture, texturecoordinates); // Light computation float light = dot(lightdirection, normal); } // Pixel color computation color = basecolor * light;

42 Shader: Static vs. Dynamic Flow Control void Shader(... // Input per vertex or per pixel in float3 normal, Static Flow Control (condition varies per batch of triangles) Dynamic Flow Control (condition varies per vertex or pixel) ) { } // Input per batch of triangles uniform float3 lightdirection, uniform bool computelight, if (computelight) {... if (dot(lightdirection, normal)) {... }... }...

43

44 GeForce M Transistors Shader Model 3.0 FP64 & High Dynamic Range

45 2004: Shader Model 3.0 & 64-Bit Color Support CPU GPU Application Stage Geometry Stage Vertex Shader (static & dynamic flow control) Rasterizer w/ Z-Cull Rasterization Stage Texture Unit Pixel Shader (static & dynamic flow control) Raster Operations Unit 64-Bit Color 3D Triangles Textures Bus (PCIe) 3D Triangles Textures Frame Buffer System Memory Video Memory

46 Shader Model 3.0 Longer shaders More complex shading Pixel shader: Dynamic flow control Better performance Derivative instructions Shader antialiasing Support for 32-bit floating-point precision Fewer artifacts Face register Faster two-sided lighting Vertex shader: Texture access Simulation on GPU, displacement mapping Geometry Instancing Better performance Lord of the Rings The Battle for Middle-earth Far Cry

47 The GeForce 6 Series Amazing Real-time Effects

48

49 Shader Model 3.0 / 64-bit Floating Point Processing Unreal Engine 3.0 Running On GeForce 6 Series 2 Million Triangle Detail Mesh Models High Dynamic Range Rendering Fully Customizable Shaders UnReal Engine 3.0 Images Courtesy of Epic Games

50 Shader Model 3.0 / 64-bit Floating Point Processing Unreal Engine 3.0 Running On GeForce 6 Series UnReal Engine 3.0 Images Courtesy of Epic Games 100 Million Triangle Source Content Scene High Dynamic Range Rendering

51 High Dynamic Range Imagery The dynamic range of a scene is the ratio of the highest to the lowest luminance Real-life scenes can have high dynamic ranges of several millions Display and print devices have a low dynamic range of around 100 Tone mapping is the process of displaying high dynamic range images on those low dynamic range devices High dynamic range images use floating-point colors OpenEXR is a high dynamic range image format that is compatible with NVIDIA s 64-bit color format HDR Rendering Engine - Compute surface reflectance, save in HDR buffer Contributions from multiple lights are additive (blended) Add image-space special effects & Post to HDR buffer AA, Glow, Depth of Field, Motion Blur

52 Real-Time Tone Mapping The image is entirely computed in 64-bit color and tone-mapped for display Renderings of the same scene, from low to high exposure

53 Evolution of Performance CPU Frequency (GHz) Pixel Fill Rate Vertex Rate Graphics Bandwidth Bus Bandwidth CPU Frequency Bus Bandwidth (GB/sec) Pixel Fill Rate (MPixels/sec) Vertex Rate (MVerts/sec) Graphics Bandwidth (GB/sec) MB 32 MB 64 MB 128 MB 256 MB 512 MB DirectX 6 DirectX 7DirectX 8 DirectX 9 OpenGL 1.1 OpenGL 1.4 OpenGL 1.5

54 Looking Ahead: Now + 10 years CPU Frequency (GHz) Bus Bandwidth (GB/sec) Pixel Fill Rate (MPixels/sec) Vertex Rate (MVerts/sec) Graphics flops (GFlops/sec) Graphics Bandwidth (GB/sec) 127 Gvertx Pixel Fill Rate Vertex Rate Graphics flops Mverts BUS Bandwidth CPU Frequency 100 GHz MHz

55 NVIDIA SLI Multi-GPU

56 Progression of Graphics Virtual Fighter NV1 1Mtrans Wanda NV1x 22Mtrans Wolfman NV2x 63Mtrans Dawn NV3x 130Mtrans Nalu NV4x 222M

57 Thank You