An Introduction to the Cg Shading Language Marco Leon Brandeis University Computer Science Department

Topics Background definitions Shading Language Basics Cg specifics Simple sample Cg programs How to call Cg programs from C/C++ Performance tips Frame-buffer Objects (if time permits) References: Learn more!

Motivation Languages like Cg allow programmers to have more control over the graphics processor. Code is easier to produce, comprehend and maintain. Can take more advantage of the graphics acceleration technology available today. Produce better-looking, faster graphics.

GPU Graphics Processing Unit (GPU). Processor specialized in transforming, rasterizing, and rendering 3D models into 2D images. CPU for general computation, GPU specialized in graphics computation. CPU can do anything GPU can do, but GPU is faster for parallel floating point calculations.

Shading Language Instructions are executed in GPU. Cg, OpenGL Shading Language, and High-level Shading Language (HLSL) are examples of shading languages. Programs are called shaders, can be compiled and executed at run-time from inside a C++ application. Shaders are run as a result of the graphics library’s call to “draw” or render polygons.

Why Use Shaders? Speed. GPUs specialize in performing many float operations in parallel, making them faster than CPUs for most 3D graphics operations. Programmability. Before high-level shaders, GPUs could only be programmed using assembly code.

Vertex Shaders Program that is executed for every vertex in a 3D model sent through the pipeline. Changes vertex positions for animation Performs transformations from object space to eye space or world space. Can do lighting calculations.

Pixel Shaders Also known as fragment shaders. Executed for every fragment (potential pixel) that is rasterized from the polygons created from the vertices. Usually perform lighting, shading, and texturing calculations.

Programmable Graphics Pipeline

Data Types Vectors and Matrices supported as packed arrays. Operations between these types are processed in parallel (more efficient use of hardware). Vector types are float2, float3, float4, half2, half3, half4 (half the precision of a float). E.g., “float3 vertexPos;” has three values that can be accessed individually by vertexPos.x, vertexPos.y, vertexPos.z. Matrices have similar types. A 4x4 matrix can be defined as “float4x4 matrixName;”

Data Types Semantics are special words preceded by a colon that indicate an input or output that is varying, i.e. different for each vertex/fragment processed by a shader. A uniform parameter to a function is a set of data that is the same for all vertices/fragments. These values are accessible to every vertex/fragment and are loaded to memory only once for all vertices/fragments processed.

Textures Textures: common uniform input type for large quantities of data in shaders. They are one, two, or three-dimensional arrays of packed arrays. Typically, a texture would be a two- dimensional array of float3 values that contain the RGB values of an image. In practice, a texture can contain any kind of data.

Homogeneous Coordinates 3D positions expressed as 4D vectors All transformations (rotation, translation, scaling, etc.) are 4x4 matrices Matrix/vector multiplication is the only operator needed in homogeneous coordinate transforms All transformations can be multiplied and compounded into a single transform to multiply by each vertex

Transformations

Cg Language Many math expressions supported by language: lerp (linear interpolation), reflect (reflection vector calculation), dot (dot product) and cross (cross product), tex2D (2D texture lookup), etc. Structures, and arrays, if size is known at compile-time (pointers not supported) Functions and return statement If-else For, while, and do-while

A Simple Vertex Program Void translateXby1(float3 position : POSITION, float2 texCoord : TEXCOORD0, out float4 oPosition : POSITION, outfloat2 oTexCoord : TEXCOORD0) { oPosition = float4(position + float3(1,0,0), 1); oTexCoord = texCoord; }

A Simple Fragment Program Void modulate(float4 color : COLOR, float2 texCoord : TEXCOORD0, outfloat4 oColor : COLOR, uniformsampler2D decal) { float4 decalColor = tex2D(decal, texCoord); oColor = lerp(color, decalColor, 0.5); }

Cg Runtime (for C/C++) #include CGcontext context = cgCreateContext(); CGprogram program = cgCreateProgram(context, CG_SOURCE, // or object programString, // text/data profile, // depends on GPU “main”, // entry function name args ); // compiler options

Cg Runtime (for C/C++) cgGLLoadProgram(program); Cgparameter myParameter = cgGetNamedParameter(program, “myParameter”); cgGLSetParameter4fv(myParameter, value); cgGLEnableProfile(CG_PROFILE_ARBVP1); cgGLBindProgram(program); cgDestroyProgram(program); cgDestroyContext(context); Cgerror error = cgGetError(); Const char* errorString = cgGetErrorString(error);

Performance Tips Use the Cg Standard Library Take advantage of Uniform parameters (by computing unchanging calculations outside of shader if possible) Using Vertex Programs vs. Fragment Programs Use lower precision data types if possible Take advantage of Vectorization (use parallel computations by performing operations on one float4 instead of doing it four times for a float)

Performance Tips Use textures to encode functions (texture lookups are usually faster than math) Use swizzling and negation freely, no performance penalty. E.g., float4(myScalar.xxx, 1) Shade only pixels that you must (perform depth test before fragment program runs) Shorter assembly is not necessarily faster

GPGPU Shaders normally help render a 2D image of a 3D world on the window. GPGPU (General-purpose GPU) techniques use GPU for any task involving intensive, parallel floating point computation. Only way to output data computed in a shader is to render a texture, using the color channels to store floating point data. Texture is not displayed on the window, but rendered off-screen to be accessed by C++ application.

Frame-buffer Objects (FBOs) Most recent technique to render-to-texture or to Renderbuffers, better performance than P- buffer and ARB render texture Applications: dynamic textures, multi-pass techniques, image processing effects, GPGPU Uses OpenGL extension called EXT_framebuffer_object

FBO Advantages Requires only a single OpenGL context No need for complicated pixel format selection Avoids performing copy from framebuffer to texture Uses less memory, only one copy of image

References Cg Toolkit User’s Manual. ftp://download.nvidia.com/developer/cg/Cg_1.4/ Docs/CG_UserManual_1-4.pdf ftp://download.nvidia.com/developer/cg/Cg_1.4/ Docs/CG_UserManual_1-4.pdf The OpenGL Framebuffer Object Extension. ons/2005/GDC/OpenGL_Day/OpenGL_FrameB uffer_Object.pdf ons/2005/GDC/OpenGL_Day/OpenGL_FrameB uffer_Object.pdf Fernando, R. and Kilgard, M. The Cg Tutorial NVIDIA Corporation.