Hardware Shading on 9700 the ATI RADEON
Jason L. Mitchell ATI Research JasonM@ati.com

Outline

RADEON 9700 Shader Models
2.0 vertex and pixel shaders in DirectX 9 ATI_fragment_program OpenGL Extension Compulsories Shiny bumpy Homomorphic BRDF Procedural wood Freestyle

Per-Pixel Hatching

High Dynamic Range Rendering HDR Environment/Light Maps HDR Scene Post-processing Local versus distant reflections / refractions
Motion Blur Image Space Operations for NPR Two-tone layered car paint model
Hardware Shading on ATI RADEON 9700
RADEON 9700 Vertex Shaders
Exposed as DirectX 9 2.0 Vertex
Shaders and via ARB_vertex_program Improves upon previous models Control flow Longer programs More constant storage
Vertex Shader Control Flow
Jumps, loops Useful in game space for solving the
permutation problem Number/type of lights Env mapping on/off
Bump mapping on/off Skinning on/off
Constant based for this generation
RADEON 9700 Pixel Shaders
DirectX 9 2.0 pixel shaders ATI_fragment_program Floating point pixels 64 ALU instructions 32 texture instructions 4 levels of dependent read
2.0 Pixel Shader Instruction Set ALU Instructions
ADD, MOV, MUL, MAD, DP3, DP4, FRAC,
RCP, RSQ, EXP, LOG and CMP

Texture Instructions

texld, texldp, texldb, texkill
Multiple render targets Output up to four colors from pixel
shader Useful for intermediate results in multipass algorithms Can use as G-buffer [Saito and G-buffer Takahashi 1990] Used to optimize NPR outlining example

Pixel Pipeline Output

Target 1

Target 2

World Space Normal

High-precision Depth

Texture 1

Texture 2

Pixel Shader
High Precision depth gives better edges than lowprecision depth used previously
Advanced Surface Types IEEE 32-bit surfaces 32-bit
1-, 2- and 4-channel versions
16-bit float s10e5 surfaces 16-bit
16-bit fixed point surfaces 16-bit

2.2 gamma

Compulsory Shaders
Shiny Bumpy Homomorphic BRDF Procedural Wood
ps.2.0 ATI_fragment_shader ps.1.4

Shiny Bumpy

Shown in Treasure
Chest demo on RADEON 8500 Uses ps.1.4 Transforms fetched normal to world space and performs reflection operation Samples cube map with reflected vector
More than just shiny and bumpy with ps.1.4
Easy to include a per-pixel per-pixel
Fresnel term and sample a diffuse cube map Runs in one pass on ps.1.4

Homomorphic BRDFs

Work is in the parametrization Reconstruction is one of: of: (((diffuse * tex0) * scale1) * tex1 * scale2) * tex2
(((diffuse * tex0) * scale1) * tex1 * scale2) * tex2 + tex3 (((diffuse * tex0) * scale1) * tex1 * scale2) * tex2) * tex3
glBeginFragmentShaderATI(); glBeginFragmentShaderATI(); glSampleMapATI (GL_REG_0_ATI, GL_TEXTURE0_ARB, GL_SWIZZLE_STR_ATI); // Sample maps glSampleMapATI (GL_REG_1_ATI, GL_TEXTURE1_ARB, GL_SWIZZLE_STR_ATI); glSampleMapATI (GL_REG_2_ATI, GL_TEXTURE2_ARB, GL_SWIZZLE_STR_ATI); if (param == PARAM_OHI_H) // only sample the specular map if necessary (param { if (sg_tex3Type == GL_TEXTURE_CUBE_MAP_ARB) { glSampleMapATI (GL_REG_3_ATI, GL_TEXTURE3_ARB, GL_SWIZZLE_STR_ATI); } else { glSampleMapATI (GL_REG_3_ATI, GL_TEXTURE3_ARB, GL_SWIZZLE_STQ_ATI); } } // r0 = diffuse * tex0 * scale1 glColorFragmentOp2ATI (GL_MUL_ATI, GL_REG_0_ATI, GL_NONE, scale1, GL_PRIMARY_COLOR_EXT, GL_NONE, GL_NONE, GL_PRIMARY_COLOR_EXT, GL_REG_0_ATI, GL_NONE, GL_NONE); GL_REG_0_ATI, // r0 = (diffuse * tex0 * scale1) * tex1 * scale2 glColorFragmentOp2ATI (GL_MUL_ATI, GL_REG_0_ATI, GL_NONE, scale2, scale2, GL_REG_1_ATI, GL_NONE, GL_NONE, GL_REG_1_ATI, GL_REG_0_ATI, GL_NONE, GL_NONE); GL_REG_0_ATI, if (param == PARAM_OHI_H) // do a MAD if specular map is used (param { // r0 = ((diffuse * tex0 * scale1) * tex1 * scale2) * tex2 + tex3 glColorFragmentOp3ATI (GL_MAD_ATI, GL_REG_0_ATI, GL_NONE, GL_NONE, GL_NONE, GL_REG_0_ATI, GL_NONE, GL_NONE, GL_REG_2_ATI, GL_NONE, GL_NONE, GL_REG_3_ATI, GL_NONE, GL_NONE); } else { // r0 = ((diffuse * tex0 * scale1) * tex1 * scale2) * tex2 glColorFragmentOp2ATI (GL_MUL_ATI, GL_REG_0_ATI, GL_NONE, GL_NONE, GL_NONE, GL_REG_0_ATI, GL_NONE, GL_NONE, GL_REG_0_ATI, GL_REG_2_ATI, GL_NONE, GL_NONE);} glEndFragmentShaderATI(); glEndFragmentShaderATI();

Two versions of wood

Hand coded

ps.2.0 assembly

RenderMan
translated to ps.2.0 assembly

Procedural Wood

Based on example in
Advanced RenderMan Uses volume texture for noise and 1D texture for smooth pulse train My version has 8 intuitive parameters Light Wood Color Dark Wood ring frequency noise amplitude trunk wobble frequency trunk wobble amplitude specular exponent scale specular exponent bias

Non-Real-Time Version

40-instruction 2.0 40-instruction

Real-Time Version

pixel shader Samples noise map 6 times Phong shading
Step-by-step Approach Shader Space (Pshade) Distance from trunk axis (z) (z) Add noise to Pshade Add noise as function of z to wobble Run through pulse train

Wood Vertex Shader

