1 / 33

CS361

Week 3 - Monday. CS361. Last time. What did we talk about last time? Graphics rendering pipeline Rasterizer Stage. Questions?. Project 1. Assignment 1. XNA Drawing Primitives. The BasicEffect class. An effect says how things should be rendered on the screen

necia
Download Presentation

CS361

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. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Week 3 - Monday CS361

  2. Last time • What did we talk about last time? • Graphics rendering pipeline • Rasterizer Stage

  3. Questions?

  4. Project 1

  5. Assignment 1

  6. XNA Drawing Primitives

  7. The BasicEffect class • An effect says how things should be rendered on the screen • We can specify this in details using shader programs • The BasicEffect class gives you the ability to do effects without creating a shader program • Less flexibility, but quick and easy • The BasicEffect class has properties for: • World transform • View transform • Projection transform • Texture to be applied • Lighting • Fog

  8. Vertices • Vertices can be stored in many different formats depending on data you want to keep • Position is pretty standard • Normals are optional • Color is optional • We will commonly use the VertexPositionColor type to hold vertices with color

  9. Vertex buffers • The GPU holds vertices in a buffer that can be indexed into • Because it is special purpose hardware, it has to be accessed in special ways • It seems cumbersome, but we will often create an array of vertices, create an appropriately sized vertex buffer, and then store the vertices into the buffer VertexPositionColor[] vertices = newVertexPositionColor[3] { newVertexPositionColor(new Vector3(0, 1, 0), Color.Red), newVertexPositionColor(new Vector3(+0.5f, 0, 0), Color.Green), newVertexPositionColor(new Vector3(-0.5f, 0, 0), Color.Blue) }; vertexBuffer = newVertexBuffer(GraphicsDevice, typeof(VertexPositionColor), 3, BufferUsage.WriteOnly); vertexBuffer.SetData<VertexPositionColor>(vertices);

  10. Vertices • We will define a list of vertices • Then we will define primitives with lists of indices into that list VertexPositionColor[] vertices = newVertexPositionColor[3] { newVertexPositionColor(new Vector3(0, 1, 0), Color.Red), newVertexPositionColor(new Vector3(+0.5f, 0, 0), Color.Green), newVertexPositionColor(new Vector3(-0.5f, 0, 0), Color.Blue) }; short[] indices = new short[3] { 0, 1, 2};

  11. Drawing an icosahedron • An icosahedron has 20 sides, but it only has 12 vertices • By using an index buffer, we can use only 12 vertices and 60 indices

  12. Lists and strips • It is very common to define primitives in terms of lists and strips • A list gives all the vertex indices for each of the shapes drawn • 2n indices to draw n lines • 3n indices to draw n triangles • A strip gives only the needed information to draw a series of connected primitives • n + 1 indices to draw a connected series of n lines • n + 2 indices to draw a connected series of n triangles

  13. Student Lecture: Programmable Shading

  14. GPU

  15. GPU • GPU stands for graphics processing unit • The term was coined by NVIDIA in 1999 to differentiate the GeForce256 from chips that did not have hardware vertex processing • Dedicated 3D hardware was just becoming the norm and many enthusiasts used an add-on board in addition to their normal 2D graphics card • Voodoo2

  16. More pipes! • Modern GPU's are generally responsible for the geometry and rasterization stages of the overall rendering pipeline • The following shows colored-coded functional stages inside those stages • Red is fully programmable • Purple is configurable • Blue is not programmable at all

  17. Programmable Shading

  18. Programmable Shaders • You can do all kinds of interesting things with programmable shading, but the technology is still evolving • Modern shader stages such as Shader Model 4.0 and 5.0 (DirectX 10 and 11) use a common-shader core • Strange as it may seem, this means that vertex, pixel, and geometry shading uses the same language

  19. Shading languages • They are generally C-like • There aren't that many: • HLSL: High Level Shading Language, developed by Microsoft and used for Shader Model 1.0 through 5.0 • Cg: C for Graphics, developed by NVIDIA and is essentially the same as HLSL • GLSL: OpenGL Shading Language, developed for OpenGL and shares some similarities with the other two • These languages were developed so that you don't have to write assembly to program your graphics cards • There are even drag and drop applications like NVIDIA's Mental Mill

  20. Virtual machines • To maximize compatibility across many different graphics cards, shader languages are thought of as targeting a virtual machine with certain capabilities • This VM is assumed to have 4-way SIMD (single-instruction multiple-data) parallelism • Vectors of 4 things are very common in graphics: • Positions: xyzw • Colors: rgba • The vectors are commonly of float values • Swizzling and masking (duplicating or ignoring) vector values are supported (kind of like bitwise operations)

  21. Programming model • A programmable shader stage has two types of inputs • Uniform inputs that stay constant during draw calls • Held in constant registers or constant buffers • Varying inputs which are different for each vertex or pixel

  22. Language style • Fast operations: scalar and vector multiplications, additions, and combinations • Well-supported (and still relatively fast): reciprocal, square root, trig functions, exponentiation and log • Standard operations apply: + and * • Other operations come through intrinsic functions that do not require headers or libraries: atan(), dot(), log() • Flow control is done through "normal" if, switch, while, and for (but long loops are unusual)

  23. Where the idea comes from • In 1984, Cook came up with the idea of shade trees, a series of operations used to color a pixel • This example shows what the shader language equivalent of the shade tree is

  24. Shaders • There are three shaders you can program • Vertex shader • Useful, but boring, mostly about doing transforms and getting normals • Geometry shader • Optional, allows you to create vertices from nowhere in hardware • Pixel shader • Where all the color data gets decided on • Also where we'll focus

  25. Example of real shadercode • The following, taken from RB Whitaker's Wiki, shows a shader for ambient lighting • We start with declarations: float4x4 World; float4x4 View; float4x4 Projection; float4 AmbientColor = float4(1, 1, 1, 1); float AmbientIntensity = 0.1; structVertexShaderInput { float4 Position : POSITION0; }; structVertexShaderOutput { float4 Position : POSITION0; };

  26. Example of real shader code continued VertexShaderOutputVertexShaderFunction(VertexShaderInput input) { VertexShaderOutput output; float4 worldPosition = mul(input.Position, World); float4 viewPosition = mul(worldPosition, View); output.Position = mul(viewPosition, Projection); return output; } float4 PixelShaderFunction(VertexShaderOutput input) : COLOR0 { return AmbientColor * AmbientIntensity; } technique Ambient { pass Pass1 { VertexShader = compile vs_1_1 VertexShaderFunction(); PixelShader = compile ps_1_1 PixelShaderFunction(); } }

  27. The result, applied to a helicopter model:

  28. More advanced shader code • The following, taken from RB Whitaker's Wiki, shows a shader for diffuse lighting float4x4 World; float4x4 View; float4x4 Projection; float4 AmbientColor = float4(1, 1, 1, 1); float AmbientIntensity = 0.1; float4x4 WorldInverseTranspose; float3 DiffuseLightDirection = float3(1, 0, 0); float4 DiffuseColor = float4(1, 1, 1, 1); float DiffuseIntensity = 1.0; structVertexShaderInput { float4 Position : POSITION0; float4 Normal : NORMAL0; }; structVertexShaderOutput { float4 Position : POSITION0; float4 Color : COLOR0; };

  29. More advanced shader code continued VertexShaderOutputVertexShaderFunction(VertexShaderInput input){ VertexShaderOutput output; float4 worldPosition = mul(input.Position, World); float4 viewPosition = mul(worldPosition, View); output.Position = mul(viewPosition, Projection); float4 normal = mul(input.Normal, WorldInverseTranspose); float lightIntensity = dot(normal, DiffuseLightDirection); output.Color = saturate(DiffuseColor * DiffuseIntensity * lightIntensity); return output; } float4 PixelShaderFunction(VertexShaderOutput input) : COLOR0 { return saturate(input.Color + AmbientColor * AmbientIntensity); } technique Diffuse { pass Pass1 { VertexShader = compile vs_1_1 VertexShaderFunction(); PixelShader = compile ps_1_1 PixelShaderFunction(); } }

  30. The result, applied to a helicopter model:

  31. Upcoming

  32. Next time… • GPU architecture • Vertex shading • Geometry shading • Pixel shading

  33. Reminders • Keep reading Chapter 3 • Keep working on Assignment 1, due this Friday by 11:59 • Keep working on Project 1, due next Friday, February 8 by 11:59 • Programming Club tonight at 6pm in E281!

More Related