Designing a Modern GPU Interface
|
|
- Johnathan Chandler
- 5 years ago
- Views:
Transcription
1 Designing a Modern GPU Interface Brooke Hodgman
2 How to make a wrapper for D3D9/11/12, GL2/3/4, GL ES2/3, Metal, Mantle, Vulkan, GNM & GCM without going (completely) insane Brooke Hodgman
3 Agenda GPU Interface wrapper around the native GPU APIs for every platform Pipeline State management Resource management Shader program management (e.g. Microsoft.fx or Nvidia.cgfx) Q&A
4 Where does this fit in? Shading Pipeline Deferred/Forward shading, post-processing, order of passes, high level techniques Scene Manager Spatial partitioning, Camera management, object culling Game Engine Specific Drawable Types Generic models, Particle systems, Animated meshes, Instanced meshes Today! GPU Interface Lowest level portable rendering API. Just a GPU abstraction.
5 Goals Flexibility Can do anything that the native APIs let us do. No cutting out features. Productivity Much simpler to use than the native APIs. Less code, and less mental tax. Performance Similar CPU frame-time to hand-written native code. Simplicity Keep the interface as small as possible.
6 Dog food test 22 PC, PS4, Xbox One Don Bradman Cricket (port) PS4, Xbox One Rugby League Live 3 Steam, PS4, PS3, Xbox One, Xbox 360
7 The GPU pipeline SM2 Draw: Input Assembler Vertex Shader Rasterizer Pixel Shader Output Merger Resources / Memory (Textures, Buffers, Samplers)
8 The GPU pipeline Vertex texture fetch SM3 Draw: Input Assembler Vertex Shader Rasterizer Pixel Shader Output Merger Resources / Memory (Textures, Buffers, Samplers)
9 The GPU pipeline Geometry Shader & Stream Out stage + Compute shaders SM4 Draw: Input Assembler Vertex Shader Geometry Shader Rasterizer Stream Out Pixel Shader Output Merger Resources / Memory (Textures, Buffers, Samplers) Dispatch: Compute Shader
10 The GPU pipeline Read-Write resources (UAVs) at pixel shader + Tessellation stages SM5 Draw: Input Assembler Vertex Shader Hull Shader Tessellator Domain Shader Geometry Shader Rasterizer Stream Out Pixel Shader Output Merger Resources / Memory (Textures, Buffers, Samplers) Dispatch: Compute Shader
11 The GPU pipeline Read-Write resources at every stage SM5+ Draw: Input Assembler Vertex Shader Hull Shader Tessellator Domain Shader Geometry Shader Rasterizer Stream Out Pixel Shader Output Merger Resources / Memory (Textures, Buffers, Samplers) Dispatch: Compute Shader
12 The GPU pipeline Most common features Draw: Input Assembler Vertex Shader Rasterizer Stream Out Pixel Shader Output Merger Resources / Memory (Textures, Buffers, Samplers) Dispatch: Compute Shader
13 The GPU pipeline Most common features, API view API states: Input Layout Programs Raster Depth / Stencil Blend Draw Command Input Assembler Vertex Shader Rasterizer Stream Out Pixel Shader Output Merger Resource bindings: Buffer Buffer Buffer / Texture / Sampler Depth Texture Colour Texture
14 The GPU pipeline Most common features, API view Programs Dispatch Command Compute Shader Buffer / Texture
15 Stateless Rendering
16 Native APIs are state machines Draw(3, TRIANGLES) Behaviour depends on the current state??????????????? Input Assembler Vertex Shader Rasterizer Stream Out Pixel Shader Output Merger???????????????
17 Native APIs are state machines BindTexture( t ) plug some resources in BindVertexBuffer( v ) BindRenderTarget( r )??????????????? Input Assembler Vertex Shader Rasterizer Stream Out Pixel Shader Output Merger v??? t??? r
18 Native APIs are state machines SetBlend( OPAQUE ) configure some fixed-function bits SetShaderProgram( s ) plug some procedures in??? s?????? OPAQUE Input Assembler Vertex Shader Rasterizer Stream Out Pixel Shader Output Merger v t??? r
19 Native APIs are state machines SetInputLayout( l ) SetRaster( SOLID ) SetDepthTest( DISABLED ) l s SOLID DIS- ABLED OPAQUE Draw(3, TRIANGLES) Input Assembler Vertex Shader Rasterizer Stream Out Pixel Shader Output Merger v t r
20 State machine issues (and features) Objects can specify that they don t care about a state (by not setting it) Don t care states can be inherited from the calling logic. SetBlend( Translucent ) House.Draw() Tree.Draw()
21 State machine issues and features But this system of inherited state can be very fragile to code modifications. void House::Draw(){ SetBlend( Opaque ) Draw( TRIANGLES,3 ) } SetBlend( Translucent ) House.Draw() Tree.Draw() uh oh!
22 State machine issues and features It can also lead to inefficiencies as your graphics programmers become pessimistic. void Tree::Draw(){ SetBlend( Opaque )... } void House::Draw(){ SetBlend( Opaque )... }
23 Stateless Alternative Simplify the API remove the entire state machine concept! Less mental tax no worrying about leaky states Retain the flexibility of don t care states but remove the fragility that it has in state-machine APIs
24 Draw Items Bundle all native API state and all resource bindings together into a Draw Item. Missing / don t care states are always filled in by some form of default value. Pipeline state Input Layout Raster Depth / Stencil Blend Programs Resources Buffer Texture Sampler Primitives Draw Command
25 Draw Items draw_item = CreateDrawItem(... ) Submit( draw_item ) Behaviour depends only on the contents of the draw item draw_item Lay out Code Solid Code Less Opaque 3 triangles IA VS Raster PS OM VB Tex Depth Colour
26 Leaky states Now impossible to get state leakage. Every draw is completely independent and immune to code modifications in other drawing systems. Submit( House.GetDrawItem() ) Submit( Tree.GetDrawItem() )
27 State Groups Container for Pipeline States and Resource Bindings. Plain-old-data, generated by a writer object. StateGroupWriter sgw sgw.begin() sgw.bindtexture( t ) sgw.bindvertexbuffer( v ) sgw.setblend( Opaque ) sgw.setshaderprogram( s ) StateGroup* sg = sgw.end() Blend Buffer Programs Texture
28 State Group Stacks Allow different systems to contribute pipeline-states and resource bindings. StateGroup* mesh =... Input Layout Buffer Blend Programs StateGroup* material =... Raster Texture StateGroup* stack[] = {material, mesh}
29 State Overrides Stack ordering dictates priority for overrides. Placing a state-group at the front of the array causes it s values to be chosen in any state conflicts. StateGroup* mesh =... Input Layout Buffer Blend Programs StateGroup* material =... StateGroup* override =... Blend Raster Texture StateGroup* stack[] = {override, material, mesh}
30 State Overrides Stack ordering dictates priority for overrides. Placing a state-group at the front of the array causes it s values to be chosen in any state conflicts. override Blend material Blend Programs mesh Input Layout Buffer Raster Texture StateGroup* stack[] = {override, material, mesh}
31 State Defaults Stack ordering dictates priority for overrides. Placing a state-group at the back of the array causes it s values to only be chosen as a fall-back. StateGroup* mesh =... StateGroup* material =... StateGroup* defaults =... StateGroup* stack[] = {material, mesh, defaults}
32 State Defaults Stack ordering dictates priority for overrides. Placing a state-group at the back of the array causes it s values to only be chosen as a fall-back. material mesh defaults Blend Programs Input Layout Buffer Input Layout Blend Raster Raster Texture Depth / Stencil Programs StateGroup* stack[] = {material, mesh, defaults}
33 Compiling a Draw Item Given a stack and a draw command, they can be pre-compiled into a draw item. override material mesh defaults Blend Blend Programs Input Layout Buffer Input Layout Blend Raster Raster Texture Depth / Stencil Programs StateGroup* stack[] = {override, material, mesh, defaults} DrawCommand command = { 3, TRIANGLES } DrawItem* draw = Compile( stack, command ) Draw Command
34 Compiling a Draw Item Given a stack and a draw command, they can be pre-compiled into a draw item. draw override Blend Draw Command Input material Layout Blend Input Assembler Raster Buffer Programs Vertex Texture Shader Programs mesh Raster Input Buffer Layout Rasterizer Stream Out StateGroup* stack[] = {override, material, mesh, defaults} Texture DrawCommand command = { 3, TRIANGLES } DrawItem* draw = Compile( stack, command ) Pixel Shader Depth / defaults Stencil Input Blend Layout Raster Depth Output / Merger Programs Stencil Draw Command Blend??????
35 Render Passes Draw Items defined all of the pipeline state except for the Depth/Stencil Target and Render Targets. Render Passes define these destination resources, plus the default and override state groups. RenderPass* pass = CreatePass( depth, color, defaults, override ) StateGroup* stack[] = {override, material, material, mesh } mesh, defaults} DrawCommand command = { 3, TRIANGLES } DrawItem* draw = Compile( stack, command, ) pass ) DrawItem* draws[] = { draw } Submit( pass, draws )
36 Resource Bindings
37 Resource ID s (and state ID s) Similar to GL, we use small integer types to refer to resource allocations & views. No reference counting a higher level of the engine can wrap reference counting around this simple integer handle scheme if necessary (a la std::shared_ptr). Helps decouple platform-specific types from the client code. This can be a significant memory saving per compiled Draw Item Pointers are 64 bits! Most resource IDs should fit in <16 bits Some kinds of state IDs might fit in <8 bits! (how many blend modes do you really use?)
38 Resource slots Most resource binding points are arrays Conflicts are resolved per individual array elements override material Sampler 1 Sampler 2 Blend Programs Sampler 0 Sampler 1 StateGroup* stack[] = {override, material}
39 Resource slots Resource slots aren t named, only numbered? Sampler 0, Sampler 1, Sampler 2 Constant Buffer 0, Constant Buffer 1, Constant Buffer2 Using this assumption at this level of the engine greatly simplifies development. Our shader programs struct can use a sampler bitmask of 0x05 to indicate that it uses sampler slot #0 and slot #2 (i.e. ((1<<0) (1<<2)) == 0x5) The State Group conflict / merging system is built on super simple integer comparisons.
40 Resource slots Using numbered slots requires defining convention. Constant Buffer 0 is always used for the per-camera matrix data. Constant Buffer 1 is always used for lighting data etc. This is actually quite useful for magic engine-generated data, which always conforms to a known (hard-coded) structure. such as camera matrices, which you want to automatically plug into every object. These are also a good use for the defaults/overrides state groups!
41 Resource slots Using named resources requires reflection. To bind data to a named slot, simply use the shader reflection system. Check with the object s shader to discover the number that s associated with that name. This is useful for less rigidly defined structures, such as materials, which may change often during development and vary from object to object.
42 Input Assembler (D3D11) Binding slots: Input Layout (Formats, strides for each element) Input Assembler Index buffer (Buffer + offset) API states: Input Layout Programs Raster Rasterizer Depth / Stencil Blend Vertex buffer(s) Draw Command Resource bindings: Input Assembler Buffer Vertex Shader Stream Out Buffer Pixel Shader Depth Texture Output Merger Colour Texture (Buffer + offset) Buffer / Texture / Sampler
43 Input Layouts and Vertex Shaders Input layouts tell the VS where to find the vertex attributes. Stream #0 data: Stream #1 data: Position 1 Position 2 Position 3 TexCoord 1 Normal 1 TexCoord 2 Normal 2 TexCoord3 Normal 3 Offset: Stride: struct VS_Input_Full { float3 p : Position; float2 t : TexCoord; float3 n : Normal } struct VS_Input_Thin { float3 p : Position; }
44 Input Layouts and Vertex Shaders Lua config files define stream formats (memory layouts for buffers) and vertex formats (VS input structures). StreamFormat("example_stream", { [VertexStream(0)] = { { Float32, 3, Position }, }, [VertexStream(1)] = { { Float32, 3, Normal }, { Float32, 2, TexCoord, 0 }, }, }) VertexFormat("VS_Input_Full", { { "p", float3, Position }, { "t", float2, TexCoord, 0 }, { "n", float3, Normal }, }) InputLayout( "example_stream", "VS_Input_Full" ) InputLayout( "example_stream", "VS_Input_Thin" ) InputLayout( "simple_stream", "VS_Input_Thin" )
45 Input Assembler (Simplified) Binding slots: Vertex Data Index buffer (Buffer ID + offset) Vertex buffer(s) (Buffer ID + offset) Input Assembler Stream Format Input Layout (now hidden from the user) Instance Data Vertex buffer(s) (Buffer ID + offset)
46 Shader Resources (D3D11) Binding slots: Constant Buffer View(s) Buffer Pixel Shader Shader Resource View(s) Buffer Texture Draw Command API states: Input Layout Input Assembler Vertex Shader Programs Raster Rasterizer Stream Out repeat for other shader stages Pixel Shader Depth / Stencil Output Merger Blend Sampler(s) Unordered Access view(s) Buffer Texture Resource bindings: Buffer Buffer Depth Texture Colour Texture Buffer / Texture / Sampler
47 Resource Lists D3D11 allows for 128 texture slots per shader stage. Can we still allow the user to access a hundred textures without the overhead of managing a hundred binding points? How did APIs already solve this for constants / uniforms? Resource lists are constant buffers (UBOs) for texture bindings. Similar to bindless resources. Ports well to Mantle/Vulkan/D3D12 descriptor lists! Only a small number of resource list binding points required. Resource List Diffuse Map ID Normal Map ID Specular Map ID
48 Shader Resources (simplified) Binding slots: Constant Buffer ID(s) Resource List ID(s) Buffer ID / Texture ID Shader Stages (all) Sampler ID(s) Unordered Access view(s) (Buffer ID / Texture ID)
49 Draw Item Resources Final size of each draw item is usually <1 cache line Resource List Buffer ID / Texture ID bytes Draw Item Constant Buffer ID(s) Resource List ID(s) Sampler ID(s) Unordered Access view(s) (Buffer ID / Texture ID) Raster ID Depth / Stencil Blend ID Program ID Input Assembler Config ID Draw Command bytes Input Assembler Config Vertex Data Instance Data bytes
50 State Group Resources Final look at actual State Group members (all optional) State Group Constant Buffer ID(s) Resource List ID(s) Sampler ID(s) Unordered Access view(s) (Buffer ID / Texture ID) Raster ID Depth / Stencil Blend ID Vertex Data Instance Data Technique ID Shader Options Draw Item Program ID
51 Shaders
52 Program management Out of the box, shaders are hard to manage. One program = Pixel Shader + Vertex Shader (+Geometry + Tessellation ) Most objects/materials require more than one program. Deferred rendering write GBuffer attributes. Forward rendering compute all shading and lighting. Shadow mapping write depth only. Material LOD enable disable features (e.g. normal mapping at a distance). Loop unrolling compile the shader once for each value of N. All of these programs grouped together form a single Technique.
53 Techniques, Passes, Options, Permutations A technique is a single shader file (Effect in MS lingo) Each technique contains several passes Gbuffer, Forward, Depth-Only, etc Each pass can contain several options Normal Mapping (y/n), Number of lights [0..8), etc For each technique, for each pass, for each permutation of options, precompile the shader source file into a program Careful each 1-bit option doubles the number of programs!
54 [FX] syntax All the APIs we use (except mobile/mac/linx) use a shader language that is close enough to HLSL that we can just write all our shader code in HLSL! A header file full of #defines is enough to smooth over the small differences in syntax. However, resource declaration syntax varies widely. Not all platforms support constant buffers (We support prev-gen / D3D9 / GL2 era). Not all platforms support Resource Lists. Not all platforms support separate Textures and Samplers
55 [FX] syntax Small amount of code generation used to smooth over these issues. We search for comment blocks of the pattern /*[FX] */ and execute their contents as Lua code. The Lua VM has been pre-registered with functions such as below, to create a domain-specific-language for declaring shader resources and techniques/passes/options: CBuffer( slot, stages, name, values ) TextureList( slot, stages, name, values ) Option( name, range ) Pass( slot, name, parameters )
56 [FX] Examples CBuffer( 0, Pixel, 'Material', { { g_emissive = float }, }) TextureList( 0, Pixel, 'Material', { { Tex2D, 's_diffuse', 'Linear' }, }) Sampler(0, {Pixel,Vertex}, 'Linear', { MinFilter = Linear, MagFilter = Linear, MipFilter = Linear, AddressU = Wrap, AddressV = Wrap, AddressW = Wrap, })
57 [FX] Examples Pass( 0, 'Opaque', { vertexshader = 'vs_main'; pixelshader = 'ps_main'; vertexlayout = { 'VS_Input_Full' }; pixeloptions = LightCount'; })
58 Shader Options Shader options are all packed together into a bitmask. Option( 'NormalMapped' ) -- pick a bit for me (use reflection!) Option( 'NormalMapped', {id=3} ) -- mask == 0x8 (i.e. 1<<3) Option( 'LightCount', {id=4, min=1, max=4} ) x00 / == LightCount: 1 0x10 / == LightCount: 2 0x20 / == LightCount: 3 0x30 / == LightCount: 4
59 Shader Options Given a pass with: Option( 'NormalMapped', {id=0} ) Option( 'LightCount', {id=4, min=1, max=4} ) The permutations would be: x00 / == NormalMapped: 0, LightCount: 1 0x01 / == NormalMapped: 1, LightCount: 1 0x10 / == NormalMapped: 0, LightCount: 2 0x11 / == NormalMapped: 1, LightCount: 2 0x20 / == NormalMapped: 0, LightCount: 3 0x21 / == NormalMapped: 1, LightCount: 3 0x30 / == NormalMapped: 0, LightCount: 4 0x31 / == NormalMapped: 1, LightCount: 4
60 Program selection I lied earlier I said that a Render Pass has just a depth-texture, rendertarget(s), defaults state group and overrides state group. A Render Pass also specifies a shader pass integer. Look up the technique, then look up the right pass within the technique and then you ve got a potentially long list of permutations State Group Technique Shader ID Options Render Pass Pass ID Draw Item Program ID Step 1 Step 2 Profit!
61 Shader Options - runtime Conflict/merging of shader options state is implemented a little differently. State Group State Group Shader Options Technique ID U32 value U32 mask value = 0x04 mask = 0x0F State Group Merged Options = 0x84 Render Pass Pass ID value = 0x80 mask = 0xF0
62 Permutation selection When compiling your permutations, sort them by CountBitsSet(options_bitmask) such that permutations with more options bits set appear earlier in the array. At runtime, the user creates their own bitmask of requested features. Linearly search through the permutations list, stop when: (requested_options & permutation_options) == permutation_options i.e. stop as soon as you re not delivering options that weren t asked for. You won t necessarily be able to satisfy the user s request exactly, but this algorithm will give them the program that enables as many of their requests as possible.
63 Permutation Selection (code) int SelectProgramsIndex( u32 techniqueid, u32 passid, u32 featuresrequested ) { Technique& technique = techniques[techniqueid]; List<Pass>& passes = technique.passes; Pass& pass = passes[passid]; List<Permutation>& permutations = pass.permutations; for( int i = 0, end = permutations.count; i!= end; ++i ) { Permutation& permutation = permutations[i]; if( (featuresrequested & permutation.features) == permutation.features ) return permutation.bindingidx; } return -1; }
64
65
66 Bonus slides That I was going to write but then I didn t
67 GLSL notes GL + GLSL are just specifications vendors create implementations (which are all broken) Validate your shaders using the Khronos reference compiler*. Don t ship your source files. Implement a pre-processor for #include, etc. Obfuscate your shipping code if you feel the need. No guarantees that every vendor will optimize (or compile) your code properly! Implement a GLSL->AST->GLSL optimizing compiler. Or better: a HLSL->AST->GLSL optimizing compiler! Automate this! *
68 Draw sorting Write a function that hashes a compiled Draw Item. More expensive state changes should be associated with more significant bits in the output. Draw Item IA Config Constant Buffer ID(s) Raster ID Blend ID Shader & pipeline state Textures Resource List ID(s) Sampler ID(s) Unordered Access view(s) (Buffer ID / Texture ID) Depth / Stencil Program ID Input Assembler Config ID Draw Command Hash 0x Sorting key
69 Transparent Draw sorting Alpha-blended geometry must be rendered from back to front. Don t use the draw item s hash, use it s distance from the camera. Distance Depth ~*(u32*)distance 0xABCDEF12 Sorting key
70 Hybrid Draw sorting For opaque geometry to make use of Hi-Z, you want to render front-to-back. However, you also want to sort by state to reduce CPU costs. Compromise by using a hybrid Distance Coarse Depth Original Hash Merge 0xABCD1357 0x New sorting key Original Sorting key
71 Redundant state filtering Each draw item is a very compact structure, containing state IDs. XOR ing two draw items creates a bitmask that highlights any changes. Masking out sections of that bitmask and comparing them to zero lets you quickly check if a state has changed since the previous draw item.
72 Resource Management
73 Data conditioning / compilation
74 Shader compilation fun
75 Devices, contexts & command lists
76 Devices
77 Contexts
78 Multithreading on old APIs
79 Higher level layer examples
80 Scene manager
81 Materials
82 Lighting
The Application Stage. The Game Loop, Resource Management and Renderer Design
1 The Application Stage The Game Loop, Resource Management and Renderer Design Application Stage Responsibilities 2 Set up the rendering pipeline Resource Management 3D meshes Textures etc. Prepare data
More informationCould you make the XNA functions yourself?
1 Could you make the XNA functions yourself? For the second and especially the third assignment, you need to globally understand what s going on inside the graphics hardware. You will write shaders, which
More informationReal - Time Rendering. Graphics pipeline. Michal Červeňanský Juraj Starinský
Real - Time Rendering Graphics pipeline Michal Červeňanský Juraj Starinský Overview History of Graphics HW Rendering pipeline Shaders Debugging 2 History of Graphics HW First generation Second generation
More informationReal-Time Rendering (Echtzeitgraphik) Michael Wimmer
Real-Time Rendering (Echtzeitgraphik) Michael Wimmer wimmer@cg.tuwien.ac.at Walking down the graphics pipeline Application Geometry Rasterizer What for? Understanding the rendering pipeline is the key
More informationGraphics Hardware. Graphics Processing Unit (GPU) is a Subsidiary hardware. With massively multi-threaded many-core. Dedicated to 2D and 3D graphics
Why GPU? Chapter 1 Graphics Hardware Graphics Processing Unit (GPU) is a Subsidiary hardware With massively multi-threaded many-core Dedicated to 2D and 3D graphics Special purpose low functionality, high
More informationA Trip Down The (2011) Rasterization Pipeline
A Trip Down The (2011) Rasterization Pipeline Aaron Lefohn - Intel / University of Washington Mike Houston AMD / Stanford 1 This talk Overview of the real-time rendering pipeline available in ~2011 corresponding
More informationAchieving High-performance Graphics on Mobile With the Vulkan API
Achieving High-performance Graphics on Mobile With the Vulkan API Marius Bjørge Graphics Research Engineer GDC 2016 Agenda Overview Command Buffers Synchronization Memory Shaders and Pipelines Descriptor
More informationRSX Best Practices. Mark Cerny, Cerny Games David Simpson, Naughty Dog Jon Olick, Naughty Dog
RSX Best Practices Mark Cerny, Cerny Games David Simpson, Naughty Dog Jon Olick, Naughty Dog RSX Best Practices About libgcm Using the SPUs with the RSX Brief overview of GCM Replay December 7 th, 2004
More informationHow to Work on Next Gen Effects Now: Bridging DX10 and DX9. Guennadi Riguer ATI Technologies
How to Work on Next Gen Effects Now: Bridging DX10 and DX9 Guennadi Riguer ATI Technologies Overview New pipeline and new cool things Simulating some DX10 features in DX9 Experimental techniques Why This
More informationBringing AAA graphics to mobile platforms. Niklas Smedberg Senior Engine Programmer, Epic Games
Bringing AAA graphics to mobile platforms Niklas Smedberg Senior Engine Programmer, Epic Games Who Am I A.k.a. Smedis Platform team at Epic Games Unreal Engine 15 years in the industry 30 years of programming
More informationRendering Grass with Instancing in DirectX* 10
Rendering Grass with Instancing in DirectX* 10 By Anu Kalra Because of the geometric complexity, rendering realistic grass in real-time is difficult, especially on consumer graphics hardware. This article
More informationNext-Generation Graphics on Larrabee. Tim Foley Intel Corp
Next-Generation Graphics on Larrabee Tim Foley Intel Corp Motivation The killer app for GPGPU is graphics We ve seen Abstract models for parallel programming How those models map efficiently to Larrabee
More informationLab 3 Shadow Mapping. Giuseppe Maggiore
Lab 3 Shadow Giuseppe Maggiore Adding Shadows to the Scene First we need to declare a very useful helper object that will allow us to draw textures to the screen without creating a quad vertex buffer //
More informationShaders. Slide credit to Prof. Zwicker
Shaders Slide credit to Prof. Zwicker 2 Today Shader programming 3 Complete model Blinn model with several light sources i diffuse specular ambient How is this implemented on the graphics processor (GPU)?
More informationShaders (some slides taken from David M. course)
Shaders (some slides taken from David M. course) Doron Nussbaum Doron Nussbaum COMP 3501 - Shaders 1 Traditional Rendering Pipeline Traditional pipeline (older graphics cards) restricts developer to texture
More informationWorking with Metal Overview
Graphics and Games #WWDC14 Working with Metal Overview Session 603 Jeremy Sandmel GPU Software 2014 Apple Inc. All rights reserved. Redistribution or public display not permitted without written permission
More informationEECS 487: Interactive Computer Graphics
EECS 487: Interactive Computer Graphics Lecture 21: Overview of Low-level Graphics API Metal, Direct3D 12, Vulkan Console Games Why do games look and perform so much better on consoles than on PCs with
More informationDave Shreiner, ARM March 2009
4 th Annual Dave Shreiner, ARM March 2009 Copyright Khronos Group, 2009 - Page 1 Motivation - What s OpenGL ES, and what can it do for me? Overview - Lingo decoder - Overview of the OpenGL ES Pipeline
More informationEngine Development & Support Team Lead for Korea UE4 Mobile Team Lead
Jack Porter Engine Development & Support Team Lead for Korea UE4 Mobile Team Lead I ve worked on Unreal Engine development since 1998! Contributed to Unreal Tournament & Gears of War series Introduction
More informationPipeline Operations. CS 4620 Lecture Steve Marschner. Cornell CS4620 Spring 2018 Lecture 11
Pipeline Operations CS 4620 Lecture 11 1 Pipeline you are here APPLICATION COMMAND STREAM 3D transformations; shading VERTEX PROCESSING TRANSFORMED GEOMETRY conversion of primitives to pixels RASTERIZATION
More informationX. GPU Programming. Jacobs University Visualization and Computer Graphics Lab : Advanced Graphics - Chapter X 1
X. GPU Programming 320491: Advanced Graphics - Chapter X 1 X.1 GPU Architecture 320491: Advanced Graphics - Chapter X 2 GPU Graphics Processing Unit Parallelized SIMD Architecture 112 processing cores
More informationChapter Answers. Appendix A. Chapter 1. This appendix provides answers to all of the book s chapter review questions.
Appendix A Chapter Answers This appendix provides answers to all of the book s chapter review questions. Chapter 1 1. What was the original name for the first version of DirectX? B. Games SDK 2. Which
More informationShader Series Primer: Fundamentals of the Programmable Pipeline in XNA Game Studio Express
Shader Series Primer: Fundamentals of the Programmable Pipeline in XNA Game Studio Express Level: Intermediate Area: Graphics Programming Summary This document is an introduction to the series of samples,
More informationPipeline Operations. CS 4620 Lecture 14
Pipeline Operations CS 4620 Lecture 14 2014 Steve Marschner 1 Pipeline you are here APPLICATION COMMAND STREAM 3D transformations; shading VERTEX PROCESSING TRANSFORMED GEOMETRY conversion of primitives
More informationPowerVR Hardware. Architecture Overview for Developers
Public Imagination Technologies PowerVR Hardware Public. This publication contains proprietary information which is subject to change without notice and is supplied 'as is' without warranty of any kind.
More informationOpenGL ES 2.0 : Start Developing Now. Dan Ginsburg Advanced Micro Devices, Inc.
OpenGL ES 2.0 : Start Developing Now Dan Ginsburg Advanced Micro Devices, Inc. Agenda OpenGL ES 2.0 Brief Overview Tools OpenGL ES 2.0 Emulator RenderMonkey w/ OES 2.0 Support OpenGL ES 2.0 3D Engine Case
More informationReal-Time Hair Simulation and Rendering on the GPU. Louis Bavoil
Real-Time Hair Simulation and Rendering on the GPU Sarah Tariq Louis Bavoil Results 166 simulated strands 0.99 Million triangles Stationary: 64 fps Moving: 41 fps 8800GTX, 1920x1200, 8XMSAA Results 166
More informationVulkan on Mobile. Daniele Di Donato, ARM GDC 2016
Vulkan on Mobile Daniele Di Donato, ARM GDC 2016 Outline Vulkan main features Mapping Vulkan Key features to ARM CPUs Mapping Vulkan Key features to ARM Mali GPUs 4 Vulkan Good match for mobile and tiling
More informationCS4621/5621 Fall Computer Graphics Practicum Intro to OpenGL/GLSL
CS4621/5621 Fall 2015 Computer Graphics Practicum Intro to OpenGL/GLSL Professor: Kavita Bala Instructor: Nicolas Savva with slides from Balazs Kovacs, Eston Schweickart, Daniel Schroeder, Jiang Huang
More informationVulkan: Architecture positive How Vulkan maps to PowerVR GPUs Kevin sun Lead Developer Support Engineer, APAC PowerVR Graphics.
Vulkan: Architecture positive How Vulkan maps to PowerVR GPUs Kevin sun Lead Developer Support Engineer, APAC PowerVR Graphics www.imgtec.com Introduction Who am I? Kevin Sun Working at Imagination Technologies
More informationOptimizing DirectX Graphics. Richard Huddy European Developer Relations Manager
Optimizing DirectX Graphics Richard Huddy European Developer Relations Manager Some early observations Bear in mind that graphics performance problems are both commoner and rarer than you d think The most
More informationCg 2.0. Mark Kilgard
Cg 2.0 Mark Kilgard What is Cg? Cg is a GPU shading language C/C++ like language Write vertex-, geometry-, and fragmentprocessing kernels that execute on massively parallel GPUs Productivity through a
More informationDirectX Programming #4. Kang, Seongtae Computer Graphics, 2009 Spring
DirectX Programming #4 Kang, Seongtae Computer Graphics, 2009 Spring Programmable Shader For recent hardwares, vertex and pixel processing stage of the graphics pipeline is programmable Programmable Vertex
More informationLecture 25: Board Notes: Threads and GPUs
Lecture 25: Board Notes: Threads and GPUs Announcements: - Reminder: HW 7 due today - Reminder: Submit project idea via (plain text) email by 11/24 Recap: - Slide 4: Lecture 23: Introduction to Parallel
More informationMetal for OpenGL Developers
#WWDC18 Metal for OpenGL Developers Dan Omachi, Metal Ecosystem Engineer Sukanya Sudugu, GPU Software Engineer 2018 Apple Inc. All rights reserved. Redistribution or public display not permitted without
More informationIntroduction to Shaders.
Introduction to Shaders Marco Benvegnù hiforce@gmx.it www.benve.org Summer 2005 Overview Rendering pipeline Shaders concepts Shading Languages Shading Tools Effects showcase Setup of a Shader in OpenGL
More informationCS427 Multicore Architecture and Parallel Computing
CS427 Multicore Architecture and Parallel Computing Lecture 6 GPU Architecture Li Jiang 2014/10/9 1 GPU Scaling A quiet revolution and potential build-up Calculation: 936 GFLOPS vs. 102 GFLOPS Memory Bandwidth:
More informationWhiz-Bang Graphics and Media Performance for Java Platform, Micro Edition (JavaME)
Whiz-Bang Graphics and Media Performance for Java Platform, Micro Edition (JavaME) Pavel Petroshenko, Sun Microsystems, Inc. Ashmi Bhanushali, NVIDIA Corporation Jerry Evans, Sun Microsystems, Inc. Nandini
More informationLecture 9: Deferred Shading. Visual Computing Systems CMU , Fall 2013
Lecture 9: Deferred Shading Visual Computing Systems The course so far The real-time graphics pipeline abstraction Principle graphics abstractions Algorithms and modern high performance implementations
More informationUnderstanding M3G 2.0 and its Effect on Producing Exceptional 3D Java-Based Graphics. Sean Ellis Consultant Graphics Engineer ARM, Maidenhead
Understanding M3G 2.0 and its Effect on Producing Exceptional 3D Java-Based Graphics Sean Ellis Consultant Graphics Engineer ARM, Maidenhead Introduction M3G 1.x Recap ARM M3G Integration M3G 2.0 Update
More informationOUTLINE. Learn the basic design of a graphics system Introduce pipeline architecture Examine software components for a graphics system
GRAPHICS PIPELINE 1 OUTLINE Learn the basic design of a graphics system Introduce pipeline architecture Examine software components for a graphics system 2 IMAGE FORMATION REVISITED Can we mimic the synthetic
More informationCOMP371 COMPUTER GRAPHICS
COMP371 COMPUTER GRAPHICS SESSION 12 PROGRAMMABLE SHADERS Announcement Programming Assignment #2 deadline next week: Session #7 Review of project proposals 2 Lecture Overview GPU programming 3 GPU Pipeline
More informationGraphics Performance Optimisation. John Spitzer Director of European Developer Technology
Graphics Performance Optimisation John Spitzer Director of European Developer Technology Overview Understand the stages of the graphics pipeline Cherchez la bottleneck Once found, either eliminate or balance
More informationThe Rasterization Pipeline
Lecture 5: The Rasterization Pipeline (and its implementation on GPUs) Computer Graphics CMU 15-462/15-662, Fall 2015 What you know how to do (at this point in the course) y y z x (w, h) z x Position objects
More informationEvolution of GPUs Chris Seitz
Evolution of GPUs Chris Seitz Overview Concepts: Real-time rendering Hardware graphics pipeline Evolution of the PC hardware graphics pipeline: 1995-1998: Texture mapping and z-buffer 1998: Multitexturing
More informationGraphics Programming. Computer Graphics, VT 2016 Lecture 2, Chapter 2. Fredrik Nysjö Centre for Image analysis Uppsala University
Graphics Programming Computer Graphics, VT 2016 Lecture 2, Chapter 2 Fredrik Nysjö Centre for Image analysis Uppsala University Graphics programming Typically deals with How to define a 3D scene with a
More informationModule 13C: Using The 3D Graphics APIs OpenGL ES
Module 13C: Using The 3D Graphics APIs OpenGL ES BREW TM Developer Training Module Objectives See the steps involved in 3D rendering View the 3D graphics capabilities 2 1 3D Overview The 3D graphics library
More informationReal - Time Rendering. Pipeline optimization. Michal Červeňanský Juraj Starinský
Real - Time Rendering Pipeline optimization Michal Červeňanský Juraj Starinský Motivation Resolution 1600x1200, at 60 fps Hw power not enough Acceleration is still necessary 3.3.2010 2 Overview Application
More informationProgrammable GPUs. Real Time Graphics 11/13/2013. Nalu 2004 (NVIDIA Corporation) GeForce 6. Virtua Fighter 1995 (SEGA Corporation) NV1
Programmable GPUs Real Time Graphics Virtua Fighter 1995 (SEGA Corporation) NV1 Dead or Alive 3 2001 (Tecmo Corporation) Xbox (NV2A) Nalu 2004 (NVIDIA Corporation) GeForce 6 Human Head 2006 (NVIDIA Corporation)
More informationContent. Building Geometry Appearance Lights Model Loaders
Content Building Geometry Appearance Lights Model Loaders Building Geometry A Geometry represents a 3D object: Mesh: The form or structure of a shape (What to draw) Material: The color, transparency, and
More informationMention driver developers in the room. Because of time this will be fairly high level, feel free to come talk to us afterwards
1 Introduce Mark, Michael Poll: Who is a software developer or works for a software company? Who s in management? Who knows what the OpenGL ARB standards body is? Mention driver developers in the room.
More informationPowerVR Series5. Architecture Guide for Developers
Public Imagination Technologies PowerVR Series5 Public. This publication contains proprietary information which is subject to change without notice and is supplied 'as is' without warranty of any kind.
More informationSqueezing Performance out of your Game with ATI Developer Performance Tools and Optimization Techniques
Squeezing Performance out of your Game with ATI Developer Performance Tools and Optimization Techniques Jonathan Zarge, Team Lead Performance Tools Richard Huddy, European Developer Relations Manager ATI
More informationOptimisation. CS7GV3 Real-time Rendering
Optimisation CS7GV3 Real-time Rendering Introduction Talk about lower-level optimization Higher-level optimization is better algorithms Example: not using a spatial data structure vs. using one After that
More informationGDC 2014 Barthold Lichtenbelt OpenGL ARB chair
GDC 2014 Barthold Lichtenbelt OpenGL ARB chair Agenda OpenGL 4.4, news and updates - Barthold Lichtenbelt, NVIDIA Low Overhead Rendering with OpenGL - Cass Everitt, NVIDIA Copyright Khronos Group, 2010
More informationOptimizing and Profiling Unity Games for Mobile Platforms. Angelo Theodorou Senior Software Engineer, MPG Gamelab 2014, 25 th -27 th June
Optimizing and Profiling Unity Games for Mobile Platforms Angelo Theodorou Senior Software Engineer, MPG Gamelab 2014, 25 th -27 th June 1 Agenda Introduction ARM and the presenter Preliminary knowledge
More informationPROFESSIONAL. WebGL Programming DEVELOPING 3D GRAPHICS FOR THE WEB. Andreas Anyuru WILEY. John Wiley & Sons, Ltd.
PROFESSIONAL WebGL Programming DEVELOPING 3D GRAPHICS FOR THE WEB Andreas Anyuru WILEY John Wiley & Sons, Ltd. INTRODUCTION xxl CHAPTER 1: INTRODUCING WEBGL 1 The Basics of WebGL 1 So Why Is WebGL So Great?
More informationIntroduction to the Direct3D 11 Graphics Pipeline
Introduction to the Direct3D 11 Graphics Pipeline Kevin Gee - XNA Developer Connection Microsoft Corporation 2008 NVIDIA Corporation. Direct3D 11 focuses on Key Takeaways Increasing scalability, Improving
More informationSpring 2011 Prof. Hyesoon Kim
Spring 2011 Prof. Hyesoon Kim Application Geometry Rasterizer CPU Each stage cane be also pipelined The slowest of the pipeline stage determines the rendering speed. Frames per second (fps) Executes on
More informationMany rendering scenarios, such as battle scenes or urban environments, require rendering of large numbers of autonomous characters.
1 2 Many rendering scenarios, such as battle scenes or urban environments, require rendering of large numbers of autonomous characters. Crowd rendering in large environments presents a number of challenges,
More informationIntroduction. What s New in This Edition
Introduction Welcome to the fourth edition of the OpenGL SuperBible. For more than ten years, we have striven to provide the world s best introduction to not only OpenGL, but 3D graphics programming in
More informationProgramming Graphics Hardware
Tutorial 5 Programming Graphics Hardware Randy Fernando, Mark Harris, Matthias Wloka, Cyril Zeller Overview of the Tutorial: Morning 8:30 9:30 10:15 10:45 Introduction to the Hardware Graphics Pipeline
More informationOpenGL Status - November 2013 G-Truc Creation
OpenGL Status - November 2013 G-Truc Creation Vendor NVIDIA AMD Intel Windows Apple Release date 02/10/2013 08/11/2013 30/08/2013 22/10/2013 Drivers version 331.10 beta 13.11 beta 9.2 10.18.10.3325 MacOS
More informationCraig Peeper Software Architect Windows Graphics & Gaming Technologies Microsoft Corporation
Gaming Technologies Craig Peeper Software Architect Windows Graphics & Gaming Technologies Microsoft Corporation Overview Games Yesterday & Today Game Components PC Platform & WGF 2.0 Game Trends Big Challenges
More informationCS GPU and GPGPU Programming Lecture 2: Introduction; GPU Architecture 1. Markus Hadwiger, KAUST
CS 380 - GPU and GPGPU Programming Lecture 2: Introduction; GPU Architecture 1 Markus Hadwiger, KAUST Reading Assignment #2 (until Feb. 17) Read (required): GLSL book, chapter 4 (The OpenGL Programmable
More informationPorting Roblox to Vulkan. Arseny
Porting Roblox to Vulkan Arseny Kapoulkine @zeuxcg 1 What is Roblox? Online multiplayer game creation platform All content is user generated Windows, macos, ios, Android, Xbox One 50M+ MAU, 1.5M+ CCU 2
More informationWhy modern versions of OpenGL should be used Some useful API commands and extensions
Michał Radziszewski Why modern versions of OpenGL should be used Some useful API commands and extensions Timer Query EXT Direct State Access (DSA) Geometry Programs Position in pipeline Rendering wireframe
More informationProgramming shaders & GPUs Christian Miller CS Fall 2011
Programming shaders & GPUs Christian Miller CS 354 - Fall 2011 Fixed-function vs. programmable Up until 2001, graphics cards implemented the whole pipeline for you Fixed functionality but configurable
More informationMAXIS-mizing Darkspore*: A Case Study of Graphic Analysis and Optimizations in Maxis Deferred Renderer
MAXIS-mizing Darkspore*: A Case Study of Graphic Analysis and Optimizations in Maxis Deferred Renderer A New Gaming Experience Made Possible With Processor Graphics Released in early 2011, the 2nd Generation
More informationlast time put back pipeline figure today will be very codey OpenGL API library of routines to control graphics calls to compile and load shaders
last time put back pipeline figure today will be very codey OpenGL API library of routines to control graphics calls to compile and load shaders calls to load vertex data to vertex buffers calls to load
More informationCanonical Shaders for Optimal Performance. Sébastien Dominé Manager of Developer Technology Tools
Canonical Shaders for Optimal Performance Sébastien Dominé Manager of Developer Technology Tools Agenda Introduction FX Composer 1.0 High Performance Shaders Basics Vertex versus Pixel Talk to your compiler
More informationGPU Memory Model. Adapted from:
GPU Memory Model Adapted from: Aaron Lefohn University of California, Davis With updates from slides by Suresh Venkatasubramanian, University of Pennsylvania Updates performed by Gary J. Katz, University
More informationIntroduction to SPIR-V Shaders
Copyright Khronos Group 2016 - Page 38 Introduction to SPIR-V Shaders Neil Hickey Compiler Engineer, ARM SPIR History Copyright Khronos Group 2016 - Page 39 Copyright Khronos Group 2016 - Page 40 SPIR-V
More informationLecture 2. Shaders, GLSL and GPGPU
Lecture 2 Shaders, GLSL and GPGPU Is it interesting to do GPU computing with graphics APIs today? Lecture overview Why care about shaders for computing? Shaders for graphics GLSL Computing with shaders
More information12.2 Programmable Graphics Hardware
Fall 2018 CSCI 420: Computer Graphics 12.2 Programmable Graphics Hardware Kyle Morgenroth http://cs420.hao-li.com 1 Introduction Recent major advance in real time graphics is the programmable pipeline:
More informationSpring 2009 Prof. Hyesoon Kim
Spring 2009 Prof. Hyesoon Kim Application Geometry Rasterizer CPU Each stage cane be also pipelined The slowest of the pipeline stage determines the rendering speed. Frames per second (fps) Executes on
More informationCourse Recap + 3D Graphics on Mobile GPUs
Lecture 18: Course Recap + 3D Graphics on Mobile GPUs Interactive Computer Graphics Q. What is a big concern in mobile computing? A. Power Two reasons to save power Run at higher performance for a fixed
More informationOptimizing for DirectX Graphics. Richard Huddy European Developer Relations Manager
Optimizing for DirectX Graphics Richard Huddy European Developer Relations Manager Also on today from ATI... Start & End Time: 12:00pm 1:00pm Title: Precomputed Radiance Transfer and Spherical Harmonic
More informationOptimal Shaders Using High-Level Languages
Optimal Shaders Using High-Level Languages The Good, The Bad, The Ugly All high level languages provide significant power and flexibility that: Make writing shaders easy Make writing slow shaders easy
More informationBuilding scalable 3D applications. Ville Miettinen Hybrid Graphics
Building scalable 3D applications Ville Miettinen Hybrid Graphics What s going to happen... (1/2) Mass market: 3D apps will become a huge success on low-end and mid-tier cell phones Retro-gaming New game
More informationShader Programming and Graphics Hardware
Shader Programming and Graphics Hardware Marries van de Hoef Graphics 2012/2013, 4 th quarter 1 Practicals The first assignment was about the basics What is going on behind the XNA functions? The second
More informationShaders in Eve Online Páll Ragnar Pálsson
Shaders in Eve Online Páll Ragnar Pálsson EVE Online Eve Online Trinity First released 2003 Proprietary graphics engine DirectX 9 (DX11 on its way) Shader Model 3 (4 & 5 in development) HLSL Turning this
More informationParallelizing Graphics Pipeline Execution (+ Basics of Characterizing a Rendering Workload)
Lecture 2: Parallelizing Graphics Pipeline Execution (+ Basics of Characterizing a Rendering Workload) Visual Computing Systems Today Finishing up from last time Brief discussion of graphics workload metrics
More informationGrafica Computazionale: Lezione 30. Grafica Computazionale. Hiding complexity... ;) Introduction to OpenGL. lezione30 Introduction to OpenGL
Grafica Computazionale: Lezione 30 Grafica Computazionale lezione30 Introduction to OpenGL Informatica e Automazione, "Roma Tre" May 20, 2010 OpenGL Shading Language Introduction to OpenGL OpenGL (Open
More informationLecture 13: OpenGL Shading Language (GLSL)
Lecture 13: OpenGL Shading Language (GLSL) COMP 175: Computer Graphics April 18, 2018 1/56 Motivation } Last week, we discussed the many of the new tricks in Graphics require low-level access to the Graphics
More informationTechnical Report. Mesh Instancing
Technical Report Mesh Instancing Abstract What is Mesh Instancing? Before we talk about instancing, let s briefly talk about the way that most D3D applications work. In order to draw a polygonal object
More informationPOWERVR MBX. Technology Overview
POWERVR MBX Technology Overview Copyright 2009, Imagination Technologies Ltd. All Rights Reserved. This publication contains proprietary information which is subject to change without notice and is supplied
More informationPowerVR Performance Recommendations. The Golden Rules
PowerVR Performance Recommendations Public. This publication contains proprietary information which is subject to change without notice and is supplied 'as is' without warranty of any kind. Redistribution
More informationDEVELOPER DAY. Vulkan Subgroup Explained Daniel Koch NVIDIA MONTRÉAL APRIL Copyright Khronos Group Page 1
DEVELOPER DAY Vulkan Subgroup Explained Daniel Koch (@booner_k), NVIDIA MONTRÉAL APRIL 2018 Copyright Khronos Group 2018 - Page 1 Copyright Khronos Group 2018 - Page 2 Agenda Motivation Subgroup overview
More informationDirectX 11 First Elements
DirectX 11 First Elements 0. Project changes changed Dx11Base.h void Update( float dt ); void Render( ); to virtual void Update( float dt ) = 0; virtual void Render( ) = 0; new App3D.h #ifndef _APP_3D_H_
More informationApplications of Explicit Early-Z Z Culling. Jason Mitchell ATI Research
Applications of Explicit Early-Z Z Culling Jason Mitchell ATI Research Outline Architecture Hardware depth culling Applications Volume Ray Casting Skin Shading Fluid Flow Deferred Shading Early-Z In past
More informationRendering Objects. Need to transform all geometry then
Intro to OpenGL Rendering Objects Object has internal geometry (Model) Object relative to other objects (World) Object relative to camera (View) Object relative to screen (Projection) Need to transform
More informationVulkan API 杨瑜, 资深工程师
Vulkan API 杨瑜, 资深工程师 Vulkan Overview (1/3) Some History ~2011 became apparent that the API is getting in the way - Console Developers programmed GPUs To-the-Metal 2012 Khronos started work on GLCommon
More informationWebGL and GLSL Basics. CS559 Fall 2015 Lecture 10 October 6, 2015
WebGL and GLSL Basics CS559 Fall 2015 Lecture 10 October 6, 2015 Last time Hardware Rasterization For each point: Compute barycentric coords Decide if in or out.7,.7, -.4 1.1, 0, -.1.9,.05,.05.33,.33,.33
More informationBeginning Direct3D Game Programming: 1. The History of Direct3D Graphics
Beginning Direct3D Game Programming: 1. The History of Direct3D Graphics jintaeks@gmail.com Division of Digital Contents, DongSeo University. April 2016 Long time ago Before Windows, DOS was the most popular
More informationC P S C 314 S H A D E R S, O P E N G L, & J S RENDERING PIPELINE. Mikhail Bessmeltsev
C P S C 314 S H A D E R S, O P E N G L, & J S RENDERING PIPELINE UGRAD.CS.UBC.C A/~CS314 Mikhail Bessmeltsev 1 WHAT IS RENDERING? Generating image from a 3D scene 2 WHAT IS RENDERING? Generating image
More information2: Introducing image synthesis. Some orientation how did we get here? Graphics system architecture Overview of OpenGL / GLU / GLUT
COMP27112 Computer Graphics and Image Processing 2: Introducing image synthesis Toby.Howard@manchester.ac.uk 1 Introduction In these notes we ll cover: Some orientation how did we get here? Graphics system
More informationCS 4620 Program 3: Pipeline
CS 4620 Program 3: Pipeline out: Wednesday 14 October 2009 due: Friday 30 October 2009 1 Introduction In this assignment, you will implement several types of shading in a simple software graphics pipeline.
More informationDominic Filion, Senior Engineer Blizzard Entertainment. Rob McNaughton, Lead Technical Artist Blizzard Entertainment
Dominic Filion, Senior Engineer Blizzard Entertainment Rob McNaughton, Lead Technical Artist Blizzard Entertainment Screen-space techniques Deferred rendering Screen-space ambient occlusion Depth of Field
More informationShader Programming CgFX, OpenGL 2.0. Michael Haller 2003
Shader Programming CgFX, OpenGL 2.0 Michael Haller 2003 Outline What is CgFX? CgFX runtime Production pipeline with CgFX CgFX Tools set OpenGL 2.0 What is CgFX? CgFX (C for Graphics Effekt File) Supports
More information