dcl_position v0 dcl_normal v3 def c40, 0.0f, m4x4 oPos, v0, 0.0f, 0.0f, 0.0f c[0] // // All zeroes Transform position to clip space
m4x4 r0, v0, c[17] mov oT0, r0 m4x4 oT1, v0, c[21] m4x4 oT2, v0, c[25] mov mul mov mov mad mov r1, c40 r1.x, r0.z, c29.x oT3, r1 r1, c40 r1.x, r0.z, c29.x, c29.y oT4, r1
// Transformed Pshade (using texture matrix 0) // Transformed Pshade (using texture matrix 1) // Transformed Pshade (using texture matrix 2) // {freq*Pshade.z, 0, 0, 0} // {freq*Pshade.z, 0, 0, 0} for 1D trunkWobble noise in x // {freq*Pshade.z + 0.5, 0, 0, 0} // {Pshade.z+0.5, 0, 0, 0} for 1D trunkWobble noise in y // Transform position to eye space // Transform normal to eye space
m4x4 oT6, v0, c[4] m4x4 oT7, v3, c[8]

Pshade

For this app, Pshade is just world Pshade
space The infinite virtual log runs along the z axis I make a few different transformed versions of Pshade in the vertex Pshade shader in order to turn scalar noise into color noise, as Ill show later

Distance from z axis

sqrt (Pshade.x2 + Pshade.y2) * freq.x.y Pass this in to pulse train

Pulse Train

Tuned to mimic the way colors mix in real
wood One pulse stored in 1D texture which repeats

Concentric Rings

ps.2.0 def c0, 2.0f, def c1, 1.0f, // c2: xyz == // c3: xyz == -1.0f, 0.5f, 0.5f -1.0f, 1.0f, 0.1f, 0.0f Light Wood Color, Dark Wood Color // scale, bias, half, X // X, X, 0.1, zero w == ringFreq xyz == Pshade (shader-space position), w == X (shader-space 1D smooth step function x2 + y2 + 1/sqrt(x2 + y2) 1/sqrt(xsqrt(x2 + y2) sqrt(xsqrt(x2 + y2) * freq sqrt(x2 Sample from 1D pulse train texture
dcl t0.xyzw dcl_2d s1 dp2add r0, t0, t0, c1.w rsq r0, r0.x rcp r0, r0.x mul r0, r0, c2.w texld r0, r0, s1 mov r1, c3 lrp r2, r0.x, c2, r1 mov oC0, r2

// // // // // // //

// Blend between light and dark wood colors

Noisy Rings

ps.2.0 def c0, 2.0f, -1.0f, 0.5f, 0.5f // scale, bias, half, X -1.0f, def c1, 1.0f, 1.0f, 0.1f, 0.0f // X, X, 0.1, zero // c2: xyz == Light Wood Color, w == ringFreq // c3: xyz == Dark Wood Color, w == noise amplitude // c4: xyz == L_eye, w == trunkWobbleAmplitude L_eye, dcl t0.xyzw // xyz == Pshade (shader-space position), w == X (shader(shader-space dcl t1.xyzw // xyz == Perturbed Pshade, w == X dcl t2.xyzw // xyz == Perturbed Pshade, w == X dcl_volume s0 // Luminance-only Volume noise LuminanceLuminance-only dcl_2d s1 // 1D smooth step function texld r3, t0, s0 // Sample dX from scalar noise at Pshade shade texld r4, t1, s0 // Sample dY from scalar noise at perturbed Pshade shade texld r5, t2, s0 // Sample dZ from scalar noise at perturbed Pshade shade mov r3.y, r4.x // Put dY in y mov r3.z, r5.x // Put dZ in z mad r3, r3, c0.x, c0.y // Put noise in -1.+1 range -1.+1 mad r7, c3.w, r3, t0 // Scale by amplitude and add to Pshade to warp the domain shade dp2add r0, r7, r7, c1.w // x2 + y2 + rsq r0, r0.x // 1/sqrt(x2 + y2) 1/sqrt(x 2 1/sqrt(x rcp r0, r0.x // sqrt(x 2 + y 2) sqrt(x 2 mul r0, r0, c2.w // sqrt(x2 + y2) * freq sqrt(x 2 texld r0, r0, s1 // Sample from 1D pulse train texture mov r1, c3 lrp r2, r0.x, c2, r1 // Blend between light and dark wood colors mov oC0, r2 Hardware Shading on ATI RADEON 9700

New code

Colored Volume Noise

Trunk Wobble

Without Wobble

With Wobble

Noise and wobble
def c0, 2.0f, -1.0f, 0.5f, 0.5f // scale, bias, half, X -1.0f, def c1, 1.0f, 1.0f, 0.1f, 0.0f // X, X, 0.1, zero // c2: xyz == Light Wood Color, w == ringFreq // c3: xyz == Dark Wood Color, w == noise amplitude // c4: xyz == L_eye, w == trunkWobbleAmplitude L_eye, dcl t0.xyzw // xyz == Pshade (shader-space position), w == X shader(shader-space dcl t1.xyzw // xyz == Perturbed Pshade, w == X Pshade, dcl t2.xyzw // xyz == Perturbed Pshade, w == X Pshade, dcl t3.xyzw // xyz == {Pshade.z, 0, 0}, w == X {Pshade.z, {Pshade.z, dcl t4.xyzw // xyz == {Pshade.z + 0.5, 0, 0}, w == X {Pshade.z dcl_volume s0 // Luminance-only Volume noise LuminanceLuminance-only dcl_2d s1 // 1D smooth step function (blend factor in x, spec exp in y,.) x, y, texld r3, t0, s0 // Sample dX from scalar volume noise texture at Pshade shade texld r4, t1, s0 // Sample dY from scalar volume noise texture at perturbed Pshade shade texld r5, t2, s0 // Sample dZ from scalar volume noise texture at perturbed Pshade shade texld r6, t3, s0 // Sample trunkWobble.x from scalar noise at {Pshade, 0, 0} shade texld r7, t4, s0 // Sample trunkWobble.y from scalar noise at {Pshade + 0.5, 0, 0} shade mov r3.y, r4.x // Put dY in y mov r3.z, r5.x // Put dZ in z mov r6.y, r7.x // Move to get {trunkWobble.x, trunkWobble.y, 0} {trunkWobble.x, trunkWobble.y, {trunkWobble.x, mad r6, r6, c0.x, c0.y // Put {trunkWobble.x, trunkWobble.y, 0} in -1.+1 range trunkWobble.x, trunkWobble.y, { {trunkWobble.x, -1.+1 mad r3, r3, c0.x, c0.y // Put noise in -1.+1 range -1.+1 mad r7, c3.w, r3, t0 // Scale noise by amplitude and add to Pshade to warp the domain shade mad r7, c4.w, r6, r7 // Scale {trunkWobble.x, trunkWobble.y, 0} by amplitude and add in {trunkWobble.x, trunkWobble.y, {trunkWobble.x, dp2add r0, r7, r7, c1.w // x2 + y2 + rsq r0, r0.x // 1/sqrt(x2 + y2) 1/sqrt(x 2 1/sqrt(x + y2 ) 2 rcp r0, r0.x // sqrt(x sqrt(x 2 mul r0, r0, c2.w // sqrt(x2 + y2) * freq sqrt(x 2 texld r0, r0, s1 // Sample from 1D pulse train texture mov r1, c3 lrp r2, r0.x, c2, r1 // Blend between light and dark wood colors mov oC0, r2 Hardware Shading on ATI RADEON 9700

