Surface Graphics. 200 polys 1,000 polys 15,000 polys. an empty foot. - a mesh of spline patches:

Size: px
Start display at page:

Download "Surface Graphics. 200 polys 1,000 polys 15,000 polys. an empty foot. - a mesh of spline patches:"

Transcription

1 Surface Graphics Objects are explicitely defined by a surface or boundary representation (explicit inside vs outside) This boundary representation can be given by: - a mesh of polygons: 200 polys 1,000 polys 15,000 polys - a mesh of spline patches: an empty foot 3

2 Polygon Mesh Definitions v3 e3 f1 e2 e1 v2 n1 v1, v2, v3: vertices (3D coordinates) e1, e2, e3: edges e1 = v2 - v1 and e2 = v3 - v2 f1: polygon or face v1 n1: face normal n1 = e1 e e1 e2 view plane (screen) n3 backface n4 n1 n2 = = e11 e e11 e12 e21 e e21 e22, e21 = -e12 n1 e11 e12 e21 e22 view vector vp n2 Rule: if all edge vectors in a face are ordered counterclockwise, then the face normal vectors will always point towards the outside of the object. This enables quick removal of back-faces (back-faces are the faces hidden from the viewer): - back-face condition: vp n > 0 5

3 Polygon Mesh Data Structure Vertex list (v1, v2, v3, v4,...): (x1, y1, z1), (x2, y2, z2), (x3, y3, z3), (x4, y4, z4),... Edge list (e1, e2, e3, e4, e5,...): (v1, v2), (v2, v3), (v3, v1), (v1, v4), (v4, v2),... Face list (f1, f2,...): v3 e2 v2 (e1, e2, e3), (e4, e5, -e1),... or (v1, v2, v3), (v1, v4, v2),... e3 f1 n1 e1 f2 e5 Normal list (n1, n2,...), one per face or per vertex (n1x, n1y, n1z), (n2x, n2y, n2z),... v1 e4 n2 v4 Use Pointers or indices into vertex and edge list arrays, when appropriate 6

4 Object-Order Viewing - Overview screen in world space W Cop y n v u H Eye (Camera) Viewing Transform y transformed object - z object - z object projected to the screen x Eye v u screen in viewing space x A view is specified by: - eye position (Eye) - view direction vector (n) - screen center position (Cop) - screen orientation (u, v) - screen width W, height H u, v, n are orthonormal vectors After the viewing transform: - the screen center is at the coordinate system origin - the screen is aligned with the x, y-axis - the viewing vector points down the negative z-axis - the eye is on the positive z-axis All objects are transformed by the viewing transform 7

5 Step 1: Viewing Transform The sequence of transformations is: - translate the screen Center Of Projection (COP) to the coordinate system orgin (T view ) - rotate the translated screen such that the view direction vector n points down the negative z- axis and the screen vectors u, v are aligned with the x, y-axis (R view ) We get M view = R view T view We transform all object (points, vertices) by M view : x' y' z' 1 = u x u y u z 0 v x v y v z 0 n x n y n z Cop x 010 Cop y 001 Cop z x y z 1 Now the objects are easy to project since the screen is in a convenient position - but first we have to account for perspective distortion... 8

6 Step 2: Perspective Projection y y y p Eye z eye z screen plane A (view-transformed) vertex with coordinates (x, y, z ) projects onto the screen as follows: y p eye = y' x eye z' p = x' eye eye z' x p and y p can be used to determine the screen coordinates of the object point (i.e., where to plot the point on the screen) 9

7 Step 1 + Step 2 = World-To-Screen Transform Perspective projection can also be captured in a matrix M proj with a subsequent perspective divide by the homogenous coordinate w: x h y h z h w = eye eye eye x' y' z' 1 x h x p = w y h y p = w So the entire world-to-screen transform is: M trans = M proj M view = M proj R view T view with a subsequent divide by the homogenous coordinate M trans is composed only once per view and all object points (vertices) are multiplied by it 10

8 Step 3: Window Transform (1) Note: our camera screen is still described in world coordinates However, our display monitor is described on a pixel raster of size (Nx, Ny) The transformation of (perspective) viewing coordinates into pixel coordinates is called window transform Assume: - we want to display the rendered screen image in a window of size (Nx, Ny) pixels - the width and height of the camera screen in world coordinates is (W, H) - the center of the camera is at the center of the screen coordinate system Then: - the valid range of object coordinates is (-W/2... +W/2, -H/2... +H/2) - these have to be mapped into (0... Nx-1, 0... Ny-1): x W s x p Nx 1 = y H 2 W s y p Ny 1 = H H camera W window Nx Ny 11

