slide1 l.
Download
Skip this Video
Loading SlideShow in 5 Seconds..
CS148: Introduction to Computer Graphics and Imaging Programmable Shaders PowerPoint Presentation
Download Presentation
CS148: Introduction to Computer Graphics and Imaging Programmable Shaders

Loading in 2 Seconds...

play fullscreen
1 / 32

CS148: Introduction to Computer Graphics and Imaging Programmable Shaders - PowerPoint PPT Presentation


  • 608 Views
  • Uploaded on

CS148: Introduction to Computer Graphics and Imaging Programmable Shaders Topics The Graphics Pipeline Fixed-function Programmable Programming Model Vertex, Geometry, Pixel Shaders Parallelism Implementation GLSL Syntax Limitations GPGPU The Graphics Pipeline

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about 'CS148: Introduction to Computer Graphics and Imaging Programmable Shaders' - liam


An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
topics
Topics

The Graphics Pipeline

  • Fixed-function
  • Programmable

Programming Model

  • Vertex, Geometry, Pixel Shaders
  • Parallelism

Implementation

  • GLSL Syntax
  • Limitations

GPGPU

geometry rendering stages
Geometry Rendering Stages

Vertex

Data

Tessellation

Vertex Processing

Pixel Processing

Geometry Processing

Pixel Rendering

Primitive Data

Texture Sampler

Textured Surface

rasterization
Rasterization

Input: Vertices & values (ex. color, texture)

Output: Pixels & interpolated values

fixed function pipeline
Fixed Function Pipeline

Math

OpenGL

glLightfv(GL_LIGHT0, GL_DIFFUSE, P);

glLightfv(GL_LIGHT0, GL_POSITION, C);

glEnable(GL_LIGHT0);

glBlendFunc(GL_SRC_ALPHA, GL_ONE);

glEnable(GL_BLEND);

?

programmable rendering
Programmable Rendering

Code

Vector4 RenderPixel(

Vector3 Position,

Vector3 Normal)

{

...

return Vector4(0, 0, 1, 0);

}

limitations
Limitations

Mutable

Pixels

Geometry

Vertices

Immutable

  • Clipping
  • Triangle scanlines
direct3d 10 pipeline
Direct3D 10 pipeline
  • Traditional graphics pipeline
  • Three application-programmable stages operate on independent vertex, primitive, and pixel fragments
  • All stages share the same programming model and can query the same resources

Vertices

Input Assembler

Textures

Sampler

Vertex Shader

Constants

Textures

Sampler

Geometry Shader

Constants

CPU or GPU Memory

Rasterizer

Textures

Sampler

Pixel Shader

Constants

Application Programmable

Target Surface

Output Merger

vertex shader
Vertex Shader

Inputs

    • Program-provided vertex data
      • glVertex3d(1.0, 2.0, 3.0);
      • glNormal3d(1.0, 0.0, 0.0);
    • Constants
    • Textures
  • Outputs
    • Position
    • Array of floats used by future pipeline stages
      • Structure determined entirely by programmer
geometry shader
Geometry Shader

Inputs

    • Geometric primitive (point, line, triangle, quad)
    • Adjacent vertex information (AV0, AV1, AV2)
  • Outputs
    • More geometric primitives
pixel shader
Pixel Shader

Inputs

    • Array of floats from vertex/geometry shader
    • Constants
    • Textures
  • Outputs
    • 4-channel color
    • Depth
simple vertex shader
Simple Vertex Shader

void main()

{

gl_Position = gl_ModelViewProjectionMatrix *

gl_Vertex;

}

gl_Position = output of vertex shader

gl_Vertex = glVertex3d(x, y, z);

or STShape::…

gl_ModelViewProjectionMatrix =

glLoadMatrixd(M);

or STTransform::…

variables
Variables

Local Variables

{ vec2 SomeVector = vec2(sin(2.0), sqrt(3.0));

float SomeFloat = SomeVector.x * SomeVector.y;

}

“Varying” Variables

Varyings are output by the vertex shader and interpolated across each primitive for the pixel shader

varying vec2 TextureCoord0;

void main() {

TextureCoord0 = vec2(gl_Position.x, 2.0);

}

variables20
Variables

Uniform Variables

Uniforms are variables set by the program that can be changed at runtime, but are constant across each execution of the shader

uniform float CurrentTime;

void main() {

float Displacement = cos(CurrentTime * 10);

}

C++ code to change this value might look like:

STVertexShader Shader;

Shader.SetUniformVariable(“CurrentTime”, ElapsedTimeInSeconds);

textures
Textures

Textures are mapped from (0, 0) to (1, 1)

Only relatively recent cards support vertex shader textures, almost all support pixel shader textures

uniform sampler2D SomeTexture;

void main()

{

vec4SomeTextureColor =

texture2D(SomeTexture, vec2(0.5, 0.5));

}

vectors
Vectors

Constructors

vec3 V3 = vec3(1.0, 2.0, 3.0);

vec4 V4 = vec4(V3, 4.0);

Swizzling

vec2 V2 = V4.xy;

vec4 V4Reverse = V4.wzyx;

vec4 Result = V4.xyzw + V4.xxxx;

Basic Vector Operators

float Result = dot(V4, V4Reverse);

vec3 Result = cross(V3, vec3(1.0, 0.0, 0.0));

simple pixel shader
Simple Pixel Shader

varying vec2 TexCoord0;

varying vec2 TexCoord1;

uniform sampler2D SomeTexture0;

uniform sampler2D SomeTexture1;

void main()

{

gl_FragColor =

texture2D(SomeTexture0, TexCoord0) * 0.5 +

texture2D(SomeTexture1, TexCoord1) * 0.5;

}

gl_FragColor = output of pixel shader

functions
Functions

Very similar to C:

boolCompare(in vec3 a, in vec3 b)

{return dot(a, a) > dot(b, b);

}

limitations25
Limitations

Memory

    • No access to nearby pixels
    • Cannot bind render target as input texture
    • Limited stack space, instruction count
  • Performance
    • Branching support is limited and slow
    • Graphics card will timeout if code takes too long
    • Variable support across different graphics cards
    • Programmable code is much slower than dedicated hardware
practical shading the bloom effect
Practical Shading: The Bloom Effect

Images from Gamasutra.com & Tron 2.0

practical shading bump mapping
Practical Shading: Bump-mapping

A fraction of the cost of increasing the initial number of polygons or using the geometry shader

parallelism
Parallelism

CPU

  • Thread synchronization
  • Bandwidth limitations
  • Scheduling overhead
  • Small number of cores

GPU

  • All threads independent
  • Message passing is not allowed
  • Resource allocation is done by GPU
  • Many cores available (12 to 48 typical)
ideal gpu problems
Ideal GPU Problems

GPU’s are great if the problem:

  • Executes the same code many times on different input
  • Needs lots of math units at the same time
  • Does not share data between executing components
  • Can be expressed as a sequence of operations acting on a stream of data
  • Large data sets
  • Has lots of work to do without CPU intervention
general purpose gpu s
General Purpose GPU’s

Beyond triangle rendering

    • Collision detection
    • Fluid simulation
    • Physics
    • Raytracing
    • Video compression
  • Beyond graphics
    • Folding@Home
    • Speech Recognition
    • Partial differential equation solvers
    • Fourier transform
object reconstruction from images
Object Reconstruction from Images

Massive non-linear optimization problem

Output: Geometry of photographed object

Input: 200 640x480 images

(~250MB)