Noise and Wobble

ps.2.0 ps.2.0 def c0, 2.0f, -1.0f, 0.5f, 0.5f // scale, bias, half, X def c0, 2.0f, -1.0f, 0.5f, 0.5f // scale, bias, half, X def c1, 1.0f, 1.0f, 0.1f, 0.0f // X, X, 0.1, zero def c1, 1.0f, 1.0f, 0.1f, 0.0f // X, X, 0.1, zero dcl t0.xyzw // xyz == Pshade (shader-space position), w == X shaderdcl t0.xyzw // xyz == Pshade (shader-space position), w == X dcl t1.xyzw // xyz == Perturbed Pshade, w == X dcl t1.xyzw // xyz == Perturbed Pshade, w == X dcl t2.xyzw // xyz == Perturbed Pshade, w == X dcl t2.xyzw // xyz == Perturbed Pshade, w == X dcl t3.xyzw // xyz == {Pshade.z, 0, 0}, w == X dcl t3.xyzw // xyz == {Pshade.z, 0, 0}, w == X {Pshade.z, dcl t4.xyzw // xyz == {Pshade.z + 0.5, 0, 0}, w == X dcl t4.xyzw // xyz == {Pshade.z + 0.5, 0, 0}, w == X {Pshade.z dcl t6.xyzw // xyz == P_eye, w == X dcl t6.xyzw // xyz == P_eye, w == X P_eye, dcl t7.xyzw // xyz == N_eye, w == X dcl t7.xyzw // xyz == N_eye, w == X N_eye, dcl_volume s0 // Luminance-only Volume noise dcl_volume s0 // LuminanceLuminance-only Volume noise dcl_2d s1 // 1D smooth step function (blend factor in x, specular exponent in y, dcl_2d s1 // 1D smooth step function (blend factor in x, specular exponent in y,.).) texld r3, t0, s0 // Sample dX from scalar volume noise texture at Pshade texld r3, t0, s0 // Sample dX from scalar volume noise texture at Pshade texld r4, t1, s0 // Sample dY from scalar volume noise texture at perturbed Pshade texld r4, t1, s0 // Sample dY from scalar volume noise texture at perturbed Pshade texld r5, t2, s0 // Sample dZ from scalar volume noise texture at perturbed Pshade texld r5, t2, s0 // Sample dZ from scalar volume noise texture at perturbed Pshade texld r6, t3, s0 // Sample trunkWobble.x from scalar volume noise at {Pshade.z, 0, 0} texld r6, t3, s0 // Sample trunkWobble.x from scalar volume noise at {P shade.z, 0, 0} {P texld r7, t4, s0 // Sample trunkWobble.y from scalar volume noise at {Pshade.z + 0.5, 0, 0} texld r7, t4, s0 // Sample trunkWobble.y from scalar volume noise at {P shade.z + 0.5, 0, 0} {P mov r3.y, r4.x // Put dY in y mov r3.y, r4.x // Put dY in y mov r3.z, r5.x // Put dZ in z mov r3.z, r5.x // Put dZ in z mov r6.y, r7.x // Move to get {trunkWobble.x, trunkWobble.y, 0} mov r6.y, r7.x // Move to get {trunkWobble.x, trunkWobble.y, 0} {trunkWobble.x, trunkWobble.y, mad r6, r6, c0.x, c0.y // Put {trunkWobble.x, trunkWobble.y, 0} in -1.+1 range mad r6, r6, c0.x, c0.y // Put {trunkWobble.x, trunkWobble.y, 0} in -1.+1 range {trunkWobble.x, trunkWobble.y, mad r3, r3, c0.x, c0.y // Put noise in -1.+1 range mad r3, r3, c0.x, c0.y // Put noise in -1.+1 range mad r7, c3.w, r3, t0 // Scale noise by amplitude and add to Pshade to warp the domain mad r7, c3.w, r3, t0 // Scale noise by amplitude and add to Pshade to warp the domain mad r7, c4.w, r6, r7 // Scale {trunkWobble.x, trunkWobble.y, 0} by amplitude and add in mad r7, c4.w, r6, r7 // Scale {trunkWobble.x, trunkWobble.y, 0} by amplitude and add in {trunkWobble.x, trunkWobble.y, dp2add r0, r7, r7, c1.w // x2 + y2 + 0 dp2add r0, r7, r7, c1.w // x2 + y2 + 0 rsq r0, r0.x // 1/sqrt(x2 + y2) rsq r0, r0.x // 1/sqrt(x 2 + y2) 1/sqrt(x rcp r0, r0.x // sqrt(x2 + y2) rcp r0, r0.x // sqrt(x 2 + y2) sqrt(x mul r0, r0, c2.w // sqrt(x2 + y2) * freq mul r0, r0, c2.w // sqrt(x 2 + y2) * freq sqrt(x texld r0, r0, s1 // Sample from 1D pulse train texture texld r0, r0, s1 // Sample from 1D pulse train texture mov r1, c3 mov r1, c3 lrp r2, r0.x, c2, r1 // Blend between light and dark wood colors lrp r2, r0.x, c2, r1 // Blend between light and dark wood colors sub r4, c4, t6 // Compute normalized vector from vertex to light in eye space (L_eye) L_eye) sub r4, c4, t6 // Compute normalized vector from vertex to light in eye space (L_eye) dp3 r5.w, r4, r4 // dp3 r5.w, r4, r4 // rsq r5.w, r5.w // rsq r5.w, r5.w // mul r4, r4, r5.w // L_eye mul r4, r4, r5.w // L_eye dp3 r6.w, t7, t7 // Normalize the interpolated normal dp3 r6.w, t7, t7 // Normalize the interpolated normal rsq r6.w, r6.w // rsq r6.w, r6.w // mul r5, t7, r6.w // N_eye mul r5, t7, r6.w // N_eye dp3 r3.w, t6, t6 // Compute normalized vector from the eye to the vertex dp3 r3.w, t6, t6 // Compute normalized vector from the eye to the vertex rsq r3.w, r3.w // rsq r3.w, r3.w // mul r3, -t6, r3.w // V_eye mul r3, -t6, r3.w // V_eye add r6, r3, r5 // Compute Eye-Space HalfAngle (L_eye+V_eye)/|L_eye+V_eye| L_eye+V_eye)/|L_eye+V_eye| add r6, r3, r5 // Compute EyeEye-Space HalfAngle (L_eye+V_eye)/|L_eye+V_eye| dp3 r6.w, r6, r6 dp3 r6.w, r6, r6 rsq r6.w, r6.w rsq r6.w, r6.w mul r6, r6, r6.w // H_eye mul r6, r6, r6.w // H_eye dp3_sat r6, r5, r6 // N.H dp3_sat r6, r5, r6 // N.H mad r0.z, r0.z, c5.z, c5.w // scale and bias wood ring pulse to specular exponent range mad r0.z, r0.z, c5.z, c5.w // scale and bias wood ring pulse to specular exponent range pow r6, r6.x, r0.z // (N.H)^k pow r6, r6.x, r0.z // (N.H)^k dp3 r5, r4, r5 // Non-clamped N.L dp3 r5, r4, r5 // NonNon-clamped N.L mad_sat r5, r5, c0.z, c0.z // "Half-Lambert" trick for more pleasing diffuse term mad_sat r5, r5, c0.z, c0.z // "Half"Half-Lambert" trick for more pleasing diffuse term mul r6, r6, r0.y // Gloss the highlight with the ramp texture mul r6, r6, r0.y // Gloss the highlight with the ramp texture mad r2, r5, r2, r6 // N.L * procedural albedo + specular mad r2, r5, r2, r6 // N.L * procedural albedo + specular mov oC0, r2 mov oC0, r2 Hardware Shading on ATI RADEON 9700