9 Step 3: Window Transform (2) The window transform can be written as the matrix M window : x s y s 1 = Nx 1 Nx W 2 Ny Ny H x p y p 1 After the perspective divide, all object points (vertices) are multiplied by M window Note: we could figure the window transform into M trans - in that case, there is only one matrix multiply per object point (vertex) with a subsequent perspective divide - the OpenGL graphics pipeline does this 12

10 Orthographic (Parallel) Projection Leave out the perspective mapping (step 2) in the viewing pipeline In orthographic projection, all object points project along parallel lines onto the screen y y y y p =y y p z z perspective projection orthographic projection 13

11 Rendering the Polygonal Objects - The Hidden Surface Removal Problem We have removed all faces that are definitely hidden: the back-faces But even the surviving faces are only potentially visible - they may be obscured by faces closer to the viewer face A of object 1 is partially obscured by face B of object 2 obj 1 A obj 2 B screen Problem of identifying those face portions that are visible is called the hidden surface problem Solutions: - pre-ordering of the faces and subdivision into their visible parts before display (expensive) - the z-buffer algorithm (cheap, fast, implementable in hardware) 14

12 The Z-Buffer (Depth-Buffer) Scan Conversion Algorithm Two data structures: - z-buffer: holds for each image pixel the z-coordinate of the closest object so far - color-buffer: holds for each pixel the closest object s color Basic z-buffer algorithm: color buffer z-buffer // initialize buffers for all (x, y) z-buffer(x, y) = -infinity; color-buffer(x, y) = color background // scan convert each front-face polygon for each front-face poly for each scanline y that traverses projected poly for each pixel x in scanline y and projected poly if z poly(x, y) > z-buffer(x, y) initialize buffers scan-convert face B of obj. 2 z-buffer(x, y) = z poly(x, y) color-buffer(x, y) = color poly(x, y) scan-convert face A of obj. 1 15

13 Polygon Shading Methods - Faceted Shading vertex3 How are the pixel colors determined in z-buffer? rasterized pixel (x,y) scanline y The simplest method is flat or faceted shading: vertex2 - each polygon has a constant color vertex1 - compute color at one point on the polygon (e.g., at center) and use everywhere - assumption: lightsource and eye is far away, i.e., N L, H E = const. N L E Problem: discontinuities are likely to appear at face boundaries 16

14 Polygon Shading Methods - Gouraud Shading Colors are averaged across polygons along common edges no more discontinuities Steps: - determine average unit normal at each poly vertex: N v = n k = 1 N k n k = 1 N k n: number of faces that have vertex v in common N v - apply illumination model at each poly vertex C v - linearly interpolate vertex colors across edges - linearly interpolate edge colors across scan lines C 3 C 1 y C p C 12 C 23 x C 2 Downside: may miss specular highlights at off-vertex positions or distort specular highlights 17

15 Polygon Shading Methods - Phong Shading Phong shading linearly interpolates normal vectors, not colors Steps: more realistic specular highlights illumination model N 3 - determine average normal at each vertex - linearly interpolate normals across edges - linearly interpolate normals across scanlines N 1 y N p C p N 12 N 23 x N 2 - apply illumination model at each pixel to calculate pixel color Downside: need more calculations since need to do illumination model at each pixel 18

16 Rendering With OpenGl (1) look also in glmatrixmode(gl_projection) Define the viewing window: glortho() for parallel projection glfrustum() for perspective projection glmatrixmode(gl_modelview) Specify the viewpoint glulookat() /* need to have GLUT */ Model the scene Modelview Matrix Stack glulookat(...) gltranslate(x,y,z) glrotate(ϕ y,0,1,0) glrotate(ϕ z,0,0,1) glrotate(ϕ x,1,0,0) order of execution rotate first, then translate, then do viewing... gltranslate(), glrotate(), glscale(),... Vertex x y z w object coordinates Modelview Matrix Viewport Transfor- mation eye coordinates OpenGL rendering pipeline Projection Matrix clip coordinates Perspective Division window coordinates normalized device coordinates 19

