1 ! The Graphics Pipeline and OpenGL III: OpenGL Shading Language (GLSL 1.10)! Gordon Wetzstein! Stanford University! EE 267 Virtual Reality! Lecture 4! stanford.edu/class/ee267/!
2 Updates! for 24h lab access: please Steven Clark (with some arguments that convince him that you read the lab instructions, e.g. screenshot of last slide)! lab computers can also be used remotely! (instructions on piazza & website to follow)! waitlist: looks like everyone who is still on the waitlist will get in! HW1 due Thursday at midnight!!
3 Lecture Overview! Review of graphics pipeline! vertex and fragment shaders! OpenGL Shading Language (GLSL 1.10)! Implementing lighting & shading with GLSL vertex and fragment shaders!!
4 Reminder: The Graphics Pipeline!
5 Reminder: The Graphics Pipeline! The Rasterizer two goals:! 1.! determine which fragments are inside the primitives (triangles) and which ones aren t! 2.! interpolate per-vertex attributes (color, texture coordinates, normals, ) to each fragment in the primitive!!
6 Reminder: The Graphics Pipeline! vertex shader! fragment shader!! transforms!! (per-vertex) lighting!!!! texturing!! (per-fragment) lighting!!!
7 Vertex Shaders! input! vertex position, normal, color, material, texture coordinates!! modelview matrix, projection matrix, normal matrix!!! vertex shader (executed for each vertex) void main () // do something here output! transformed vertex position (in clip coords), texture coordinates!!!
8 Fragment Shaders! input! vertex position in window coords, texture coordinates!!! fragment shader (executed for each fragment) void main () // do something here output! fragment color!! fragment depth!!!
9 Why Do We Need Shaders?! massively parallel computing! single instruction multiple data (SIMD) paradigm à GPUs are designed to be parallel processors! vertex shaders are independently executed for each vertex on GPU (in parallel)! fragment shaders are independently executed for each fragment on GPU (in parallel)!
10 ! Why Do We Need Shaders?!!!! most important: vertex transforms and lighting & shading calculations! shading: how to compute color of each fragment (e.g. interpolate colors)! 1.! Flat shading! 2.! Gouraud shading (per-vertex shading)! 3.! Phong shading (per-fragment shading)! other: render motion blur, depth of field, physical simulation,! courtesy: Intergraph Computer Systems!
11 !!!! Shading Languages! Cg (C for Graphics NVIDIA, deprecated)! GLSL (GL Shading Language OpenGL)! EE 267!! HLSL (High Level Shading Language - MS Direct3D)!
12 Demo Simple Vertex Shader! // variable passed in from application uniform float deformation = 1.0; void main () // vertex shader // deform vertex position vec3 pos = gl_vertex.xyz + deformation * gl_normal; // convert to clip space gl_position = gl_modelviewprojectionmatrix * vec4(pos,1.0); // do lighting calculations here (in world space)
13 Demo Simple Fragment Shader! // variables passed in from application uniform sampler2d texture; uniform float gamma = 1.0; void main () // fragment shader // texture lookup vec3 texturecolor = texture2d(texture, gl_texcoord.xy).rgb; // set output color by applying gamma gl_fragcolor.rgb = pow(texturecolor,gamma);
14 Demo Vertex & Fragment Shader! // variable to be passed from vertex to fragment shader varying vec4 mycolor; void main () // vertex shader Gouraud shading // transform position to clip space gl_position = gl_modelviewprojectionmatrix * gl_vertex; // transform position to world space vec4 positionworld = gl_modelviewmatrix * gl_vertex; // transform normal into world space vec3 normalworld = gl_normalmatrix * gl_normal; // do lighting calculations here (in world space) mycolor = // variable to be passed from vertex to fragment shader varying vec4 mycolor; void main () // fragment shader - Gouraud shading gl_fragcolor = mycolor;
15 Demo Vertex & Fragment Shader! // variable to be passed from vertex to fragment shader varying vec4 mypos; varying vec3 mynormal; void main () // vertex shader Phong shading // transform position to clip space gl_position = gl_modelviewprojectionmatrix * gl_vertex; // transform position to world space vec4 mypos = gl_modelviewmatrix * gl_vertex; // transform normal into world space vec3 mynormal = gl_normalmatrix * gl_normal; // variable to be passed from vertex to fragment shader varying vec4 mypos; varying vec3 mynormal; void main () // fragment shader - Phong shading // do lighting calculations here gl_fragcolor = ;
16 Demo General Purpose Computation Shader! // variables passed in from application uniform sampler2d tex; uniform float timestep = 1.0; void main () // fragment shader vec2 texcoord = gl_texcoord.xy; // texture lookups float u = texture2d(tex,texcoord).r; float u_xp1 = texture2d(tex, float2(texcoord.x+1,texcoord.y)).r; float u_xm1 = texture2d(tex, float2(texcoord.x-1,texcoord.y)).r; float u_yp1 = texture2d(tex, float2(texcoord.x,texcoord.y+1)).r; float u_ym1 = texture2d(tex, float2(texcoord.x,texcoord.y-1)).r; glfragcolor.r = u + timestep*(u_xp1+u_xm1+u_yp1+u_ym1-4*u);!u heat equation:!!t = "#2 u u ( t+1) =! t "# 2 u + u ( t)
17 ! OpenGL Shading Language (GLSL)! high-level programming language for shaders! syntax similar to C (i.e. has main function and many other similarities)! usually very short programs that are executed in parallel on GPU! good introduction / tutorial:!
18 OpenGL Shading Language (GLSL)! versions of OpenGL, WebGL, GLSL can get confusing! here s what we use:! WebGL based on OpenGL ES 2.0! GLSL shader preprocessor: #version 110 reason: three.js doesn t support WebGL 2.0 yet!
19 GLSL Simplest (pass-through) Vertex Shader! void main () // vertex shader // transform position to clip space // this is similar to gl_position = ftransform(); gl_position = gl_modelviewprojectionmatrix * gl_vertex;
20 GLSL Simplest Fragment Shader! void main () // fragment shader // set same color for each fragment gl_fragcolor = vec4(1.0,0.0,0.0,1.0);
21 GLSL Data Types! bool int float ivec2, ivec3, ivec4 vec2, vec3, vec4 mat2, mat3, mat4 sampler2d! boolean (true or false)! signed integer! 32 bit floating point! integer vector with 2, 3, or 4 elements! floating point vector with 2, 3, or 4 elements! floating point matrix with 2x2, 3x3, or 4x4 elements! handle to a 2D texture!
22 ! GLSL Data Types! uniform type read-only values passed in from CPU application, e.g. uniform float or uniform sampler2d vertex shader! fragment shader! void main () gl_position = gl_modelviewprojectionmatrix * gl_vertex; uniform sampler2d texture; void main () gl_fragcolor = texture2d(texture, gl_texcoords.xy);
23 ! GLSL Data Types! varying type variables that are passed from vertex to fragment shader (i.e. write-only in vertex shader, read-only in fragment shader)! vertex shader! fragment shader! varying float myvalue; void main () gl_position = gl_modelviewprojectionmatrix * gl_vertex; myvalue = / 10.0; varying float myvalue; void main () gl_fragcolor = vec4(myvalue, myvalue, myvalue, 1.0);
24 GLSL Standard Attributes in Vertex Shader! built-in attributes! vec4 gl_vertex vec3 gl_normal vec4 gl_color vertex position! vertex normal! vertex color! vec4 gl_multitexcoordx vertex texture coords of texture unit X! built-in uniforms!! mat4 gl_modelviewmatrix modelview matrix mat4 gl_modelviewprojectionmatrix modelview projection matrix! mat3 gl_normalmatrix normal matrix (i.e. inverse transpose of modelview matrix) built-in varying!! vec4 gl_position vertex position in clip coords! vec4 gl_frontcolor color! vec4 gl_texcoord[x] texture coords of texture unit X
25 Disclaimer! modelview and projection matrices can be used via either the built-in uniforms OR as regular, user-defined built-in variables! in the lab & homework, we will not use the built-in variables but pass in the matrices manually!
26 GLSL Standard Attributes in Fragment Shader! built-in (varying) input! vec4 gl_fragcoord vec4 gl_texcoord[x] vec4 gl_color (x,y,z,1/w clip ) in window space! interpolated texture coordinates! interpolated color from gl_frontcolor built-in output! vec4 gl_fragcolor fragment color! float gl_fragdepth value written to depth buffer, if not specified: gl_fragcoord.z!
28 GLSL Shader! Uniforms! all of these values will be interpolated over the primitive by rasterizer! Uniforms! Samplers! Attribute 0! Varying 0! Attribute 1! Varying 1! Attribute 2! Varying 2! Attribute 3! Attribute 4! Vertex Shader! Varying 3! Varying 4! Fragment Shader! gl_fragcolor! Attribute 5! Attribute 6! Varying 5! Varying 6! Attribute 7! Varying 7! Temporary Variables! gl_position! gl_texcoord[x]!! gl_fragcoord! gl_texcoord[x]!! Temporary Variables!
29 GLSL built-in functions! dot dot product between two vectors! cross cross product between two vectors! texture2d texture lookup (get color value of texture at some tex coords)! normalize normalize a vector! clamp clamp a scalar to some range (e.g., 0 to 1)! radiants, degrees, sin, cos, tan, asin, acos, atan, pow, exp, log, exp2, log2, sqrt, abs, sign, floor, ceil, mod, min, max, length, good summary of OpenGL ES (WebGL) shader functions:!
30 Gouraud Shading with GLSL (only diffuse part)! uniform vec3 lightpositionworld; uniform vec3 lightcolor; uniform vec3 diffusematerial; void main () // vertex shader // transform position to clip space gl_position = gl_modelviewprojectionmatrix * gl_vertex; // transform vertex position, normal, and light position to view space vec3 P = vec3 L = vec3 N = // compute the diffuse term here float diffusefactor = // set output color gl_frontcolor.rgb = diffusefactor * diffusematerial * lightcolor;
31 Gouraud Shading with GLSL (only diffuse part)! void main () // fragment shader // set output color gl_fragcolor = gl_color;
32 Phong Shading with GLSL (only diffuse part)! varying vec3 vposition; varying vec3 vnormal; void main () // vertex shader // transform position to clip space gl_position = gl_modelviewprojectionmatrix * gl_vertex; // transform vertex position, normal, and light position to view space vec3 P = vec3 N = // set output texture coordinate to vertex position in world coords vposition = P; // set output color to vertex normal direction vnormal = N;
33 Phong Shading with GLSL (only diffuse part)! uniform vec3 lightcolor; uniform vec3 diffusematerial; uniform vec3 lightpositionworld; varying vec3 vposition; varying vec3 vnormal; void main () // fragment shader // incoming color is interpolated by rasterizer over primitives! vec3 N = vnormal; // vector pointing to light source vec3 L = // compute the diffuse term float diffusefactor // set output color gl_fragcolor.rgb = diffusefactor * diffusematerial * lightcolor;
34 ! GLSL - Misc! swizzling:! vec4 myvector1; vec4 myvector2; vec3 myvector1.xxy + myvector2.zxy; matrices are column-major ordering! initialize vectors in any of the following ways:! vec4 myvector = vec4(1.0, 2.0, 3.0, 4.0); vec4 myvector2 = vec4(vec2(1.0, 2.0), 3.0, 4.0); vec4 myvector3 = vec4(vec3(1.0, 2.0, 3.0), 4.0); sometimes OpenGL quantizes gl_frontcolor (vertex shader) to gl_color (fragment shader) to 8 bits per channel, despite being a float à may need to use gl_texcoord[x] instead to preserve precision! these are equivalent:! myvector.xyzw = myvector.rgba = myvector.uvst we omitted a lot of details
36 Summary! GLSL is your language for writing vertex and fragment shaders! each shader is independently executed for each vertex/fragment on the GPU! usually require both vertex and fragment shader, but can pass-through data!
37 Further Reading! GLSL tutorial: summary of built-in GLSL functions: GLSL and WebGL:
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
CSCI 420 Computer Graphics Lecture 4 Shaders Jernej Barbic University of Southern California Shading Languages GLSL Vertex Array Objects Vertex Shader Fragment Shader [Angel Ch. 1, 2, A] Introduction The
Lecture 09: Shaders (Part 1) CSE 40166 Computer Graphics Peter Bui University of Notre Dame, IN, USA November 9, 2010 OpenGL Rendering Pipeline OpenGL Rendering Pipeline (Pseudo-Code) 1 f o r gl_vertex
1 The Transition from RenderMan to the OpenGL Shading Language (GLSL) Mike Bailey firstname.lastname@example.org This work is licensed under a Creative Commons Attribution-NonCommercial- NoDerivatives 4.0 International
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:
1 Introduction to the OpenGL Shading Language (GLSL) This work is licensed under a Creative Commons Attribution-NonCommercial- NoDerivatives 4.0 International License Mike Bailey email@example.com
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
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
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
Introduction to Shaders Marco Benvegnù firstname.lastname@example.org www.benve.org Summer 2005 Overview Rendering pipeline Shaders concepts Shading Languages Shading Tools Effects showcase Setup of a Shader in OpenGL
2D graphics with WebGL Some material contained here is adapted from the book s slides. September 7, 2015 (Dr. Mihail) 2D graphics September 7, 2015 1 / 22 Graphics Pipeline (Dr. Mihail) 2D graphics September
Mobile Application Programing: Android OpenGL Operation Activities Apps are composed of activities Activities are self-contained tasks made up of one screen-full of information Activities start one another
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
Introduction to the OpenGL Shading Language Randi Rost Director of Developer Relations, 3Dlabs 08-Dec-2005 1 Why use graphics programmability? Graphics hardware has changed radically Fixed functionality
OpenGL shaders and programming models that provide object persistence COSC342 Lecture 22 19 May 2016 OpenGL shaders We discussed forms of local illumination in the ray tracing lectures. We also saw that
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)?
Shaders CSCI 4239/5239 Advanced Computer Graphics Spring 2014 What is a Shader? Wikipedia: A shader is a computer program used in 3D computer graphics to determine the final surface properties of an object
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
GLSL Programming Nicolas Holzschuch GLSL programming C-like language structure: int i, j; i = 2; j = 0; j += i; Functions, loops, branches... Reading your first GSL shader is easy Differences with C New
Vertex & Fragment shaders The next big step in graphics hardware Adds programmability to the previously fixed rendering pipeline The OpenGL Shading Language (a.k.a. GLSL, glslang) Vertex shaders: programs
1 GLSL v1.20 Scott MacHaffie Schrödinger, Inc. http://www.schrodinger.com Table of Contents Introduction...2 Example 01: Trivial shader...2 Syntax...3 Types of variables...3 Example 02: Materials vertex
Name Solution GPU Programming EE 4702-1 Final Examination Friday, 11 December 2015 15:00 17:00 CST Alias Methane? Problem 1 Problem 2 Problem 3 Problem 4 Problem 5 Problem 6 Exam Total (20 pts) (15 pts)
Advanced Graphics The Shader knows Alex Benton, University of Cambridge A.Benton@damtp.cam.ac.uk Supported in part by Google UK, Ltd What is the shader? Local space World space Viewing space Local space
Copyright Khronos Group 2012 Page 1 Teaching GL Dave Shreiner Director, Graphics and GPU Computing, ARM 1 December 2012 Copyright Khronos Group 2012 Page 2 Agenda Overview of OpenGL family of APIs Comparison
Objectives Shading in OpenGL Introduce the OpenGL shading methods - per vertex shading vs per fragment shading - Where to carry out Discuss polygonal shading - Flat - Smooth - Gouraud CITS3003 Graphics
Shader Programming Technical Game Development II Professor Charles Rich Computer Science Department email@example.com Reference: Rost, OpenGL Shading Language, 2nd Ed., AW, 2006 The Orange Book Also take CS
Mobile Application Programming: Android OpenGL Operation OpenGL ES C-Based Performance-Oriented Graphics Library Wrapper libraries provided for Java, C#, etc. Produces 2D images from 2D or 3D geometric
MXwendler Fragment Shader Development Reference Version 1.0 This document describes the MXwendler fragmentshader interface. You will learn how to write shaders using the GLSL language standards and the
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
Artistic Rendering with Graphics Shaders by A Master Research Paper submitted to the Eastern Michigan University, Department of Computer Science In Partial Fulfillment of the Requirements for the Master
Understanding Shaders and WebGL Chris Dalton & Olli Etuaho Agenda Introduction: Accessible shader development with WebGL Understanding WebGL shader execution: from JS to GPU Common shader bugs Accessible
Name GPU Programming EE 4702-1 Final Examination Friday, 11 December 2015 15:00 17:00 CST Alias Problem 1 Problem 2 Problem 3 Problem 4 Problem 5 Problem 6 Exam Total (20 pts) (15 pts) (15 pts) (20 pts)
OpenGL Shading Language GLSL Is a high level shading language based on the C programming language. It was created by the OpenGL ARB to give developers more direct control of the graphics pipeline without
Comp 410/510 Computer Graphics Spring 2018 Programming with OpenGL Part 3: Shaders Objectives Basic shaders - Vertex shader - Fragment shader Programming shaders with GLSL Finish first program void init(void)
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
OpenGL, GLUT, GLEW, GLSL An Overview GLUT GLEW GLSL Objectives Give you an overview of the software that you will be using this semester OpenGL, GLUT, GLEW, GLSL What are they? How do you use them? What
Today s Agenda Shaders fundamentals Programming with shader-based OpenGL Shaders Like a function call data are passed in, processed, and passed back out -- Shreiner et al, OpenGL Programming Guide GLSL
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,
Lessons Learned from HW Shading CS Interactive Computer Graphics Prof. David E. Breen Department of Computer Science Only have an idle() function if something is animated Set idle function to NULL, when
Computergraphics Exercise 15/16 3. Shading & Texturing Jakob Wagner for internal use only Shaders Vertex Specification define vertex format & data in model space Vertex Processing transform to clip space
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
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!
GLSL II Ed Angel Professor of Computer Science, Electrical and Computer Engineering, and Media Arts Director, Arts Technology Center University of New Mexico Objectives Coupling GLSL to Applications Example
CS452/552; EE465/505 Lighting & Shading 2-17 15 Outline! More on Lighting and Shading Read: Angel Chapter 6 Lab2: due tonight use ASDW to move a 2D shape around; 1 to center Local Illumination! Approximate
Shading Models There are two main types of rendering that we cover, polygon rendering ray tracing Polygon rendering is used to apply illumination models to polygons, whereas ray tracing applies to arbitrary
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
Bandwidth Gravity of modern computer systems GPUs Under the Hood Prof. Aaron Lanterman School of Electrical and Computer Engineering Georgia Institute of Technology The bandwidth between key components
2 Lecture Outline Introduction to DirectX & Direct3D Lab 2a: Direct3D Basics William H. Hsu Department of Computing and Information Sciences, KSU KSOL course pages: http://bit.ly/hgvxlh / http://bit.ly/evizre
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
Cg: A system for programming graphics hardware in a C-like language William R. Mark University of Texas at Austin R. Steven Glanville NVIDIA Kurt Akeley NVIDIA and Stanford University Mark Kilgard NVIDIA
Graphics Hardware, Graphics APIs, and Computation on GPUs Mark Segal Overview Graphics Pipeline Graphics Hardware Graphics APIs ATI s low-level interface for computation on GPUs 2 Graphics Hardware High
Best practices for effective OpenGL programming Dan Omachi OpenGL Development Engineer 2 What Is OpenGL? 3 OpenGL is a software interface to graphics hardware - OpenGL Specification 4 GPU accelerates rendering
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
Stored Texture Shaders 157 Preparing for Texture Access These steps are the same when using a shader as when using fixed functionality Make a specific texture unit active by calling glactivetexture Create
Teaching a Modern Graphics Pipeline Using a Shader-based Software Renderer Heinrich Fink 1 Thomas Weber 1 Michael Wimmer 1 1 Institute of Computer Graphics and Algorithms, Vienna University of Technology
Shading Languages Ari Silvennoinen Apri 12, 2004 Introduction The recent trend in graphics hardware has been to replace fixed functionality in vertex and fragment processing with programmability , ,
GpuPy: Accelerating NumPy With a GPU Washington State University School of Electrical Engineering and Computer Science Benjamin Eitzen - firstname.lastname@example.org Robert R. Lewis - email@example.com Presentation
OPEN GL Modified from Angel 6e book slides BACKGROUND Objectives Early History of APIs Development of the OpenGL API OpenGL Architecture OpenGL as a state machine OpenGL as a data flow machine Functions
Using Shaders for Lighting Mike Bailey firstname.lastname@example.org Lighting Definitions L N R E N = Normal L = Light vector E = Eye vector R = Light reflection vector ER = Eye reflection vector Color = LightColor
GLSL II Ed Angel Professor of Computer Science, Electrical and Computer Engineering, and Media Arts Director, Arts Technology Center University of New Mexico Objectives Coupling GLSL to Applications Example
OpenGL SUPERBIBLE Fifth Edition Comprehensive Tutorial and Reference Richard S. Wright, Jr. Nicholas Haemel Graham Sellers Benjamin Lipchak AAddison-Wesley Upper Saddle River, NJ Boston Indianapolis San
Shaders in Jitter Powerful as Jitter is, simple appearing patches often run up against the performance limitations of the computer, especially if we are trying for high resolution. You can't do very many
COURSE 17: STATE-OF-THE-ART IN SHADING HARDWARE1 CHAPTER 6: THE OPENGL SHADING LANGUAGE 2 Randi J. Rost 3Dlabs, Inc. SIGGRAPH 2002 Course Notes 05-August-2002 SIGGRAPH 2002 6-1 State of the Art in Shading
Orthogonal Projection Matrices 1 Objectives Derive the projection matrices used for standard orthogonal projections Introduce oblique projections Introduce projection normalization 2 Normalization Rather
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
Appendix E E.Order of Operations This book describes all the performed between initial specification of vertices and final writing of fragments into the framebuffer. The chapters of this book are arranged
WebGL: Hands On DevCon5 NYC 2011 Kenneth Russell Software Engineer, Google, Inc. Chair, WebGL Working Group Today's Agenda Introduce WebGL and its programming model. Show code for a complete example. Demonstrate
Fall 2017 CSCI 420: Computer Graphics 5.2 Shading in OpenGL Hao Li http://cs420.hao-li.com 1 Outline Normal Vectors in OpenGL Polygonal Shading Light Sources in OpenGL Material Properties in OpenGL Example:
Drawing Fast The Graphics Pipeline CS559 Fall 2016 Lectures 10 & 11 October 10th & 12th, 2016 1. Put a 3D primitive in the World Modeling 2. Figure out what color it should be 3. Position relative to the
The University of Southern Mississippi The Aquila Digital Community Honors Theses Honors College 5-2013 Water Simulation on WebGL and Three.js Kerim J. Pereira Follow this and additional works at: http://aquila.usm.edu/honors_theses
Rendering Pipeline Rendering Pipeline Converts geometric primitives into images Is split into several independent stages Those are usually executed concurrently Pipeline 18.10.2013 Steiner- Wallner- Podaras