Full Shader

With Phong Shading

Final Scene

RenderMonkey Compiler

Freestyle Shaders

Shaders in Chapter 3 of bound notes
Per-Pixel Hatching Refer to bound notes for others
Per-pixel specular exponent Skin
Shaders in Supplement - Chapter 3.1
High Dynamic Range Rendering
HDR Environment/Light Maps HDR Scene Post-processing Local versus distant reflections / refractions

Motion Blur

Image Space Operations for NPR Two-tone layered car paint model
Flying Balls and Plucked Strings
Real-Time Hatching Shown at SIGGRAPH 2001 by Praun et al Tonal Art Maps (TAMs) contain hatching (TAMs)
patterns of varying density in different channels Compute linear combination of TAM channels based on NL

Tonal Art Map

Weighted sum of these channels determines final tone

Hatched Shadowed Scene

Basic Hatching
ps.1.4 texld r0, t0 ; sample the 1st three channels of the TAM texld r1, t0 ; sample the 2nd three channels of the TAM texcrd r2.rgb, t1.xyz ; get the 123 TAM weights and place in r2 texcrd r3.rgb, t2.xyz ; get the 456 TAM weights and place in r3 dp3_sat r0, 1-r0, r2 ; dot 123 TAM values with 123 TAM weights 1-r0, dp3_sat r1, 1-r1, r3 ; dot 456 TAM values with 456 TAM weights 1-r1, add_sat r0, r0, r1 ; add reg 0 and reg1 mov_sat r0, 1-r0 ; complement and saturate 1-r0

Hatching Enhancements

Per-pixel determination of Per-pixel
TAM weights based on NL and distance attenuation of light Hatch tinting as function of a base color map

Per-Pixel TAM Weighting

1. Compute NL 2. Compute Distance Attenuation 3. Modulate attenuation and NL with base map
intensity 4. Do dependent read from 1D textures to convert above intensity to TAM weights:
5. Fetch TAMs 6. Compute Linear Combination of TAM channels 7. Tint according to base map color

Per-Pixel TAM Weights

Per Vertex TAM Weights

Per Pixel TAM Weights

Hatched Images with Shadows

Enhanced Hatching

ps.1.4 def c0, 1.00f, 1.00f, 1.00f, 1.00f def c1, 0.30f, 0.59f, 0.11f, 0.00f ; RGB to luminance conversion weights texcrd r1.rgb, t2 ; NL texld r4, t3 ; Intensity map looked up from light space position texld r5, t0 ; Base Texture mul_x2 r4, r4.r, r1.r ; NL * attenuation add r4, r4, c2 ; += ambient dp3 r3, r5, c1 ; Intensity of base map mul r5, r4, r5 ; Modulate base map by light mul r4, r4, r3 ; Modulate light by base map intensity phase texld r0, t1 ; sample the first three channels of the TAM texld r1, t1 ; sample the second three channels of the TAM texld r2, r4 ; Get weights for 123 texld r3, r4 ; Get weights for 456 dp3_sat r0, 1-r0, r2 ; dot the reg0 (TAM values) with reg2 (TAM weights) 1-r0, dp3_sat r1, 1-r1, r3 ; dot the reg1 (TAM values) with reg3 (TAM weights) 1-r1, add_sat r0, r0, r1 ; add reg0 and reg1 mul r0.rgb, 1-r5, r0 ; Color hatches with base texture 1-r5, mov_sat r0, 1-r0 ; complement and saturate 1-r0
High Dynamic Range Rendering

HDR Rendering Process

Scene Geometry lit with HDR Light Probes

HDR Scene

Bloom Filter

Tone Map

Displayable Image
Rendering the Scene Render reflected scene into HDR
planar reflection map for table top HDR light probe for distant environment HDR environment maps for local reflections from balls on pedestals Postprocess to get glows Tone map to displayable image