17 Rendering With OpenGl (2) Specify the light sources: gllight() Enable the z-buffer: glenable(gl_depth_test) Enable lighting: glenable(gl_lighting) Enable light source i: glenable(gl_lighti) /* GL_LIGHTi is the symbolic name of light i */ Select shading model: glshademodel() /* GL_FLAT or GL_SMOOTH */ For each object: /* duplicate the matrix on the stack if want to apply some extra transformations to the object */ glpushmatrix(); gltranslate(), glrotate(), glscale() /* any specific transformation on this object */ for all polygons of the object: /* specify the polygon (assume a triangle here) */ glbegin(gl_polygon); glcolor3fv(c1); glvertex3fv(v1); glnormal3fv(n1); /* vertex 1 */ glcolor3fv(c2); glvertex3fv(v2); glnormal3fv(n2); /* vertex 2 */ glcolor3fv(c3); glvertex3fv(v3); glnormal3fv(n3); /* vertex 3 */ glend(); glpopmatrix() /* get rid of the object-specific transformations, pop back the saved matrix */ 20

18 Texture Mapping - Realistic Detail for Boring Polygons Leonard McMillan, UNC 3

19 Texture Mapping - Large Walls Take pictures, map as textures onto large polygon 4

20 Texture Mapping Large Walls - OpenGL Program glenable(gl_texture_2d); for each polygon glbindtexture(texturename); glbegin(gl_quad); glcolor3fv(c1); glvertex3fv(v1); gltexcoord2d(0.0, 0.0); /* vertex 1 */ glcolor3fv(c2); glvertex3fv(v2); gltexcoord2d(0.0, 1.0); /* vertex 2 */ glcolor3fv(c3); glvertex3fv(v3); gltexcoord2d(1.0, 1.0); /* vertex 3 */ glcolor3fv(c4); glvertex3fv(v4); gltexcoord2d(1.0, 0.0); /* vertex 4 */ glend(); (1.0, 0.0) (1.0, 1.0) (0.0, 0.0) (0.0, 1.0) 5

21 Texture Mapping - Small Facets Leonard McMillan, UNC 6

22 Texture Mapping Small Facets - OpenGL Program glenable(gl_texture_2d); glbindtexture(texturename); for each polygon i in the mesh glbegin(gl_quad); glcolor3fv(c[i][0]); glvertex3fv(v[i][0]); gltexcoord2fv(t[i][0]); /* vertex 1 */ glcolor3fv(c[i][1]); glvertex3fv(v[i][1]); gltexcoord2fv(t[i][1]); /* vertex 2 */ glcolor3fv(c[i][2]); glvertex3fv(v[i][2]); gltexcoord2fv(t[i][2]); /* vertex 3 */ glend(); polygon mesh texture (image) v[i][0] screen pixel v[i][2] interpolated texel v[i][1] 7

23 Complete Graphics Pipeline screen display (framebuffer) polygon primitives transformed into screen space vertex transformation transformed vertices rasterization shading texture mapping shaded and texture fragments vertex shader fragment shader (vertex engine) (rasterizers) fragments are interpolated from texture image 8

24 Graphics Hardware - Peeking Under The Hood Graphics hardware accelerates vertex and fragment shaders - (almost) fully programmable - enables accurate physics and visuals - realistic games - latest: real-time movie production on the PC - accelerate even general purpose, scientific and numerical computations (GPGPU) 9

CSE 690: GPGPU. Lecture 2: Understanding the Fabric - Intro to Graphics. Klaus Mueller Stony Brook University Computer Science Department

CSE 690: GPGPU Lecture 2: Understanding the Fabric - Intro to Graphics Klaus Mueller Stony Brook University Computer Science Department Klaus Mueller, Stony Brook 2005 1 Surface Graphics Objects are explicitely

Pipeline 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

Pipeline Operations. CS 4620 Lecture 10

Pipeline Operations CS 4620 Lecture 10 2008 Steve Marschner 1 Hidden surface elimination Goal is to figure out which color to make the pixels based on what s in front of what. Hidden surface elimination

Pipeline 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

Interpolation using scanline algorithm

Interpolation using scanline algorithm Idea: Exploit knowledge about already computed color values. Traverse projected triangle top-down using scanline. Compute start and end color value of each pixel

Rasterization 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

3D Rasterization II COS 426

3D Rasterization II COS 426 3D Rendering Pipeline (for direct illumination) 3D Primitives Modeling Transformation Lighting Viewing Transformation Projection Transformation Clipping Viewport Transformation

Rendering. Converting a 3D scene to a 2D image. Camera. Light. Rendering. View Plane

Rendering Pipeline Rendering Converting a 3D scene to a 2D image Rendering Light Camera 3D Model View Plane Rendering Converting a 3D scene to a 2D image Basic rendering tasks: Modeling: creating the world

