HW-Tessellation Basics
|
|
- Virgil Paul
- 5 years ago
- Views:
Transcription
1 HW-Tessellation Basics Peter Houska Institute of Computer Graphics and Algorithms Vienna University of Technology
2 Tessellation Video [UnHe] Institute of Computer Graphics and Algorithms 1
3 What is Tessellation? Refers to subdivision of geometry Geometry shader could do that already OpenCL etc. could be used for subdiv, too Nowadays prefer tessellation shader(s) better performance! subdivision itself is taken care of automatically just supply subdivision factors Institute of Computer Graphics and Algorithms 2
4 Why Tessellation? Ever increasing polygon counts Application needs to: store data transmit data between RAM & VRAM Possible bottleneck! better to refine mesh entirely on GPU Example: Skinned animation transmit & animate coarse mesh only refine mesh entirely on the GPU Institute of Computer Graphics and Algorithms 3
5 Typical Usage of Tessellation (True) Displacement mapping not just modification of lighting ( bump mapping, etc.) changes objects silhouette Institute of Computer Graphics and Algorithms 4
6 Example: Displacement Mapping [UnHe] Institute of Computer Graphics and Algorithms 5
7 Typical Usage of Tessellation cont'd Dynamic & Continuous Level Of Detail e.g. subdivide based on screen space error Algebraic Surfaces only send control points to GPU, evaluate surface on the fly [OglDev] Institute of Computer Graphics and Algorithms 6
8 New Shader Stages in the Pipeline Input Assembler Vertex Shader Tessellation Control Shader Primitive Generator Tessellation Evaluation Shader Geometry Shader Rasterizer Fragment Shader Output Merger Input Assembler Vertex Shader Hull Shader Tessellator Domain Shader Geometry Shader Rasterizer Pixel Shader Output Merger Institute of Computer Graphics and Algorithms 7
9 Tessellation Dataflow input patch = group of CPs may add/delete CPs Tessellation Control Shader TLs barycentric coordinates + connectivity Primitive Generator (PG) output patch 1:1 (no add/delete) Tessellation Evaluation Shader vertex for each barycentric coord from PG CPs... control points (=collection of vertices with attributes) TLs... tessellation levels Institute of Computer Graphics and Algorithms 8
10 Tessellation Dataflow - TCS input patch = group of CPs may add/delete CPs Tessellation Control Shader TLs barycentric coordinates + connectivity Primitive Generator (PG) output patch 1:1 (no add/delete) Tessellation Evaluation Shader vertex for each barycentric coord from PG CPs... control points (=collection of vertices with attributes) TLs... tessellation levels Institute of Computer Graphics and Algorithms 9
11 Tessellation Control Shader (TCS) Reads an input patch consists of "any" number of vertices Emits an output patch is run once for each vertex in output patch computes attributes of that vertex Most important per-patch outputs are tessellation levels (TLs) TLs control the number of subdivisions performed by the primitive generator Institute of Computer Graphics and Algorithms 10
12 Tessellation Control Shader (TCS) Per-vertex output variables are declared as arrays indexed by vertex number May write only to outputs corresponding to its output patch vertex given by special variable gl_invocationid Institute of Computer Graphics and Algorithms 11
13 Tessellation Control Shader (TCS) May declare per-patch output variables use qualifier patch out Per-patch outputs do not correspond to any specific vertex in the patch are not indexed by vertex number. User-defined per-patch outputs are not used by the primitive generator but may be read by tessellation evaluation shaders. Institute of Computer Graphics and Algorithms 12
14 Tessellation Dataflow - PG input patch = group of CPs may add/delete CPs Tessellation Control Shader TLs barycentric coordinates + connectivity Primitive Generator (PG) output patch 1:1 (no add/delete) Tessellation Evaluation Shader vertex for each barycentric coord from PG CPs... control points (=collection of vertices with attributes) TLs... tessellation levels Institute of Computer Graphics and Algorithms 13
15 Primitive Generator (PG) Subdivides triangle or quad primitive based on tessellation levels of the patch the set of layout declarations specified in tessellation evaluation shader yields collection of points, lines, or triangles Institute of Computer Graphics and Algorithms 14
16 Primitive Generator (PG) The type of subdivision performed is specified by an input layout declaration in the tessellation evaluation shader Possible domain parameterizations triangles quads isolines Strictly speaking only subdivides domain, not the input primitive Institute of Computer Graphics and Algorithms 15
17 Primitive Generator (PG) Domain parameterization for tessellation generator primitive modes IL 0-1 inner tessellation levels OL 0-3 outer tessellation levels [OglSpec] Institute of Computer Graphics and Algorithms 16
18 Primitive Generator (PG) Generated vertices have associated (u,v,w) or (u,v) position in a normalized parameter space Parameter values in the range [0; 1] For triangles: vertex position is barycentric coordinate (u,v,w) (u + v + w) = 1 Institute of Computer Graphics and Algorithms 17
19 Primitive Generator (PG) Input layout declaration in the tessellation evaluation shader controls number and spacing of segments equal_spacing fractional_even_spacing fractional_odd_spacing Institute of Computer Graphics and Algorithms 18
20 Tessellation Factors [LGGh] Institute of Computer Graphics and Algorithms 19
21 Subdivision Step-by-Step (1/6) Start with equilateral triangle 3 outer TLs, 1 inner TL given Ignore the 3 outer TLs for now Temporarily subdivide outer edges by inner TL n we get n segments and (n+1) vertices on each edge inner TL=4 inner TL=5 Institute of Computer Graphics and Algorithms 20
22 Subdivision Step-by-Step (2/6) Form the corner points of inner triangle Intersect lines which are perpendicular to edge and contain nearest subdivision points on edge Intersection points are new corner points for inner triangle inner TL=4 inner TL=5 Institute of Computer Graphics and Algorithms 21
23 Subdivision Step-by-Step (3/6) Intersect inner triangle edge with perpendicular lines through remaining ((n+1)-4) points on outer edge inner TL=4 inner TL=5 Institute of Computer Graphics and Algorithms 22
24 Subdivision Step-by-Step (4/6) Note: inner TL=4 outer triangle has n segments inner triangle has (n-2) segments outer triangle has n+1 vertices inner triangle has n-1 vertices inner TL=5 Institute of Computer Graphics and Algorithms 23
25 Subdivision Step-by-Step (5/6) Newly created inner triangle is treated as the outer triangle in the next step recursively create new inner TL= 4: Note that the innermost triangle is degenerate (a point) inner TL=4 inner TL=5 Institute of Computer Graphics and Algorithms 24
26 Subdivision Step-by-Step (6/6) Outermost edges are finally subdivided by given outer TLs Completely fill area between concentric triangles with triangles Each vertex is assigned its corresponding barycentric coordinate Institute of Computer Graphics and Algorithms 25
27 Tessellation Dataflow - TES input patch = group of CPs may add/delete CPs Tessellation Control Shader TLs barycentric coordinates + connectivity Primitive Generator (PG) output patch 1:1 (no add/delete) Tessellation Evaluation Shader vertex for each barycentric coord from PG CPs... control points (=collection of vertices with attributes) TLs... tessellation levels Institute of Computer Graphics and Algorithms 26
28 Tessellation Evaluation Shader (TES) Is run on each vertex generated by PG Has access to relative location of vertex in subdivided output primitive (u,v) or (u,v,w) coordinate all vertex attributes in input patch position, texture coordinates,... Calculates and writes final vertex position other attributes of each vertex Institute of Computer Graphics and Algorithms 27
29 Important Code in the Application Configure number of vertices in patch glpatchparameteri(gl_patch_vertices, n); Query for the maximum allowable number n GLint MaxPatchVertices; glgetintegerv(gl_max_patch_vertices, &MaxPatchVertices); Use new primitive mode GL_PATCHES for rendering, e.g.: gldrawarrays(gl_patches, first_vert, vert_cnt); gldrawelements(gl_patches, idx_buffer_len, GL_UNSIGNED_INT, 0); Just as passing 3 vertices+attributes when rendering triangles, pass n vertices for each patch Institute of Computer Graphics and Algorithms 28
30 Creating Tessellation Shaders Basically the same procedure as for VS/GS/FS, just replace constants:... glcreateshader(gl_tess_control_shader);... glcreateshader(gl_tess_evaluation_shader);... Institute of Computer Graphics and Algorithms 29
31 Example: Simple Displacement Mapping Application Render patches, each made up of 3 vertices so each patch is basically a triangle vertex attributes: position & texture coordinate VS simply passes data down to TCS TCS calculates the tessellation levels passes vertex attributes down to TES TES performs texture fetch at received texture coordinate and uses value as displacement factor FS fetches color from texture at same texture coordinate Institute of Computer Graphics and Algorithms 30
32 Vertex Shader #version 410 core // matrix that transforms from object space to world space (WS) uniform mat4 model_mat; in vec4 in_vertex; in vec2 in_tc0; // attribute 0: object space vertex position // attribute 1: texture coordinate // variables to pass down information from VS to TCS out vec2 tc0_v2tc; out vec4 WS_pos_v2tc; void main(void) { tc0_v2tc = in_tc0; WS_pos_v2tc = model_mat * in_vertex; // transform vertex to WS } Institute of Computer Graphics and Algorithms 31
33 Tessellation Control Shader (1/2) #version 410 core // define the number of CPs in the output patch layout (vertices = 3) out; uniform vec4 cam_pos_ws; // camera position in WS // attributes of the input CPs in vec2 tc0_v2tc[]; in vec4 WS_pos_v2tc[]; // attributes of the output CPs out vec2 tc0_tc2te[]; out vec4 WS_pos_tc2te[]; Institute of Computer Graphics and Algorithms 32
34 Tessellation Control Shader (2/2) void main(void) { // Set the control points of the output patch tc0_tc2te[gl_invocationid] = tc0_v2tc[gl_invocationid]; WS_pos_tc2te[gl_InvocationID] = WS_pos_v2tc[gl_InvocationID]; // the next snippet just sketches the calculations... // based on the vertex distances to the camera, we choose the TLs } // Calculate the tessellation levels see next slide for indices // actually we only need to write these once per patch, // not once per vertex [hint: check for gl_invocationid ] gl_tesslevelouter[0] = calc_tl(ws_pos_v2tc[1], WS_pos_v2tc[2]); gl_tesslevelouter[1] = calc_tl(ws_pos_v2tc[2], WS_pos_v2tc[0]); gl_tesslevelouter[2] = calc_tl(ws_pos_v2tc[0], WS_pos_v2tc[1]); gl_tesslevelinner[0] = calc_inner_tl(... ); Institute of Computer Graphics and Algorithms 33
35 Tessellation Control Shader - Indices V (vertex 1) [OglSpec] W (vertex 2) edge 1 U (vertex 0) Institute of Computer Graphics and Algorithms 34
36 Tessellation Evaluation Shader (1/2) #version 410 core // tell PG to emit triangles in counter-clockwise order // with equal spacing (try fractional_even_spacing and // fractional_odd_spacing, too!) layout(triangles, equal_spacing, ccw) in; uniform mat4 proj_mat; uniform mat4 view_mat; uniform sampler2d disp_tex; // texture for displacement values uniform float displacement_factor; // these vertex attributes are passed down from the TCS in vec2 tc0_tc2te[]; in vec4 WS_pos_tc2te[]; out vec2 tc0; // the only attribute we'll need later in the FS Institute of Computer Graphics and Algorithms 35
37 Tessellation Evaluation Shader (2/2) // Interpolate values v0-v2 based on the barycentric coordinates // of the current vertex within the triangle vec2 ipol2d(vec2 v0, vec2 v1, vec2 v2) { return vec2(gl_tesscoord.x) * v0 + vec2(gl_tesscoord.y) * v1 + vec2(gl_tesscoord.z) * v2; } void main(void) { // Interpolate attribs of output vertex using its barycentric coords vec2 tc0_tess = ipol2d(tc0_tc2te[0], tc0_tc2te[1], tc0_tc2te[2]); } vec4 WS_pos_tess = vec4( ipol3d( Institute of Computer Graphics and Algorithms 36 WS_pos_tc2te[0].xyz, WS_pos_tc2te[1].xyz, WS_pos_tc2te[2].xyz ), 1.0); tc0 = tc0_tess; // pass texture coordinate to FS // Displace the vertex along the WS z-axis float displacement = texture(disp_tex, tc0_tess).x; WS_pos_tess.z += displacement * displacement_factor; // transform to NDC gl_position = proj_mat * view_mat * WS_vertex_pos_tess;
38 Fragment Shader #version 410 core uniform sampler2d c_tex; // color texture in vec2 tc0; // passed down from the TES out vec4 out_color0; // the final fragment color void main(void) { out_color0 = texture(c_tex, tc0); } Institute of Computer Graphics and Algorithms 37
39 References [OglSpec] [UnHe] Unigine "Heaven" benchmark Some tutorials: [LGGh] prideout.net/blog/?p=48 [OglDev] ogldev.atspace.co.uk/www/tutorial30/tutorial30.html Institute of Computer Graphics and Algorithms 38
CSE 4431/ M Advanced Topics in 3D Computer Graphics. TA: Margarita Vinnikov
CSE 4431/5331.03M Advanced Topics in 3D Computer Graphics TA: Margarita Vinnikov mvinni@cse.yorku.ca The OpenGL 4.x pipeline 2 new Programmable stages Tessellation Control Shader(GL_TESS_CONTROL_SHADER)
More informationOUTLINE. Tessellation in OpenGL Tessellation of Bezier Surfaces Tessellation for Terrain/Height Maps Level of Detail
TESSELLATION 1 OUTLINE Tessellation in OpenGL Tessellation of Bezier Surfaces Tessellation for Terrain/Height Maps Level of Detail 2 THE EXAMPLE TESSELLATION SHADING Instead of specifying vertices, you
More informationCS770/870 Fall 2015 Advanced GLSL
Expanded Graphics Pipeline CS770/870 Fall 2015 Advanced GLSL Geometry definition Shaders can actually be inserted in more places in pipeline Vertex and fragment shaders are most important Vertex shader
More informationHow to use tessellation to add geometric detail to your scenes. How to use geometry shaders to process whole primitives and create geometry on the fly
Chapter 8 Primitive Processing WHAT YOU LL LEARN IN THIS CHAPTER How to use tessellation to add geometric detail to your scenes How to use geometry shaders to process whole primitives and create geometry
More informationCS195V Week 3. GLSL Programming
CS195V Week 3 GLSL Programming Differences in OpenGL and GLSL 4.x A lot of changes made to GLSL 4.x spec (see: http://www. opengl.org/registry/doc/glslangspec.4.00.8.clean.pdf) CS123 used OpenGL 2.x and
More informationOPENGL RENDERING PIPELINE
CPSC 314 03 SHADERS, OPENGL, & JS UGRAD.CS.UBC.CA/~CS314 Textbook: Appendix A* (helpful, but different version of OpenGL) Alla Sheffer Sep 2016 OPENGL RENDERING PIPELINE 1 OPENGL RENDERING PIPELINE Javascript
More informationTessellation Shaders
1 Tessellation Shaders Mike Bailey mjb@cs.oregonstate.edu tessellation.pptx Why do we need a Tessellation step right in the pipeline? You can perform adaptive subdivision based on a variety of criteria
More informationA Tessellated Parametric Triangular Bézier Patch
1 CS 457/557 Winter Quarter 2017 Project #7: A Tessellated Parametric Triangular Bézier Patch Due: March 15, 2017 A Parametric Line 2 P 1 P 0 B 0 = (1 u) B 1 = u } Blending Functions A Parametric Triangular
More informationApproximate Catmull-Clark Patches. Scott Schaefer Charles Loop
Approximate Catmull-Clark Patches Scott Schaefer Charles Loop Approximate Catmull-Clark Patches Scott Schaefer Charles Loop Catmull-Clark Surface ACC-Patches Polygon Models Prevalent in game industry Very
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 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 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 informationWebGL and GLSL Basics. CS559 Fall 2016 Lecture 14 October
WebGL and GLSL Basics CS559 Fall 2016 Lecture 14 October 24 2016 Review 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 informationThe Graphics Pipeline
The Graphics Pipeline Lecture 2 Robb T. Koether Hampden-Sydney College Fri, Aug 28, 2015 Robb T. Koether (Hampden-Sydney College) The Graphics Pipeline Fri, Aug 28, 2015 1 / 19 Outline 1 Vertices 2 The
More informationEfficient GPU Rendering of Subdivision Surfaces. Tim Foley,
Efficient GPU Rendering of Subdivision Surfaces Tim Foley, 2017-03-02 Collaborators Activision Wade Brainerd Stanford Matthias Nießner NVIDIA Manuel Kraemer Henry Moreton 2 Subdivision surfaces are a powerful
More informationThe Graphics Pipeline
The Graphics Pipeline Lecture 2 Robb T. Koether Hampden-Sydney College Wed, Aug 23, 2017 Robb T. Koether (Hampden-Sydney College) The Graphics Pipeline Wed, Aug 23, 2017 1 / 19 Outline 1 Vertices 2 The
More informationCSE 167: Lecture #8: GLSL. Jürgen P. Schulze, Ph.D. University of California, San Diego Fall Quarter 2012
CSE 167: Introduction to Computer Graphics Lecture #8: GLSL Jürgen P. Schulze, Ph.D. University of California, San Diego Fall Quarter 2012 Announcements Homework project #4 due Friday, November 2 nd Introduction:
More informationDirect Rendering of Trimmed NURBS Surfaces
Direct Rendering of Trimmed NURBS Surfaces Hardware Graphics Pipeline 2/ 81 Hardware Graphics Pipeline GPU Video Memory CPU Vertex Processor Raster Unit Fragment Processor Render Target Screen Extended
More informationProgramming with OpenGL Shaders I. Adapted From: Ed Angel Professor of Emeritus of Computer Science University of New Mexico
Programming with OpenGL Shaders I Adapted From: Ed Angel Professor of Emeritus of Computer Science University of New Mexico 0 Objectives Shader Basics Simple Shaders Vertex shader Fragment shaders 1 Vertex
More informationMotivation MGB Agenda. Compression. Scalability. Scalability. Motivation. Tessellation Basics. DX11 Tessellation Pipeline
MGB 005 Agenda Motivation Tessellation Basics DX Tessellation Pipeline Instanced Tessellation Instanced Tessellation in DX0 Displacement Mapping Content Creation Compression Motivation Save memory and
More informationCiril Bohak. - INTRODUCTION TO WEBGL
2016 Ciril Bohak ciril.bohak@fri.uni-lj.si - INTRODUCTION TO WEBGL What is WebGL? WebGL (Web Graphics Library) is an implementation of OpenGL interface for cmmunication with graphical hardware, intended
More informationGeometry Shaders. And how to use them
Geometry Shaders And how to use them OpenGL Pipeline (part of it) Vertex data Vertex shader Vertices Primitives Geometry shader Primitives Fragments Fragment shader Color Depth Stencil Vertex Data Attributes
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 informationPhong Tessellation for Quads
Phong Tessellation for Quads Jonathan Dupuy 1,2 1 LIRIS, Université Lyon 1 2 LIGUM, Dept. I.R.O., Université de Montréal Figure 1: First 3 levels of Phong tessellation on a quad mesh (the leftmost surface
More informationProgramming with OpenGL Part 3: Shaders. Ed Angel Professor of Emeritus of Computer Science University of New Mexico
Programming with OpenGL Part 3: Shaders Ed Angel Professor of Emeritus of Computer Science University of New Mexico 1 Objectives Simple Shaders - Vertex shader - Fragment shaders Programming shaders with
More informationProgramming with OpenGL Shaders I. Adapted From: Ed Angel Professor of Emeritus of Computer Science University of New Mexico
Programming with OpenGL Shaders I Adapted From: Ed Angel Professor of Emeritus of Computer Science University of New Mexico Objectives Shader Programming Basics Simple Shaders Vertex shader Fragment shaders
More informationThe Graphics Pipeline
The Graphics Pipeline Ray Tracing: Why Slow? Basic ray tracing: 1 ray/pixel Ray Tracing: Why Slow? Basic ray tracing: 1 ray/pixel But you really want shadows, reflections, global illumination, antialiasing
More informationCS 4620 Midterm, October 23, 2018 SOLUTION
1. [20 points] Transformations CS 4620 Midterm, October 23, 2018 SOLUTION (a) Describe the action of each of the following matrices, as transformations in homogeneous coordinates, in terms of rotation,
More informationCS GPU and GPGPU Programming Lecture 7: Shading and Compute APIs 1. Markus Hadwiger, KAUST
CS 380 - GPU and GPGPU Programming Lecture 7: Shading and Compute APIs 1 Markus Hadwiger, KAUST Reading Assignment #4 (until Feb. 23) Read (required): Programming Massively Parallel Processors book, Chapter
More informationShader Programming 1. Examples. Vertex displacement mapping. Daniel Wesslén 1. Post-processing, animated procedural textures
Shader Programming 1 Examples Daniel Wesslén, dwn@hig.se Per-pixel lighting Texture convolution filtering Post-processing, animated procedural textures Vertex displacement mapping Daniel Wesslén 1 Fragment
More informationEDAF80 Introduction to Computer Graphics. Seminar 3. Shaders. Michael Doggett. Slides by Carl Johan Gribel,
EDAF80 Introduction to Computer Graphics Seminar 3 Shaders Michael Doggett 2017 Slides by Carl Johan Gribel, 2010-13 Today OpenGL Shader Language (GLSL) Shading theory Assignment 3: (you guessed it) writing
More informationRasterization Overview
Rendering Overview The process of generating an image given a virtual camera objects light sources Various techniques rasterization (topic of this course) raytracing (topic of the course Advanced Computer
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 informationThe 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 informationCSE 167: Introduction to Computer Graphics Lecture #13: GLSL. Jürgen P. Schulze, Ph.D. University of California, San Diego Fall Quarter 2015
CSE 167: Introduction to Computer Graphics Lecture #13: GLSL Jürgen P. Schulze, Ph.D. University of California, San Diego Fall Quarter 2015 Announcements Project 6 due Friday Next Thursday: Midterm #2
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 informationSign up for crits! Announcments
Sign up for crits! Announcments Reading for Next Week FvD 16.1-16.3 local lighting models GL 5 lighting GL 9 (skim) texture mapping Modern Game Techniques CS248 Lecture Nov 13 Andrew Adams Overview The
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 information2.11 Particle Systems
2.11 Particle Systems 320491: Advanced Graphics - Chapter 2 152 Particle Systems Lagrangian method not mesh-based set of particles to model time-dependent phenomena such as snow fire smoke 320491: Advanced
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 informationRay Casting of Trimmed NURBS Surfaces on the GPU
Ray Casting of Trimmed NURBS Surfaces on the GPU Hans-Friedrich Pabst Jan P. Springer André Schollmeyer Robert Lenhardt Christian Lessig Bernd Fröhlich Bauhaus University Weimar Faculty of Media Virtual
More informationSHADER PROGRAMMING. Based on Jian Huang s lecture on Shader Programming
SHADER PROGRAMMING Based on Jian Huang s lecture on Shader Programming What OpenGL 15 years ago could do http://www.neilturner.me.uk/shots/opengl-big.jpg What OpenGL can do now What s Changed? 15 years
More informationInput Nodes. Surface Input. Surface Input Nodal Motion Nodal Displacement Instance Generator Light Flocking
Input Nodes Surface Input Nodal Motion Nodal Displacement Instance Generator Light Flocking The different Input nodes, where they can be found, what their outputs are. Surface Input When editing a surface,
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 informationComputer Graphics (CS 543) Lecture 10: Soft Shadows (Maps and Volumes), Normal and Bump Mapping
Computer Graphics (CS 543) Lecture 10: Soft Shadows (Maps and Volumes), Normal and Bump Mapping Prof Emmanuel Agu Computer Science Dept. Worcester Polytechnic Institute (WPI) Shadow Buffer Theory Observation:
More informationGLSL Introduction. Fu-Chung Huang. Thanks for materials from many other people
GLSL Introduction Fu-Chung Huang Thanks for materials from many other people Programmable Shaders //per vertex inputs from main attribute aposition; attribute anormal; //outputs to frag. program varying
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 informationZeyang Li Carnegie Mellon University
Zeyang Li Carnegie Mellon University Recap: Texture Mapping Programmable Graphics Pipeline Bump Mapping Displacement Mapping Environment Mapping GLSL Overview Perlin Noise GPGPU Map reflectance over a
More informationTSBK03 Screen-Space Ambient Occlusion
TSBK03 Screen-Space Ambient Occlusion Joakim Gebart, Jimmy Liikala December 15, 2013 Contents 1 Abstract 1 2 History 2 2.1 Crysis method..................................... 2 3 Chosen method 2 3.1 Algorithm
More informationComputergrafik. Matthias Zwicker Universität Bern Herbst 2016
Computergrafik Matthias Zwicker Universität Bern Herbst 2016 2 Today Basic shader for texture mapping Texture coordinate assignment Antialiasing Fancy textures 3 Texture mapping Glue textures (images)
More informationCSE 167: Introduction to Computer Graphics Lecture #7: GLSL. Jürgen P. Schulze, Ph.D. University of California, San Diego Spring Quarter 2016
CSE 167: Introduction to Computer Graphics Lecture #7: GLSL Jürgen P. Schulze, Ph.D. University of California, San Diego Spring Quarter 2016 Announcements Project 2 due Friday 4/22 at 2pm Midterm #1 on
More informationLecture 4: Geometry Processing. Kayvon Fatahalian CMU : Graphics and Imaging Architectures (Fall 2011)
Lecture 4: Processing Kayvon Fatahalian CMU 15-869: Graphics and Imaging Architectures (Fall 2011) Today Key per-primitive operations (clipping, culling) Various slides credit John Owens, Kurt Akeley,
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 informationToday s Agenda. Basic design of a graphics system. Introduction to OpenGL
Today s Agenda Basic design of a graphics system Introduction to OpenGL Image Compositing Compositing one image over another is most common choice can think of each image drawn on a transparent plastic
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 informationCS 130 Final. Fall 2015
CS 130 Final Fall 2015 Name Student ID Signature You may not ask any questions during the test. If you believe that there is something wrong with a question, write down what you think the question is trying
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 informationGraphics Hardware. Instructor Stephen J. Guy
Instructor Stephen J. Guy Overview What is a GPU Evolution of GPU GPU Design Modern Features Programmability! Programming Examples Overview What is a GPU Evolution of GPU GPU Design Modern Features Programmability!
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 informationModels and Architectures
Models and Architectures Objectives Learn the basic design of a graphics system Introduce graphics pipeline architecture Examine software components for an interactive graphics system 1 Image Formation
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 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 informationGLSL Introduction. Fu-Chung Huang. Thanks for materials from many other people
GLSL Introduction Fu-Chung Huang Thanks for materials from many other people Shader Languages Currently 3 major shader languages Cg (Nvidia) HLSL (Microsoft) Derived from Cg GLSL (OpenGL) Main influences
More informationSceneKit: What s New Session 604
Graphics and Games #WWDC17 SceneKit: What s New Session 604 Thomas Goossens, SceneKit engineer Amaury Balliet, SceneKit engineer Anatole Duprat, SceneKit engineer Sébastien Métrot, SceneKit engineer 2017
More informationCS559 Computer Graphics Fall 2015
CS559 Computer Graphics Fall 2015 Practice Midterm Exam Time: 2 hrs 1. [XX Y Y % = ZZ%] MULTIPLE CHOICE SECTION. Circle or underline the correct answer (or answers). You do not need to provide a justification
More informationApproximating Subdivision Surfaces with Gregory Patches for Hardware Tessellation
Approximating Subdivision Surfaces with Gregory Patches for Hardware Tessellation Charles Loop Microsoft Research Scott Schaefer Texas A&M University Tianyun Ni NVIDIA Ignacio Castaño NVIDIA Goal Real-Time
More information2D rendering takes a photo of the 2D scene with a virtual camera that selects an axis aligned rectangle from the scene. The photograph is placed into
2D rendering takes a photo of the 2D scene with a virtual camera that selects an axis aligned rectangle from the scene. The photograph is placed into the viewport of the current application window. A pixel
More informationRendering Subdivision Surfaces Efficiently on the GPU
Rendering Subdivision Surfaces Efficiently on the GPU Gy. Antal, L. Szirmay-Kalos and L. A. Jeni Department of Algorithms and their Applications, Faculty of Informatics, Eötvös Loránd Science University,
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 informationLecture 5 Vertex and Fragment Shaders-1. CITS3003 Graphics & Animation
Lecture 5 Vertex and Fragment Shaders-1 CITS3003 Graphics & Animation E. Angel and D. Shreiner: Interactive Computer Graphics 6E Addison-Wesley 2012 Objectives The rendering pipeline and the shaders Data
More informationShader Programming. Daniel Wesslén, Stefan Seipel, Examples
Shader Programming Daniel Wesslén, dwn@hig.se Stefan Seipel, ssl@hig.se Examples 1 Per-pixel lighting Texture convolution filtering 2 Post-processing, animated procedural textures Vertex displacement mapping
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 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 informationProgrammable Graphics Hardware
Programmable Graphics Hardware Outline 2/ 49 A brief Introduction into Programmable Graphics Hardware Hardware Graphics Pipeline Shading Languages Tools GPGPU Resources Hardware Graphics Pipeline 3/ 49
More informationhttps://ilearn.marist.edu/xsl-portal/tool/d4e4fd3a-a3...
Assessment Preview - This is an example student view of this assessment done Exam 2 Part 1 of 5 - Modern Graphics Pipeline Question 1 of 27 Match each stage in the graphics pipeline with a description
More informationTutorial on GPU Programming #2. Joong-Youn Lee Supercomputing Center, KISTI
Tutorial on GPU Programming #2 Joong-Youn Lee Supercomputing Center, KISTI Contents Graphics Pipeline Vertex Programming Fragment Programming Introduction to Cg Language Graphics Pipeline The process to
More information- Rasterization. Geometry. Scan Conversion. Rasterization
Computer Graphics - The graphics pipeline - Geometry Modelview Geometry Processing Lighting Perspective Clipping Scan Conversion Texturing Fragment Tests Blending Framebuffer Fragment Processing - So far,
More informationTexture mapping. Computer Graphics CSE 167 Lecture 9
Texture mapping Computer Graphics CSE 167 Lecture 9 CSE 167: Computer Graphics Texture Mapping Overview Interpolation Wrapping Texture coordinates Anti aliasing Mipmaps Other mappings Including bump mapping
More informationLecture 9(B): GPUs & GPGPU
Lecture 9(B): GPUs & GPGPU John-Philip Taylor 26 March 2015 Attribution-ShareAlike 4.0 International (CC BY-SA 4.0) Outline OpenGL Primitives and Vertices Vertex Shader Rasteriser Fragment Shader OpenCL
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 informationCS4621/5621 Fall Basics of OpenGL/GLSL Textures Basics
CS4621/5621 Fall 2015 Basics of OpenGL/GLSL Textures Basics Professor: Kavita Bala Instructor: Nicolas Savva with slides from Balazs Kovacs, Eston Schweickart, Daniel Schroeder, Jiang Huang and Pramook
More informationInformation Coding / Computer Graphics, ISY, LiTH. Splines
28(69) Splines Originally a drafting tool to create a smooth curve In computer graphics: a curve built from sections, each described by a 2nd or 3rd degree polynomial. Very common in non-real-time graphics,
More informationCS770/870 Spring 2017 Open GL Shader Language GLSL
Preview CS770/870 Spring 2017 Open GL Shader Language GLSL Review traditional graphics pipeline CPU/GPU mixed pipeline issues Shaders GLSL graphics pipeline Based on material from Angel and Shreiner, Interactive
More informationCS770/870 Spring 2017 Open GL Shader Language GLSL
CS770/870 Spring 2017 Open GL Shader Language GLSL Based on material from Angel and Shreiner, Interactive Computer Graphics, 6 th Edition, Addison-Wesley, 2011 Bailey and Cunningham, Graphics Shaders 2
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 informationReview of Tuesday. ECS 175 Chapter 3: Object Representation
Review of Tuesday We have learnt how to rasterize lines and fill polygons Colors (and other attributes) are specified at vertices Interpolation required to fill polygon with attributes 26 Review of Tuesday
More informationOpenGL Performances and Flexibility
OpenGL Performances and Flexibility Marco Di Benedetto Visual Computing Laboratory ISTI CNR, Italy OpenGL Roadmap 1.0 - Jan 1992 - First Version 1.1 - Jan 1997 - Vertex Arrays, Texture Objects 1.2 - Mar
More informationShadows. Prof. George Wolberg Dept. of Computer Science City College of New York
Shadows Prof. George Wolberg Dept. of Computer Science City College of New York Objectives Introduce Shadow Algorithms Expand to projective textures 2 Flashlight in the Eye Graphics When do we not see
More informationToday. Rendering - III. Outline. Texturing: The 10,000m View. Texture Coordinates. Specifying Texture Coordinates in GL
Today Rendering - III CS148, Summer 2010 Graphics Pipeline and Programmable Shaders Artist Workflow Siddhartha Chaudhuri 1 2 Outline Texturing: The 10,000m View Intro to textures The fixed-function graphics
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 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 informationIntroduction to Computer Graphics with WebGL
Introduction to Computer Graphics with WebGL Ed Angel Professor Emeritus of Computer Science Founding Director, Arts, Research, Technology and Science Laboratory University of New Mexico Models and Architectures
More informationToday. Texture mapping in OpenGL. Texture mapping. Basic shaders for texturing. Today. Computergrafik
Computergrafik Today Basic shader for texture mapping Texture coordinate assignment Antialiasing Fancy textures Matthias Zwicker Universität Bern Herbst 2009 Texture mapping Glue textures (images) onto
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 informationCS452/552; EE465/505. Clipping & Scan Conversion
CS452/552; EE465/505 Clipping & Scan Conversion 3-31 15 Outline! From Geometry to Pixels: Overview Clipping (continued) Scan conversion Read: Angel, Chapter 8, 8.1-8.9 Project#1 due: this week Lab4 due:
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. Implementing Texturing What Can Go Wrong and How to Fix It Mipmapping Filtering Perspective Correction
TEXTURE MAPPING 1 OUTLINE Implementing Texturing What Can Go Wrong and How to Fix It Mipmapping Filtering Perspective Correction 2 BASIC STRAGEGY Three steps to applying a texture 1. specify the texture
More informationFast Tessellated Rendering on Fermi GF100. HPG 2010 Tim Purcell
Fast Tessellated Rendering on Fermi GF100 Hot3D @ HPG 2010 Tim Purcell Outline DX10 state of the art DX11 tessellation Fermi GF100 architecture Results Demo 2 State of the Art: DX10 pipeline Input Assembler
More informationShader Programs. Lecture 30 Subsections 2.8.2, Robb T. Koether. Hampden-Sydney College. Wed, Nov 16, 2011
Shader Programs Lecture 30 Subsections 2.8.2, 2.8.3 Robb T. Koether Hampden-Sydney College Wed, Nov 16, 2011 Robb T. Koether (Hampden-Sydney College) Shader Programs Wed, Nov 16, 2011 1 / 43 Outline 1
More informationCSE 167: Introduction to Computer Graphics Lecture #7: Textures. Jürgen P. Schulze, Ph.D. University of California, San Diego Fall Quarter 2018
CSE 167: Introduction to Computer Graphics Lecture #7: Textures Jürgen P. Schulze, Ph.D. University of California, San Diego Fall Quarter 2018 Announcements Project 2 due this Friday at 2pm Grading in
More information