Local Reflection

Distant HDR Light
probe is always sampled with reflection vector in pixel shader Local environment map is sampled with a blend of the surface normal (N) (N) and the reflection vector (R) (R)

100% R

Blend between R and N

100% N

Frame Postprocessing

Size Frame

Horizontal 3-Gaussian Filters Vertical 3Gaussian Filters

Tone Mapping

Very Underexposed

Underexposed

Good exposure

Overexposed

Motion Blur in Animusic Pipe Dream Demo

Real-time Real-time

version of Animusic Pipe Dream animation from SIGGRAPH 2001 Electronic Theater
Image from Real-Time Image from Real-Time Animusic Pipe Dream demo Animusic Pipe Dream demo
Motion Blur Distorts Shape and Shading

Shape

Stretching objects similar to [Wloka & Zeleznik 96]
Flying balls Plucked strings

Shading

Lower specular exponent and intensity as function

of velocity

Apply per-pixel lod bias as a function of velocity Alpha set to represent contribution to the scene

Motion Blur

Moving Balls

Plucked String

Distorting Shape of Balls
Instantaneous velocity (distance ball
moved since previous time step) is input to vertex shader as is the motion vector M
M (M Eye) is motion perpendicular to

the eye

Vertex shader computes Blur factor 1/(1+distance traveled/ball diameter)

Capsule Distortion

Direction of Motion Path of Motion Direction of Motion Path of Motion

No Motion Blur

With Motion Blur
Distorting Shading of Balls
Blur factor interpolated across polygons
Pixel shader does LOD biased texture load from

broadening the highlight

environment map as function of blurriness factor
Specular exponent (k) gets smaller as ball goes faster, Scalar gloss term also get smaller Serves to distribute the energy over pixels as specular

highlight smears

given pixel
Alpha of pixel says how much the ball was there at a

Motion Blur on Strings

Two instances of string geometry are drawn
when in motion One instance bends back and forth over time and retains original thickness Other instance is stretched apart to span full current amplitude of motion and is blended on top Alpha of second string is function of amplitude More motion equals lower alpha
Image Space Outlining for NPR
Render alternate representation of scene

into texture map

With the RADEON 9700, were able to render into
up to four targets simultaneously, effectively implementing Saito and Takahashis G-buffer
Run filter over image to detect edges
Implemented using pixel shading hardware

Normal and Depth

Eye Space Depth

Outlines

Normal Edges

Depth Edges

Normal and Depth Negated in Shadow
World Space Normal Negated in Shadow
Eye Space Depth Negated in Shadow
Normal and Depth Outlines

Edges from Normals

Edges from Depth
Object and Shadow Outlines
Outlines from selectively negated normals and depths

Texture Region IDs

Edges at Texture Region Boundaries

Edge Filter

t1 t2 t0 t4 t3

5-tap Filter

Edge Filter Code
ps.2.0 def def def def def dcl_2d dcl_2d dcl dcl dcl dcl dcl c0, c3, c8, c9, c12, s0 s1 t0 t1 t2 t3 t4 0.0f, 0.80f, 0, 0 0,.5, 1, 2 0.0f, 0.0f, -0.01f, 0.0f 0.0f, -0.25f, 0.25f, 1.0f 0.0f, 0.01f, 0.0f, 0.0f // normal thresholds // Depth thresholds // TexID Thresholds cmp r10, r10, r10, -r10 add r10, r10, c8.b cmp r10, r10, c1.r, c1.g dp4_sat r10, r10, c3.z mad_sat r10, r10, c1.b, c1.w mul r11, r11, r10 map five times s0 // Center Tap s0 // Down/Right s0 // Down/Left s0 // Up/Left s0 // Up/Right // // // // // // Take absolute value Subtract threshold Make black/white Sum up detected pixels Scale and bias result Combine with previous

// Sample texld r0, texld r1, texld r2, texld r3, texld r4,

the t0, t1, t2, t3, t4,

//----------------------------------------------------// NORMALS //----------------------------------------------------mad r0.xyz, r0, c3.w, -c3.z mad r1.xyz, r1, c3.w, -c3.z mad r2.xyz, r2, c3.w, -c3.z mad r3.xyz, r3, c3.w, -c3.z mad r4.xyz, r4, c3.w, -c3.z // Take dot products with center (Signed result -1 to 1) dp3 r5.r, r0, r1 dp3 r5.g, r0, r2 dp3 r5.b, r0, r3 dp3 r5.a, r0, r4 // Subtract threshold sub r5, r5, c0.g // Make black/white based on threshold cmp r5, r5, c1.g, c1.r // detect any 1's dp4_sat r11, r5, c3.z mad_sat r11, r11, c1.b, c1.w // Scale and bias result //-------------------------------------------------------// Z //-------------------------------------------------------add r10.r, r0.a, -r1.a // Take four deltas add r10.g, r0.a, -r2.a add r10.b, r0.a, -r3.a add r10.a, r0.a, -r4.a
//---------------------------------------------------// TexIDs //---------------------------------------------------// Sample the map five times texld r0, t0, s1 // Center Tap texld r1, t1, s1 // Down/Right texld r2, t2, s1 // Down/Left texld r3, t3, s1 // Up/Left texld r4, t4, s1 // Up/Right // Get differences in color sub r1.rgb, r0, r1 sub r2.rgb, r0, r2 sub r3.rgb, r0, r3 sub r4.rgb, r0, r4 // Calculate magnitude of color differences dp3 r1.r, r1, c3.z dp3 r1.g, r2, c3.z dp3 r1.b, r3, c3.z dp3 r1.a, r4, c3.z cmp r1, r1, r1, -r1 // sub r1, r1, c12.g // cmp r1, r1, c1.r, c1.g // dp4_sat r10, r1, c3.z // mad_sat r10, r10, c1.b, c1.w // mul r11, r10, r11 // // Output mov oC0, r11 Take absolute values Subtract threshold Make black/white Total up edges Scale and bias result Combine with previous

Morphology

Dilate

Dilation Shader

ps.2.0 def c0, 0,.5, 1, 2 def c1, 0.4f, -1, 5.0f, 0 dcl_2d s0 dcl t0 dcl t1 dcl t2 dcl t3 dcl t4 // Sample the map five times texld r0, t0, s0 // Center Tap texld r1, t1, s0 // Up texld r2, t2, s0 // Left texld r3, t3, s0 // Down texld r4, t4, s0 // Right // Sum the samples add r0, r0, r1 add r1, r2, r3 add r0, r0, r1 add r0, r0, r4 mad_sat r0, r0.r, c1.r, c1.g mov oC0, r0