OpenGL Transformations

OpenGL Transformations R. J. Renka Department of Computer Science & Engineering University of North Texas 02/18/2014 Introduction The most essential aspect of OpenGL is the vertex pipeline described in

CS 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

Notes on Assignment. Notes on Assignment. Notes on Assignment. Notes on Assignment

Notes on Assignment Notes on Assignment Objects on screen - made of primitives Primitives are points, lines, polygons - watch vertex ordering The main object you need is a box When the MODELVIEW matrix

OpenGL: Open Graphics Library. Introduction to OpenGL Part II. How do I render a geometric primitive? What is OpenGL

OpenGL: Open Graphics Library Introduction to OpenGL Part II CS 351-50 Graphics API ( Application Programming Interface) Software library Layer between programmer and graphics hardware (and other software

Module Contact: Dr Stephen Laycock, CMP Copyright of the University of East Anglia Version 1

UNIVERSITY OF EAST ANGLIA School of Computing Sciences Main Series PG Examination 2013-14 COMPUTER GAMES DEVELOPMENT CMPSME27 Time allowed: 2 hours Answer any THREE questions. (40 marks each) Notes are

Models 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

Describe the Orthographic and Perspective projections. How do we combine together transform matrices?

Aims and objectives By the end of the lecture you will be able to Work with multiple transform matrices Describe the viewing process in OpenGL Design and build a camera control APIs Describe the Orthographic

CSE 167: Introduction to Computer Graphics Lecture #4: Vertex Transformation

CSE 167: Introduction to Computer Graphics Lecture #4: Vertex Transformation Jürgen P. Schulze, Ph.D. University of California, San Diego Fall Quarter 2013 Announcements Project 2 due Friday, October 11

Shading. Introduction to Computer Graphics Torsten Möller. Machiraju/Zhang/Möller/Fuhrmann

Shading Introduction to Computer Graphics Torsten Möller Machiraju/Zhang/Möller/Fuhrmann Reading Chapter 5.5 - Angel Chapter 6.3 - Hughes, van Dam, et al Machiraju/Zhang/Möller/Fuhrmann 2 Shading Illumination

Mach band effect. The Mach band effect increases the visual unpleasant representation of curved surface using flat shading.

Mach band effect The Mach band effect increases the visual unpleasant representation of curved surface using flat shading. A B 320322: Graphics and Visualization 456 Mach band effect The Mach band effect

Lecture 4. Viewing, Projection and Viewport Transformations

Notes on Assignment Notes on Assignment Hw2 is dependent on hw1 so hw1 and hw2 will be graded together i.e. You have time to finish both by next monday 11:59p Email list issues - please cc: elif@cs.nyu.edu

Models and Architectures. Ed Angel Professor of Computer Science, Electrical and Computer Engineering, and Media Arts University of New Mexico

Models and Architectures Ed Angel Professor of Computer Science, Electrical and Computer Engineering, and Media Arts University of New Mexico 1 Objectives Learn the basic design of a graphics system Introduce

E.Order of Operations

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

CS4202: Test. 1. Write the letter corresponding to the library name next to the statement or statements that describe library.

CS4202: Test Name: 1. Write the letter corresponding to the library name next to the statement or statements that describe library. (4 points) A. GLUT contains routines that use lower level OpenGL commands

CHAPTER 1 Graphics Systems and Models 3

?????? 1 CHAPTER 1 Graphics Systems and Models 3 1.1 Applications of Computer Graphics 4 1.1.1 Display of Information............. 4 1.1.2 Design.................... 5 1.1.3 Simulation and Animation...........

Computer Graphics. Chapter 10 Three-Dimensional Viewing

Computer Graphics Chapter 10 Three-Dimensional Viewing Chapter 10 Three-Dimensional Viewing Part I. Overview of 3D Viewing Concept 3D Viewing Pipeline vs. OpenGL Pipeline 3D Viewing-Coordinate Parameters

Advanced Computer Graphics (CS & SE )

Advanced Computer Graphics (CS & SE 233.420) Topics Covered Picking Pipeline Viewing and Transformations Rendering Modes OpenGL can render in one of three modes selected by glrendermode(mode) GL_RENDER

Lecture 5: Viewing. CSE Computer Graphics (Fall 2010)

Lecture 5: Viewing CSE 40166 Computer Graphics (Fall 2010) Review: from 3D world to 2D pixels 1. Transformations are represented by matrix multiplication. o Modeling o Viewing o Projection 2. Clipping

Introduction 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

COMP3421. Introduction to 3D Graphics

COMP3421 Introduction to 3D Graphics 3D coodinates Moving to 3D is simply a matter of adding an extra dimension to our points and vectors: 3D coordinates 3D coordinate systems can be left or right handed.

The Viewing Pipeline adaptation of Paul Bunn & Kerryn Hugo s notes

The Viewing Pipeline adaptation of Paul Bunn & Kerryn Hugo s notes What is it? The viewing pipeline is the procession of operations that are applied to the OpenGL matrices, in order to create a 2D representation

6.837 Introduction to Computer Graphics Assignment 5: OpenGL and Solid Textures Due Wednesday October 22, 2003 at 11:59pm

6.837 Introduction to Computer Graphics Assignment 5: OpenGL and Solid Textures Due Wednesday October 22, 2003 at 11:59pm In this assignment, you will add an interactive preview of the scene and solid

How do we draw a picture?

1 How do we draw a picture? Define geometry. Now what? We can draw the edges of the faces. Wireframe. We can only draw the edges of faces that are visible. We can fill in the faces. Giving each object

OpenGL: Setup 3D World

CT4510: Computer Graphics OpenGL: Setup 3D World BOCHANG MOON Prerequisite for 3D World Understanding on basic mathematical background, transformations, and spaces Pixels, raster image, ector, matrix,

graphics pipeline computer graphics graphics pipeline 2009 fabio pellacini 1

graphics pipeline computer graphics graphics pipeline 2009 fabio pellacini 1 graphics pipeline sequence of operations to generate an image using object-order processing primitives processed one-at-a-time

graphics pipeline computer graphics graphics pipeline 2009 fabio pellacini 1

graphics pipeline computer graphics graphics pipeline 2009 fabio pellacini 1 graphics pipeline sequence of operations to generate an image using object-order processing primitives processed one-at-a-time

3D Polygon Rendering. Many applications use rendering of 3D polygons with direct illumination

Rendering Pipeline 3D Polygon Rendering Many applications use rendering of 3D polygons with direct illumination 3D Polygon Rendering What steps are necessary to utilize spatial coherence while drawing

Graphics Pipeline. CS535 Fall Daniel G. Aliaga Department of Computer Science Purdue University

Graphics Pipeline CS535 Fall 2016 Daniel G. Aliaga Department of Computer Science Purdue University Ray-tracing Inverse mapping for every pixel construct a ray from the eye for every object in the scene

Computer Graphics with OpenGL ES (J. Han) Chapter VII Rasterizer

Chapter VII Rasterizer Rasterizer The vertex shader passes the clip-space vertices to the rasterizer, which performs the following: Clipping Perspective division Back-face culling Viewport transform Scan

Reading. 18. Projections and Z-buffers. Required: Watt, Section , 6.3, 6.6 (esp. intro and subsections 1, 4, and 8 10), Further reading:

Reading Required: Watt, Section 5.2.2 5.2.4, 6.3, 6.6 (esp. intro and subsections 1, 4, and 8 10), Further reading: 18. Projections and Z-buffers Foley, et al, Chapter 5.6 and Chapter 6 David F. Rogers

CS 4204 Computer Graphics

CS 4204 Computer Graphics 3D Viewing and Projection Yong Cao Virginia Tech Objective We will develop methods to camera through scenes. We will develop mathematical tools to handle perspective projection.

CS 381 Computer Graphics, Fall 2008 Midterm Exam Solutions. The Midterm Exam was given in class on Thursday, October 23, 2008.

CS 381 Computer Graphics, Fall 2008 Midterm Exam Solutions The Midterm Exam was given in class on Thursday, October 23, 2008. 1. [4 pts] Drawing Where? Your instructor says that objects should always be

CEng 477 Introduction to Computer Graphics Fall 2007

Visible Surface Detection CEng 477 Introduction to Computer Graphics Fall 2007 Visible Surface Detection Visible surface detection or hidden surface removal. Realistic scenes: closer objects occludes the

CSE 167: Introduction to Computer Graphics Lecture #8: Textures. Jürgen P. Schulze, Ph.D. University of California, San Diego Spring Quarter 2016

CSE 167: Introduction to Computer Graphics Lecture #8: Textures Jürgen P. Schulze, Ph.D. University of California, San Diego Spring Quarter 2016 Announcements Project 2 due this Friday Midterm next Tuesday

COMP3421. Introduction to 3D Graphics

COMP3421 Introduction to 3D Graphics 3D coodinates Moving to 3D is simply a matter of adding an extra dimension to our points and vectors: 3D coordinates 3D coordinate systems can be left or right handed.

CS 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.

Orthogonal Projection Matrices. Angel and Shreiner: Interactive Computer Graphics 7E Addison-Wesley 2015

Orthogonal Projection Matrices 1 Objectives Derive the projection matrices used for standard orthogonal projections Introduce oblique projections Introduce projection normalization 2 Normalization Rather

Announcements. Written Assignment 2 is out see the web page. Computer Graphics

Announcements Written Assignment 2 is out see the web page 1 Texture and other Mappings Shadows Texture Mapping Bump Mapping Displacement Mapping Environment Mapping Watt Chapter 8 COMPUTER GRAPHICS 15-462

Books, OpenGL, GLUT, GLUI, CUDA, OpenCL, OpenCV, PointClouds, and G3D

Books, OpenGL, GLUT, GLUI, CUDA, OpenCL, OpenCV, PointClouds, and G3D CS334 Spring 2012 Daniel G. Aliaga Department of Computer Science Purdue University Computer Graphics Pipeline Geometric Primitives

CSE 167: Lecture #4: Vertex Transformation. Jürgen P. Schulze, Ph.D. University of California, San Diego Fall Quarter 2012

CSE 167: Introduction to Computer Graphics Lecture #4: Vertex Transformation Jürgen P. Schulze, Ph.D. University of California, San Diego Fall Quarter 2012 Announcements Project 2 due Friday, October 12

9. Illumination and Shading Approaches for visual realism: - Remove hidden surfaces - Shade visible surfaces and reproduce shadows - Reproduce surface properties Texture Degree of transparency Roughness,

3D Graphics Pipeline II Clipping. Instructor Stephen J. Guy

3D Graphics Pipeline II Clipping Instructor Stephen J. Guy 3D Rendering Pipeline (for direct illumination) 3D Geometric Primitives 3D Model Primitives Modeling Transformation 3D World Coordinates Lighting

For each question, indicate whether the statement is true or false by circling T or F, respectively.

True/False For each question, indicate whether the statement is true or false by circling T or F, respectively. 1. (T/F) Rasterization occurs before vertex transformation in the graphics pipeline. 2. (T/F)

CS451Real-time Rendering Pipeline

1 CS451Real-time Rendering Pipeline JYH-MING LIEN DEPARTMENT OF COMPUTER SCIENCE GEORGE MASON UNIVERSITY Based on Tomas Akenine-Möller s lecture note You say that you render a 3D 2 scene, but what does

Computer Graphics I Lecture 11

15-462 Computer Graphics I Lecture 11 Midterm Review Assignment 3 Movie Midterm Review Midterm Preview February 26, 2002 Frank Pfenning Carnegie Mellon University http://www.cs.cmu.edu/~fp/courses/graphics/

Introduction to 3D Graphics with OpenGL. Z-Buffer Hidden Surface Removal. Binghamton University. EngiNet. Thomas J. Watson

Binghamton University EngiNet State University of New York EngiNet Thomas J. Watson School of Engineering and Applied Science WARNING All rights reserved. No Part of this video lecture series may be reproduced

Today. Rendering pipeline. Rendering pipeline. Object vs. Image order. Rendering engine Rendering engine (jtrt) Computergrafik. Rendering pipeline

Computergrafik Today Rendering pipeline s View volumes, clipping Viewport Matthias Zwicker Universität Bern Herbst 2008 Rendering pipeline Rendering pipeline Hardware & software that draws 3D scenes on

Graphics for VEs. Ruth Aylett

Graphics for VEs Ruth Aylett Overview VE Software Graphics for VEs The graphics pipeline Projections Lighting Shading Runtime VR systems Two major parts: initialisation and update loop. Initialisation

- 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,

RASTERISED RENDERING

DH2323 DGI16 INTRODUCTION TO COMPUTER GRAPHICS AND INTERACTION RASTERISED RENDERING Christopher Peters HPCViz, KTH Royal Institute of Technology, Sweden chpeters@kth.se http://kth.academia.edu/christopheredwardpeters

TSBK03 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

3D Programming. 3D Programming Concepts. Outline. 3D Concepts. 3D Concepts -- Coordinate Systems. 3D Concepts Displaying 3D Models

3D Programming Concepts Outline 3D Concepts Displaying 3D Models 3D Programming CS 4390 3D Computer 1 2 3D Concepts 3D Model is a 3D simulation of an object. Coordinate Systems 3D Models 3D Shapes 3D Concepts

COMP3421. Introduction to 3D Graphics

COMP3421 Introduction to 3D Graphics 3D coordinates Moving to 3D is simply a matter of adding an extra dimension to our points and vectors: 3D coordinates 3D coordinate systems can be left or right handed.

The 3D Graphics Rendering Pipeline

The 3D Graphics Rendering Pipeline Animação e Visualização Tridimensional João Madeiras Pereira Which Visualization? Interactive Real-Time Rendering 3D scenes Realism Real-Time Interaction Application

OpenGL. Toolkits.

http://www.opengl.org OpenGL Open Graphics Library Graphics API Delivered with UNIX, Win9x/2000/Me/Nt/Xp, Mac OS Direct3D (DirectX) is only Windows Utilizes the window system and event handling of the

Lecture 4 Advanced Computer Graphics (CS & SE )

Lecture 4 Advanced Computer Graphics (CS & SE 233.420) Topics Covered Animation Matrices Viewing Lighting Animating Interactive Programs Consider planet.c Want to animate rotating the Earth around the

Announcements. Submitting Programs Upload source and executable(s) (Windows or Mac) to digital dropbox on Blackboard

Now Playing: Vertex Processing: Viewing Coulibaly Amadou & Mariam from Dimanche a Bamako Released August 2, 2005 Rick Skarbez, Instructor COMP 575 September 27, 2007 Announcements Programming Assignment

Chapter 7 - Light, Materials, Appearance

Chapter 7 - Light, Materials, Appearance Types of light in nature and in CG Shadows Using lights in CG Illumination models Textures and maps Procedural surface descriptions Literature: E. Angel/D. Shreiner,

Graphics for VEs. Ruth Aylett

Graphics for VEs Ruth Aylett Overview VE Software Graphics for VEs The graphics pipeline Projections Lighting Shading VR software Two main types of software used: off-line authoring or modelling packages

Chapter 5. Projections and Rendering

Chapter 5 Projections and Rendering Topics: Perspective Projections The rendering pipeline In order to view manipulate and view a graphics object we must find ways of storing it a computer-compatible way.

CS 591B Lecture 9: The OpenGL Rendering Pipeline

CS 591B Lecture 9: The OpenGL Rendering Pipeline 3D Polygon Rendering Many applications use rendering of 3D polygons with direct illumination Spring 2007 Rui Wang 3D Polygon Rendering Many applications

CS 112 The Rendering Pipeline. Slide 1

CS 112 The Rendering Pipeline Slide 1 Rendering Pipeline n Input 3D Object/Scene Representation n Output An image of the input object/scene n Stages (for POLYGON pipeline) n Model view Transformation n

Shadow Algorithms. CSE 781 Winter Han-Wei Shen

Shadow Algorithms CSE 781 Winter 2010 Han-Wei Shen Why Shadows? Makes 3D Graphics more believable Provides additional cues for the shapes and relative positions of objects in 3D What is shadow? Shadow:

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

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

Advanced Lighting Techniques Due: Monday November 2 at 10pm

CMSC 23700 Autumn 2015 Introduction to Computer Graphics Project 3 October 20, 2015 Advanced Lighting Techniques Due: Monday November 2 at 10pm 1 Introduction This assignment is the third and final part

CSE 167: Introduction to Computer Graphics Lecture #6: Lights. Jürgen P. Schulze, Ph.D. University of California, San Diego Fall Quarter 2014

CSE 167: Introduction to Computer Graphics Lecture #6: Lights Jürgen P. Schulze, Ph.D. University of California, San Diego Fall Quarter 2014 Announcements Project 2 due Friday, Oct. 24 th Midterm Exam

CS 354R: Computer Game Technology

CS 354R: Computer Game Technology Texture and Environment Maps Fall 2018 Texture Mapping Problem: colors, normals, etc. are only specified at vertices How do we add detail between vertices without incurring

Graphics Pipeline & APIs

Graphics Pipeline & APIs CPU Vertex Processing Rasterization Fragment Processing glclear (GL_COLOR_BUFFER_BIT GL_DEPTH_BUFFER_BIT); glpushmatrix (); gltranslatef (-0.15, -0.15, solidz); glmaterialfv(gl_front,

Hidden surface removal. Computer Graphics

Lecture Hidden Surface Removal and Rasterization Taku Komura Hidden surface removal Drawing polygonal faces on screen consumes CPU cycles Illumination We cannot see every surface in scene We don t want

Module 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

CSE4030 Introduction to Computer Graphics

CSE4030 Introduction to Computer Graphics Dongguk University Jeong-Mo Hong Timetable 00:00~00:10 Introduction (English) 00:10~00:50 Topic 1 (English) 00:50~00:60 Q&A (English, Korean) 01:00~01:40 Topic

CS559 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

CS 464 Review. Review of Computer Graphics for Final Exam

CS 464 Review Review of Computer Graphics for Final Exam Goal: Draw 3D Scenes on Display Device 3D Scene Abstract Model Framebuffer Matrix of Screen Pixels In Computer Graphics: If it looks right then

() Illumination and Shading Dr. Ayman Eldeib Lighting So given a 3-D triangle and a 3-D viewpoint, we can set the right pixels But what color should those pixels be? If we re attempting to create a realistic

Visible-Surface Detection Methods. Chapter? Intro. to Computer Graphics Spring 2008, Y. G. Shin

Visible-Surface Detection Methods Chapter? Intro. to Computer Graphics Spring 2008, Y. G. Shin The Visibility Problem [Problem Statement] GIVEN: a set of 3-D surfaces, a projection from 3-D to 2-D screen,

CS 130 Exam I. Fall 2015

S 3 Exam I Fall 25 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

VISIBILITY & CULLING. Don t draw what you can t see. Thomas Larsson, Afshin Ameri DVA338, Spring 2018, MDH

VISIBILITY & CULLING Don t draw what you can t see. Thomas Larsson, Afshin Ameri DVA338, Spring 2018, MDH Visibility Visibility Given a set of 3D objects, which surfaces are visible from a specific point

Books, OpenGL, GLUT, CUDA, OpenCL, OpenCV, PointClouds, G3D, and Qt

Books, OpenGL, GLUT, CUDA, OpenCL, OpenCV, PointClouds, G3D, and Qt CS334 Fall 2015 Daniel G. Aliaga Department of Computer Science Purdue University Books (and by now means complete ) Interactive Computer

Last Time? The Traditional Graphics Pipeline Participating Media Measuring BRDFs 3D Digitizing & Scattering BSSRDFs Monte Carlo Simulation Dipole Approximation Today Ray Casting / Tracing Advantages? Ray

Computer 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:

Illumination and Shading Illumination (Lighting)! Model the interaction of light with surface points to determine their final color and brightness! The illumination can be computed either at vertices or

Interactive Computer Graphics A TOP-DOWN APPROACH WITH SHADER-BASED OPENGL

International Edition Interactive Computer Graphics A TOP-DOWN APPROACH WITH SHADER-BASED OPENGL Sixth Edition Edward Angel Dave Shreiner Interactive Computer Graphics: A Top-Down Approach with Shader-Based

Graphics Hardware and Display Devices

Graphics Hardware and Display Devices CSE328 Lectures Graphics/Visualization Hardware Many graphics/visualization algorithms can be implemented efficiently and inexpensively in hardware Facilitates interactive

Graphics Hardware and OpenGL

Graphics Hardware and OpenGL Ubi Soft, Prince of Persia: The Sands of Time What does graphics hardware have to do fast? Camera Views Different views of an object in the world 1 Camera Views Lines from

From Graphics to Visualization

From Graphics to Visualization Introduction Light Sources Surface Lighting Effects Basic (Local ) Illumination Models Polgon-Rendering Methods Texture Mapping Transparenc and Blending Visualization Pipeline

Today 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

Graphics Pipeline & APIs

3 2 4 Graphics Pipeline & APIs CPU Vertex Processing Rasterization Processing glclear (GL_COLOR_BUFFER_BIT GL_DEPTH_BUFFER_BIT); glpushmatrix (); gltranslatef (-0.15, -0.15, solidz); glmaterialfv(gl_front,

Hidden Surfaces II. Week 9, Mon Mar 15

University of British Columbia CPSC 314 Computer Graphics Jan-Apr 2010 Tamara Munzner Hidden Surfaces II Week 9, Mon Mar 15 http://www.ugrad.cs.ubc.ca/~cs314/vjan2010 ews yes, I'm granting the request

Advanced Rendering Techniques Lecture Rendering Pipeline (Part I) Professor Leandro Augusto Frata Fernandes laffernandes@ic.uff.br Lecture notes available in http://www.ic.uff.br/~laffernandes/teaching/0./topicos_rendering