// Threshold

Outlining Sketch
More detail on this in RealReal-
Time Image-Space Outlining Image-Space for Non-Photorealistic Non-Photorealistic Rendering sketch on Thursday in the Rendering session at 3:30 - 5:30 pm in River Room 001

Two-tone Car Paint

Normal Decompression Sparkle from microflake Base color Clear coat Rough Specular

Normal Decompression

Sample from two-channel 16-16 two-channel 16-16
normal map Derive z from +sqrt (1 x2 y2)

Ns and Nss

Two normal maps on car

Normal from appearance preserving
simplification process, N
High frequency normalized vector noise, Nn
Compute Ns and Nss from N and Nn
Ns = (aNn + bN) / |aNn + bN| , where a << b Nss = (cNn + dN) / |cNn + dN| , where c = d

Base Color and Flake

Base color and flake effect are
derived from Ns and Nss using the following polynomial
c0(NsV) + c1(NsV)2 + c2(NsV)4 + c3(NssV)16

Base Color Flake

Layers of Car Paint

Base Color

c0(NsV) + c1(NsV)2 + c2(NsV)4

(NssV)16

HDR Clear Coat

Final Color

RGBScale HDR Environment Map

Ceiling of car showroom

Top Cube Map Face RGB
Top Face Scale in Alpha Channel
Alpha channel contains 1/16 of the true HDR
scale of the pixel value RGB contains normalized color of the pixel Pixel shader reconstructs HDR value from scale*8*color to get half of the true HDR value Obvious quantization issues, but reasonable for some applications Similar to Wards RGBE Real Pixels but simpler to reconstruct in the pixel shader

Image Space Glows

Render scene into multisample AA back
buffer Also render HDR clear coat and other emissive objects into small texture map Run separable Gaussian blur over this small texture similar to RNL demo shown earlier Composite this with rendered scene Gives glows off of any bright areas in the scene, including reflections off of the car body

Rough Specular

Use texldb for all accesses to cubic
environment map For rough specular, the bias is high, causing a blurring effect Also convert color fetched from environment map to luminance in rough trim areas

Summary

2.0 vertex and pixel shaders in DirectX 9 ATI_fragment_program OpenGL Extension Compulsories Homomorphic BRDF Shiny bumpy bouncy fun thing Procedural wood Freestyle Per-Pixel Hatching High Dynamic Range Rendering HDR Environment/Light Maps HDR Scene Post-processing Local versus distant reflections / refractions Motion Blur Image Space Operations for NPR Two-tone layered car paint model

More Information

Notes online at www.ati.com/developer Shader Tool set, RenderMonkey, will be
discussed in Tech Talks Tuesday @ 10 am to noon in Hall D Thursday @ 1pm to 3pm in Hall D Image-space Outlining sketch Thursday in Image-space the Rendering session at 3:30 - 5:30 pm in River Room 001 Fur Sketch Thursday in the Hardware Rendering session at 10:30 am - 12:15 pm in Room 217BCD Come by the ATI Booth

Getting Started Guide

P/N 117-40154-60
Copyright 2003, ATI Technologies Inc. All rights reserved. ATI and all ATI product and product feature names are trademarks and/or registered trademarks of ATI Technologies Inc. All other company and/or product names are trademarks and/or registered trademarks of their respective owners. Features, performance and specifications are subject to change without notice. Product may not be exactly as shown in the diagrams. Reproduction of this manual, or parts thereof, in any form, without the express written permission of ATI Technologies Inc. is strictly prohibited.

Table of Contents

Welcome... 1 Do This First!... 1 Uninstalling Old Graphics Card Software. 3 Installing Your ATI Graphics Card. 4 Installing a RADEON 9700/9500 Series.. 6 Installing a RADEON 9800 Series.. 8 NTSC/PAL Support.. 10 Using the connectors.. 11 Windows New Hardware Found.. 12 Installing the CATALYST Software Suite.. 13 Troubleshooting Tips.. 15 Using the Electronic Users Guide.. 16 Getting Additional Accessories.. 16 Warranty Information.. 17 Product Warranty Registration.. 17 Customer Service... 17 Hardware Warranty Service Statement.. 18 Warranty Service... 19 Compliance Information.. 21 FCC Compliance Information.. 21 Industry Canada Compliance Statement.. 22 CE Compliance Information.. 22 LInformation de conformit de la CE. 23 CE-befolgungInformationen.. 23

Getting Started

Welcome
Congratulations on the purchase of your ATI Graphics Accelerator card! Carefully complete the following simple steps to install your new video card. Soon you will experience the ultimate in graphics performance on your very own computer.

Do This First!

This section applies to AGP Graphic Accelerator cards only.
To ensure a successful installation of your ATI Graphics Accelerator card, you MUST do the following BEFORE replacing your current graphics card with your new ATI card: Install AGP Drivers for non-Intel Chipset Based Motherboards. Several AGP motherboard manufacturers use non-Intel AGP chipsets. Chipsets include those made by Acer Laboratories (ALI), Silicon Integrated Systems (SIS), and VIA Technologies, Inc. Each non-Intel chipset requires the installation of a custom Virtual GART (AGP) Driver. This driver is required by your new ATI card to function correctly with your motherboard. It is very important that the correct AGP driver be installed before installing an AGP video card in your system. An incorrect or missing GART driver can result in AGP memory not being detected or a black screen after Windows loads.
How to determine what motherboard chipset is present on your system:
1 Right-click My Computer and choose Properties. 2 Click the (Hardware Tab in Windows
2000/Windows XP) Device Manager tab then scroll to the bottom of the device list.
3 Select System Devices. 4 Scroll through the list of System Devices until you find
a listing for the AGP controller.
5 The chipset manufacturers name will appear as the
device name. Once you have determined the chipset manufacturer for your motherboard, obtain and then install the latest AGP drivers from: VIA Technologies http://www.viaarena.com Acer Laboratories (ALI) http://www.ali.com.tw Silicon Integrated Systems (SIS) http://www.sis.com Advanced Micro Devices (AMD) http://www.amd.com Intel Technologies http://support.intel.com General Motherboard/chipset information http://www.motherboards.org More information on this topic can be found at http://www.ati.com/support/faq/ agpchipsetdrivers.html
Uninstalling Old Graphics Card Software
To ensure successful installation of your ATI Graphics Accelerator card, you must uninstall the graphic drivers for the existing graphics card before removing it from your computer. To uninstall old graphics drivers With your current graphics card still in your computer:
1 Close all applications that are currently running. 2 Click Start, Settings, Control Panel and select

Add/Remove Programs.

3 Select your current graphic drivers and click

Add/Remove

4 *The Wizard will help you remove your current display

drivers.

5 The System should be restarted after the drivers have
been removed. *If the previously installed graphics card has any additional software installed, they may also need to be removed at this point. (For example DVD Player, Multimedia applications, etc.)
Installing Your ATI Graphics Card
You are now ready to install your card. (RADEON 9800 Series users see Installing a RADEON 9800 Series on page 8 and 9700/9500 Series users see Installing a RADEON 9700/9500 Series on page 6.) If you are not sure whether your card is PCI or AGP, compare the bottom edge of your card with the following illustration:
1 Power-off the computer and monitor. 2 Disconnect the monitor cable from the back of your

computer.

3 Remove the computer cover.
If necessary, consult your computers manual for help in removing the cover.
Remember to discharge your bodys static electricity by touching the metal surface of the computer chassis.
4 Remove any existing graphics card from your
computer. If your computer has an on-board graphics capability, you may need to disable it on the motherboard. For more information, see your computer documentation.
5 After locating the AGP or PCI slot, and if necessary,
removing the metal cover: Align your ATI Graphics Accelerator card with the AGP/PCI slot. Press it in firmly until the card is fully seated.
6 Replace the screw to fasten the card in place, and
replace the computer cover.
7 Plug the monitor cable into your card. 8 Turn on the computer and monitor.
Installing a RADEON 9700/9500 Series
The RADEON 9700/9500 Series requires connection to your PCs internal power supply for operation. Consult your system builder or OEM to ensure your system has an adequate power supply. Otherwise ATI recommends a 300 watt power supply or greater to ensure normal system operation where a number of other internal devices are installed.
Connecting to the Hard Drive power connector Complete the instructions for removing the old video card and software found at Uninstalling Old Graphics Card Software on page 3. Use the supplied Power Extension Cable to connect the RADEON 9700/9500 Series to the computers Hard Drive power connector.
1 Locate the AGP slot, if necessary, removing the
metal cover: Align your ATI Graphics Accelerator card with the AGP slot. Press it in firmly until the card is fully seated.
2 Remove the power cable from the Hard Drive power

connector.

3 Connect A of the Power Extension Cable to the
RADEON 9700/9500 Series power connector as shown. (The cable may already be connected to the graphics card.)

4 Connect B to the power supply connector. 5 Connect C to the Hard Drive power connector
Your computer will beep and a warning message may appear on the display and the boot process will stop if the RADEON 9700/9500 Series is not correctly connected to the power supply.
Installing a RADEON 9800 Series
The RADEON 9800 Series requires connection to your PCs internal power supply for operation. Consult your system builder or OEM to ensure your system has an adequate power supply. Otherwise ATI recommends a 300 watt power supply or greater to ensure normal system operation where a number of other internal devices are installed.
Connecting to the Hard Drive power connector Complete the instructions for removing the old video card and software found at Uninstalling Old Graphics Card Software on page 3. For users living in countries that use the PAL Television standard see NTSC/PAL Support on page 10. Use the supplied Power Extension Cable to connect the RADEON 9800 Series to the computers Hard Drive power connector.
RADEON 9800 Series power connector as shown. (The cable may already be connected to the graphics card.)
4 Connect B to the power supply connector. 5 Connect C to the Hard Drive power connector.
Your computer will beep and a warning message may appear on the display and the boot process will stop if the RADEON 9800 Series is not correctly connected to the power supply.

NTSC/PAL Support

The RADEON 9800 Series provides both NTSC and PAL support. NTSC is the TV standard used in North America. PAL is the TV standard for most of Europe.
The default setting for the RADEON 9800 Series is NTSC. If you live in North America there is no need to change this setting unless you intend to use PAL standard equipment (for example, PAL Camcorder/PAL VCR).
To change the setting to PAL:
1 Remove the RADEON 9800 Series from your
2 Locate the orange switch near the fan (see illustration

on page 9).

3 Use a sharp pencil to move slider switch number 1 as
shown in the illustration.
4 Re-install the graphics accelerator card into your

Using the connectors

The following illustration shows all possible connector combinations. Your specific ATI Graphics Accelerator card may not have all the shown connectors. S-VID OUT and COMP OUT ports are both shown here to illustrate the connections. Your card will have one or the other, not both.

The optional S-Video TV Out connector on your ATI Graphics Accelerator card can be used to connect to your TV, VCR, or camcorder. If your TV, VCR, or camcorder only supports a composite connector, a S-Video-toComposite connector can be purchased that allows you to connect to a device with a composite connector. See Getting Additional Accessories on page 16.
Windows New Hardware Found
Windows may start the Add New Hardware Wizard to install the Standard VGA Driver. To correctly install your new hardware: Cancel the Wizard if you are using Windows 2000 or Windows XP, and proceed to Installing the CATALYST Software Suite on page 13. If the Add New Hardware Wizard does not appear, proceed to Installing the CATALYST Software Suite on page 13. If the Add New Hardware Wizard does appear:
1 Click Next to allow Windows to search for the
Standard VGA or Standard PCI Graphics Adapter. If prompted for the Windows CD-ROM, insert it into your CD-ROM drive.
2 Type the following: D:\<Operating System name> for
example D:\WinME If D is not your CD-ROM drive, substitute D with the correct drive letter.
3 Click OK. 4 Click Finish to close the Wizard. The system should

now be restarted.

Installing the CATALYST Software Suite
ATIs CATALYST software suite provides the ultimate software required to enjoy the full acceleration of your ATI Graphics Accelerator card. The CATALYST software suite comprises four, distinct software elements: Driver. Multimedia Center. HydraVision (not included in the Express Install). Remote Wonder Software. To ensure you install the latest software, use the ATI Installation CD-ROM that shipped with your ATI Graphics Accelerator card. To install the CATALYST software suite
1 Insert the ATI INSTALLATION CD-ROM into your
CD-ROM drive. If Windows runs the CD-ROM automatically, proceed to step 6.
2 Click Start. 3 Select Run. 4 Type the following: D:\ATISETUP
(If D is not your CD-ROM drive, substitute D with the correct drive letter.)
Click OK. Click Install under Software Install. Click Next. Click Yes to the license agreement. ATI Easy Install to begin the Installation Wizard.
10 Follow the Wizards on-screen instructions to complete
the installation. The Express installation option is recommended. If your ATI Graphics Accelerator card includes a multimedia component, the software for that component will automatically be installed, along with the ATI graphics driver. Not all software components are installed using the Express installation. Custom installation allows you to select individual software components for installation.

Troubleshooting Tips

The following troubleshooting tips may help if you experience problems. Contact your dealer or ATI for more advanced troubleshooting information. Check that the card is seated properly in the AGP or PCI slot. Ensure that the monitor cable is securely fastened to the cards monitor connector. Make sure that the monitor and computer are plugged in and receiving power. If necessary, disable any built-in graphics capabilities on your motherboard. For more information, consult your computers manual or manufacturer. (NOTE: Some manufacturers do not allow the built-in graphics to be disabled or to become the secondary display.) For more troubleshooting tips, right-click the ATI icon in the taskbar and select Troubleshooting. If you have problems during bootup, start your computer in Safe Mode. Hold the CTRL key until the Microsoft Windows Startup Menu appears on the screen. Then select the number for Safe Mode, and press Enter. (You can also use F8 to bring up the Microsoft Windows Startup Menu.) In Safe Mode, go to the Device Manager and remove all duplicate display adapter and monitor entries if you are only using one graphics card. For more assistance, use the Troubleshooting Guide located in the Windows Help or contact your computer manufacturer.

Using the Electronic Users Guide
Your ATI Graphics Accelerator card comes complete with a Users Guide in Portable Document Format (PDF). The Users Guide describes in detail the features and functions of your ATI Graphics Accelerator card and the associated software. You will need the latest Adobe Acrobat Reader software available from www.adobe.com To open the Users Guide

CD-ROM drive.

2 If Windows runs the CD-ROM automatically, proceed

to step 6.

3 Click Start. 4 Select Run. 5 Type the following: D:\ATISETUP
6 Click OK. 7 Click Documentation. 8 Click User Guides.
Getting Additional Accessories
Additional and replacement cables, installation CD-ROMs, manuals and other accessories for ATI products can be purchased from the online ATI store at http://www.ati.com/online/accessories

Warranty Information

Product Warranty Registration
To receive Customer Service you must register your product with ATI. Online Product Warranty Registration is available at: http://www.ati.com/online/registration

Customer Service

For detailed instructions on how to use your ATI product, refer to the Online Users Guide included on your ATI Installation CD-ROM. If you require further assistance with your product, the following options are available: Online: For product information, video drivers, Frequently Asked Questions and Email support visit: http://www.ati.com and select Customer Service for Built By ATI products. Telephone: Available Monday to Friday, 9:00 AM - 7:00 PM EST. *905-882-2626 *Access to Telephone Support is available to registered users at no additional cost for the first 30 days from the date of purchase (long distance charges may apply). For complete details please visit: http://www.ati.com/online/customercare
Mail: ATI TECHNOLOGIES INC. Attention: Customer Service 33 Commerce Valley Drive East Markham, Ontario Canada L3T 7N6
Hardware Warranty Service Statement
Should the product, in ATIs opinion, malfunction within the warranty period, ATI will at its discretion repair or replace the product upon receipt with an equivalent. Any replaced parts become the property of ATI. This warranty does not apply to the software component of a product or a product which has been damaged due to accident, misuse, abuse, improper installation, usage not in accordance with product specifications and instructions, natural or personal disaster, or unauthorized alterations, repairs, or modifications. For a detailed description of the ATI Hardware Warranty Service Statement visit: http://www.ati.com/online/warranty/statement

Warranty Service

For warranty service instructions visit: http://www.ati.com/online/warranty or contact one of our Customer Service Representatives using one of the aforementioned means. Before shipping any unit for repair, obtain an RMA number for warranty service. When shipping your product, pack it securely, show the RMA and serial number of the product on the outside, and ship prepaid and insured. ATI will not be held liable for damage or loss to the product in shipment. Limitations This warranty is valid only if the online Product Warranty Registration form at: http://www.ati.com/online/registration is successfully submitted within 30 days of purchase of said product. All warranties for this product, expressed or implied, will expire three (3) years* from date of original purchase. *The ATI REMOTE WONDER unit is warranted for 1 year.
DV WONDER is warranted for 2 years. All accompanying cables and accessories are warranted for 90 days.
No warranties for this product, expressed or implied, shall extend to any person who purchases the product in a used condition.
The liability of ATI in respect of any defective product will be limited to the repair or replacement of such product. ATI may use new or equivalent-to-new replacement parts. Defective product will be sent in for repair or replacement only. ATI makes no other representations or warranties as to fitness for a particular purpose, merchantability or otherwise in respect of the product. No other representations, warranties or conditions, shall be implied by statute or otherwise. In no event shall ATI be responsible or liable for any damages, including but not limited to the loss of revenue or profit, arising: from the use of the product, from the loss of use of the product, as a result of any event, circumstance, action or abuse beyond the control of ATI; whether such damages be direct, indirect, consequential, special or otherwise and whether such damages are incurred by the person to whom this warranty extends or a third party.

Compliance Information

FCC Compliance Information
The RADEON family of products complies with FCC Rules Part 15. Operation is subject to the following two conditions This device may not cause harmful interference, and This device must accept any interference received, including interference that may cause undesired operation. This equipment has been tested and found to comply with the limits for a Class B digital device, pursuant to Part 15 of the FCC Rules. These limits are designed to provide reasonable protection against harmful interference in a residential installation. This equipment generates, uses and can radiate radio frequency energy and, if not installed and used in accordance with manufacturer's instructions, may cause harmful interference to radio communications. However, there is no guarantee that interference will not occur in a particular installation. If this equipment does cause harmful interference to radio or television reception, which can be determined by turning the equipment off and on, the user is encouraged to try to correct the interference by one or more of the following measures: Re-orient or relocate the receiving antenna. Increase the separation between the equipment and receiver. Connect the equipment to an outlet on a circuit different from that to which the receiver is connected. Consult the dealer or an experienced radio/TV technician for help.