Lecture 3. Programming with OpenGL GLUT + GLEW. CS 354 Computer Graphics Sunday, January 20, 13
|
|
- Christal Owen
- 11 months ago
- Views:
Transcription
1 Lecture 3 Programming with OpenGL GLUT + GLEW
2 OpenGL The success of GL lead to OpenGL (1992), a platform-independent API that was - Easy to use - Close enough to the hardware to get excellent performance - Focus on rendering - Omitted windowing and input to avoid window system dependencies
3 OpenGL evolution Originally controlled by an Architectural Review Board (ARB) - Members included SGI, Microsoft, Nvidia, HP, 3DLabs, IBM,. - Now Kronos Group - Was relatively stable (through version 2.5) Backward compatible Evolution reflected new hardware capabilities 3D texture mapping and texture objects Vertex and fragment programs - Allows platform specific features through extensions
4 Modern OpenGL Performance is achieved by using GPU rather than CPU Control GPU through programs called shaders Application s job is to send data to GPU GPU does all rendering
5 OpenGL 3.1 Totally shader-based - No default shaders - Each application must provide both a vertex and a fragment shader No immediate mode Few state variables Most 2.5 functions deprecated Backward compatibility not required
6 OpenGL: Other Versions OpenGL ES - Embedded systems - Version 1.0 simplified OpenGL Version 2.0 simplified OpenGL 3.1 Shader based WebGL - Javascript implementation of ES Supported on newer browsers OpenGL 4.1 and Add geometry shaders and tessellator
7 What about Direct X? Windows only Advantages - Better control of resources - Access to high level functionality Disadvantages - New versions not backward compatible - Windows only Recent advances in shaders are leading to convergence with OpenGL
8 OpenGL Libraries OpenGL core library - OpenGL32 on Windows - GL on most unix/linux systems (libgl.a) OpenGL Utility Library (GLU) - Provides functionality in OpenGL core but avoids having to rewrite code Links with window system - GLX for X window systems - WGL for Windows - AGL for Macintosh
9 GLUT OpenGL Utility Toolkit (GLUT) - Provides functionality common to all window systems Open a window Get input from mouse and keyboard Menus Event-driven - Code is portable but GLUT lacks the functionality of a good toolkit for a specific platform No slide bars
10 freeglut GLUT was created long ago and has been unchanged - Amazing that it works with OpenGL Some functionality can t work since it requires deprecated functions freeglut updates GLUT - Added capabilities - Context checking
11 GLEW OpenGL Extension Wrangler Library Makes it easy to access OpenGL extensions available on a particular system Avoids having to have specific entry points in Windows code Application needs only to include glew.h and run a glewinit()
12 Software Organization
13 OpenGL Architecture Immediate Mode geometry pipeline Polynomial Evaluator Per Vertex Operations & Primitive Assembly CPU Display List Rasterization Per Fragment Operations Frame Buffer Pixel Operations Texture Memory
14 OpenGL Functions Primitives - Points - Line Segments - Polygons Attributes Transformations - Viewing - Modeling Control (GLUT) Input (GLUT) Query
15 OpenGL State OpenGL is a state machine OpenGL functions are of two types - Primitive generating Can cause output if primitive is visible How vertices are processed and appearance of primitive are controlled by the state - State changing Transformation functions Attribute functions Under 3.1 most state variables are defined by the application and sent to the shaders
16 Not Object Oriented OpenGL is not object oriented so that there are multiple functions for a given logical function -gluniform3f -gluniform2i -gluniform3dv Underlying storage mode is the same Easy to create overloaded functions in C++ but issue is efficiency
17 OpenGL Function Format function name dimensions gluniform3f(x,y,z) belongs to GL library x,y,z are floats gluniform3fv(p) p is a pointer to an array
18 OpenGL #defines Most constants are defined in the include files gl.h, glu.h and glut.h - Note #include <GL/glut.h> should automatically include the others - Examples -glenable(gl_depth_test) -glclear(gl_color_buffer_bit) include files also define OpenGL data types: GLfloat, GLdouble,.
19 OpenGL and GLSL Shader based OpenGL is based less on a state machine model than a data flow model Most state variables, attributes and related pre 3.1 OpenGL functions have been deprecated Action happens in shaders Job is application is to get data to GPU
20 GLSL OpenGL Shading Language C-like with - Matrix and vector types (2, 3, 4 dimensional) - Overloaded operators - C++ like constructors Similar to Nvidia s Cg and Microsoft HLSL Code sent to shaders as source code New OpenGL functions to compile, link and get information to shaders
21 A Simple Program (?) Generate a square on a solid background
22 It used to be easy (Simple.c) #include <GL/glut.h> void mydisplay(){ glclear(gl_color_buffer_bit); glbegin(gl_polygon); glvertex2f(-0.5, -0.5); glvertex2f(-0.5, 0.5); glvertex2f(0.5, 0.5); glvertex2f(0.5, -0.5); glend(); glflush(); } int main(int argc, char** argv){ glutcreatewindow("simple"); glutdisplayfunc(mydisplay); glutmainloop(); }
23 What Happened? Most OpenGL functions deprecated Makes heavy use of state variable default values that no longer exist - Viewing - Colors - Window parameters Next version will make the defaults more explicit However, processing loop is the same
24 Simple.c #include <GL/glut.h> void mydisplay(){ glclear(gl_color_buffer_bit); // need to fill in this part // and add in shaders } int main(int argc, char** argv){ glutcreatewindow("simple"); glutdisplayfunc(mydisplay); glutmainloop(); }
25 Event Loop Note that the program defines a display callback function named mydisplay - Every glut program must have a display callback - The display callback is executed whenever OpenGL decides the display must be refreshed, for example when the window is opened - The main function ends with the program entering an event loop
26 Compilation Notes See website and starter code of Project 1 for example Unix/linux - Include files usually in /include/gl - Compile with lglut lglu lgl loader flags - May have to add L flag for X libraries - Mesa implementation included with most linux distributions - Check web for latest versions of Mesa and GLUT
27 OpenGL Program Structure Most OpenGL programs have a similar structure that consists of the following functions -main(): specifies the callback functions opens one or more windows with the required properties enters event loop (last executable statement) -init(): sets the state variables Viewing Attributes -initshader():read, compile and link shaders - callbacks Display function Input and window functions
28 Simple.c (revisited) main() function is the same - Mostly GLUT functions init() will allow more flexible colors initshader() will hides details of setting up shaders for now Key issue is that we must form a data array to send to GPU and then render it
29 main.c #include <GL/glew.h> #include <GL/glut.h> includes gl.h int main(int argc, char** argv) { glutinit(&argc,argv); glutinitdisplaymode(glut_single GLUT_RGB); glutinitwindowsize(500,500); glutinitwindowposition(0,0); glutcreatewindow("simple"); glutdisplayfunc(mydisplay); glewinit(); init(); glutmainloop(); } specify window properties set OpenGL state and initialize shaders enter event loop display callback
30 GLUT functions glutinit allows application to get command line arguments and initializes system gluinitdisplaymode requests properties for the window (the rendering context) - RGB color - Single buffering - Properties logically ORed together glutwindowsize in pixels glutwindowposition from top-left corner of display glutcreatewindow create window with title simple glutdisplayfunc display callback glutmainloop enter infinite event loop
31 Immediate Mode Graphics Geometry specified by vertices - Locations in space( 2 or 3 dimensional) - Points, lines, circles, polygons, curves, surfaces Immediate mode - Each time a vertex is specified in application, its location is sent to the GPU - Old style uses glvertex - Creates bottleneck between CPU and GPU - Removed from OpenGL 3.1
32 Retained Mode Graphics Put all vertex and attribute data in array Send array to GPU to be rendered immediately Almost OK but problem is we would have to send array over each time we need another render of it Better to send array over and store on GPU for multiple renderings
33 Display Callback Once we get data to GLU, we can initiate the rendering with a simple callback void mydisplay() { glclear(gl_color_buffer_bit); gldrawarrays(gl_triangles, 0, 3); glflush(); } Arrays are buffer objects that contain vertex arrays
34 Vertex Arrays Vertices can have many attributes - Position - Color - Texture Coordinates - Application data A vertex array holds these data Using types in vec.h point2 vertices[3] = {point2(0.0, 0.0), point2( 0.0, 1.0), point2(1.0, 1.0)};
35 Vertex Array Object Bundles all vertex data (positions, colors,..,) Get name for buffer then bind Glunit abuffer; glgenvertexarrays(1, &abuffer); glbindvertexarray(abuffer); At this point we have a current vertex array but no contents Use of glbindvertexarray lets us switch between VBOs
36 Buffer Object Buffers objects allow us to transfer large amounts of data to the GPU Need to create, bind and identify data Gluint buffer; glgenbuffers(1, &buffer); glbindbuffer(gl_array_buffer, buffer); glbufferdata(gl_array_buffer, sizeof(points), points); Data in current vertex array is sent to GPU
37 Initialization Vertex array objects and buffer objects can be set up on init() Also set clear color and other OpeGL parameters Also set up shaders as part of initialization - Read - Compile - Link First let s consider a few other issues
38 Coordinate Systems in OpenGL The units in points are determined by the application and are called object, world, model or problem coordinates Viewing specifications usually are also in object coordinates Eventually pixels will be produced in window coordinates OpenGL also uses some internal representations that usually are not visible to the application but are important in the shaders
39 OpenGL Camera I OpenGL places a camera at the origin in object space pointing in the negative z direction The default viewing volume is a box centered at the origin with a side of length 2
40 Orthographic Viewing In the default orthographic view, points are projected forward along the z axis onto the plane z=0 z=0 z=0
41 Transformations & Viewing In OpenGL, projection is carried out by a projection matrix (transformation) Transformation functions are also used for changes in coordinate systems Pre 3.0 OpenGL had a set of transformation functions which have been deprecated Three choices - Application code - GLSL functions - vec.h and mat.h
42 OpenGL Geometry Primitives GL_POINTS GL_LINES GL_LINE_STRIP GL_LINE_LOOP GL_TRIANGLES GL_TRIANGLE_STRIP GL_TRIANGLE_FAN
43 Polygons in OpenGL OpenGL will only display triangles - Simple: edges cannot cross - Convex: All points on line segment between two points in a polygon are also in the polygon - Flat: all vertices are in the same plane Application program must tessellate a polygon into triangles (triangulation) OpenGL 4.1 contains a tessellator
44 Polygons Testing Conceptually simple to test for simplicity and convexity Time consuming Earlier versions assumed both and left testing to the application Present version only renders triangles Need algorithm to triangulate an arbitrary polygon
45 Polygons Testing Long thin triangles render badly Equilateral triangles render well Maximize minimum angle Delaunay triangulation for unstructured points
46 Triangulations Convex polygon d c b a Start with abc, remove b, then acd,.
47 Non-convex (concave)
48 Convex Decomposition Find reflex vertices and split. Reflex vertex
49 Attributes Attributes determine the appearance of objects - Color (points, lines, polygons) - Size and width (points, lines) - Stipple pattern (lines, polygons) - Polygon mode Display as filled: solid color or stipple pattern Display edges Display vertices Only a few (glpointsize) are supported by OpenGL functions
50 RGB Color in OpenGL Each color component is stored separately in the frame buffer Usually 8 bits per component in buffer Color values can range from 0.0 (none) to 1.0 (all) using floats or over the range from 0 to 255 using unsigned bytels
51 Indexed Color in OpenGL Colors are indices into tables of RGB values Requires less memory - indices usually 8 bits - not as important now Memory inexpensive Need more colors for shading
52 Smooth Color in OpenGL Default is smooth shading - OpenGL interpolates vertex colors across visible polygons Alternative is flat shading - Color of first vertex determines fill color - Handle in shader
53 Setting Colors Colors are ultimately set in the fragment shader but can be determined in either shader or in the application Application color: pass to vertex shader as a uniform variable or as a vertex attribute Vertex shader color: pass to fragment shader as varying variable Fragment color: can alter via shader code
54 Vertex Shader Applications Moving vertices - Morphing - Wave motion - Fractals Lighting - More realistic models - Cartoon shaders
55 Fragment Shader Applications Per fragment lighting calculations per vertex lighting per fragment lighting
56 Fragment Shader Applications Texture mapping smooth shading environment mapping bump mapping
57 Writing Shader Applications First programmable shaders were programmed in an assembly-like manner OpenGL extensions added for vertex and fragment shaders Cg (C for graphics) C-like language for programming shaders - Works with both OpenGL and DirectX - Interface to OpenGL complex OpenGL Shading Language (GLSL)
58 Simple Shader in vec4 vposition; void main(void) { gl_position = vposition; }
59 Execution Model Vertex data Shader Program GPU Application Program gldrawarrays Vertex Shader Vertex Primitive Assembly Graphics, 6 th Ed., 2012 Addison 9 Wesley
60 Simple Fragment Program void main(void) { gl_fragcolor = vec4(1.0, 0.0, 0.0, 1.0); } Graphics, 6 th Ed., 2012 Addison 10 Wesley
61 Execution Model Shader Program Application Rasterizer Fragment Shader Frame Buffer Fragment Fragment Color Graphics, 6 th Ed., 2012 Addison 11 Wesley
62 Data Types C types: int, float, bool Vectors: - float vec2, vec3, vec4 - Also int (ivec) and boolean (bvec) Matrices: mat2, mat3, mat4 - Stored by columns - Standard referencing m[row] [column] C++ style constructors - vec3 a =vec3(1.0, 2.0, 3.0) - vec2 b = vec2(a) Graphics, 6 th Ed., 2012 Addison 12 Wesley
63 Pointers There are no pointers in GLSL We can use C structs which can be copied back from functions Because matrices and vectors are basic types they can be passed into and output from GLSL functions, e.g. mat3 func(mat3 a) Graphics, 6 th Ed., 2012 Addison 13 Wesley
64 Qualifiers GLSL has many of the same qualifiers such as const as C/C++ Need others due to the nature of the execution model Variables can change - Once per primitive - Once per vertex - Once per fragment - At any time in the application Vertex attributes are interpolated by the rasterizer into fragment attributes Graphics, 6 th Ed., 2012 Addison 14 Wesley
65 Attribute Qualifier Attribute-qualified variables can change at most once per vertex There are a few built in variables such as gl_position but most have been deprecated User defined (in application program) - Use in qualifier to get to shader -in float temperature -in vec3 velocity Graphics, 6 th Ed., 2012 Addison 15 Wesley
66 Uniform Qualified Variables that are constant for an entire primitive Can be changed in application and sent to shaders Cannot be changed in shader Used to pass information to shader such as the bounding box of a primitive Graphics, 6 th Ed., 2012 Addison 16 Wesley
67 Varying Qualified Variables that are passed from vertex shader to fragment shader Automatically interpolated by the rasterizer Old style used the varying qualifier varying vec4 color; Now use out in vertex shader and in in the fragment shader out vec4 color; Graphics, 6 th Ed., 2012 Addison 17 Wesley
68 Example: Vertex Shader const vec4 red = vec4(1.0, 0.0, 0.0, 1.0); out vec3 color_out; void main(void) { gl_position = vposition; color_out = red; } Graphics, 6 th Ed., 2012 Addison 18 Wesley
69 Required Fragment Shader in vec3 color_out; void main(void) { gl_fragcolor = color_out; } // in latest version use form // out vec4 fragcolor; // fragcolor = color_out; Graphics, 6 th Ed., 2012 Addison 19 Wesley
70 Passing values call by value-return Variables are copied in Returned values are copied back Three possibilities - in - out - inout (deprecated) Graphics, 6 th Ed., 2012 Addison 20 Wesley
71 Operators and Functions Standard C functions - Trigonometric - Arithmetic - Normalize, reflect, length Overloading of vector and matrix types mat4 a; vec4 b, c, d; c = b*a; // a column vector stored as a 1d array d = a*b; // a row vector stored as Graphics, 6 th Ed., 2012 Addison 21 Wesley
72 Swizzling and Selection Can refer to array elements by element using [] or selection (.) operator with - x, y, z, w - r, g, b, a - s, t, p, q -a[2], a.b, a.z, a.p are the same Swizzling operator lets us manipulate components vec4 a; a.yz = vec2(1.0, 2.0); Graphics, 6 th Ed., 2012 Addison 22 Wesley
73 Linking Shaders with Application Read shaders Compile shaders Create a program object Link everything together Link variables in application with variables in shaders - Vertex attributes - Uniform variables E. Angel and D. Shreiner: Interactive Computer Graphics 6E Addison-Wesley Graphics, th Ed., 2012 Addison 3 Wesley
74 Program Object Container for shaders - Can contain multiple shaders - Other GLSL functions GLuint myprogobj; myprogobj = glcreateprogram(); /* define shader objects here */ gluseprogram(myprogobj); gllinkprogram(myprogobj); Graphics, 6 th Ed., 2012 Addison 4 Wesley
75 Reading a Shader Shaders are added to the program object and compiled Usual method of passing a shader is as a null-terminated string using the function glshadersource If the shader is in a file, we can write a reader to convert the file to a string Graphics, 6 th Ed., 2012 Addison 5 Wesley
76 Shader Reader #include <stdio.h> static char* readshadersource(const char* shaderfile) { FILE* fp = fopen(shaderfile, "r"); if ( fp == NULL ) { return NULL; } fseek(fp, 0L, SEEK_END); long size = ftell(fp); Graphics, 6 th Ed., 2012 Addison 6 Wesley
77 Shader Reader (cont) fseek(fp, 0L, SEEK_SET); char* buf = new char[size + 1]; fread(buf, 1, size, fp); buf[size] = '\0'; fclose(fp); return buf; } Graphics, 6 th Ed., 2012 Addison 7 Wesley
78 Adding a Vertex Shader GLuint vshader; GLunit myvertexobj; GLchar vshaderfile[] = my_vertex_shader ; GLchar* vsource = readshadersource(vshaderfile); glshadersource(myvertexobj, 1, &vertexshaderfile, NULL); myvertexobj = glcreateshader(gl_vertex_shader); glcompileshader(myvertexobj); glattachobject(myprogobj, myvertexobj); Graphics, 6 th Ed., 2012 Addison 8 Wesley
79 Vertex Attributes Vertex attributes are named in the shaders Linker forms a table Application can get index from table and tie it to an application variable Similar process for uniform variables Graphics, 6 th Ed., 2012 Addison 9 Wesley
80 Vertex Attribute Example #define BUFFER_OFFSET( offset ) ((GLvoid*) (offset)) GLuint loc = glgetattriblocation( program, "vposition" ); glenablevertexattribarray( loc ); glvertexattribpointer( loc, 2, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(0) ); Graphics, 6 th Ed., 2012 Addison 10 Wesley
81 Uniform Variable Example GLint angleparam; angleparam = glgetuniformlocation(myprogobj, "angle"); /* angle defined in shader */ /* my_angle set in application */ GLfloat my_angle; my_angle = 5.0 /* or some other value */ gluniform1f(angleparam, my_angle); Graphics, 6 th Ed., 2012 Addison 11 Wesley
82 Double Buffering Updating the value of a uniform variable opens the door to animating an application - Execute gluniform in display callback - Force a redraw through glutpostredisplay() Need to prevent a partially redrawn frame buffer from being displayed Draw into back buffer Display front buffer Swap buffers after updating finished Graphics, 6 th Ed., 2012 Addison 12 Wesley
83 Adding Double Buffering Request a double buffer - glutinitdisplaymode(glut_double) Swap buffers void mydisplay() { glclear( ); gldrawarrays(); glutswapbuffers(); } Graphics, 6 th Ed., 2012 Addison 13 Wesley
84 Idle Callback Idle callback specifies function to be executed when no other actions pending - glutidlefunc(myidle); void myidle() { // recompute display glutpostredisplay(); } Graphics, 6 th Ed., 2012 Addison 14 Wesley
85 Attribute and Varying Qualifiers Starting with GLSL 1.5 attribute and varying qualifiers have been replaced by in and out qualifiers No changes needed in application Vertex shader example: #version 1.4 attribute vec3 vposition; varying vec3 color; #version 1.5 in vec3 vposition; out vec3 color; Graphics, 6 th Ed., 2012 Addison 15 Wesley
86 Adding Color If we set a color in the application, we can send it to the shaders as a vertex attribute or as a uniform variable depending on how often it changes Let s associate a color with each vertex Set up an array of same size as positions Send to GPU as a vertex buffer object Graphics, 6 th Ed., 2012 Addison 16 Wesley
87 Setting Colors typedef vec3 color3; color3 base_colors[4] = {color3(1.0, ),. color3 colors[numvertices]; vec3 points[numvertices]; //in loop setting positions colors[i] = basecolors[color_index] position[i] =. Graphics, 6 th Ed., 2012 Addison 17 Wesley
88 Setting Up Buffer Object //need larger buffer glbufferdata(gl_array_buffer, sizeof(points) + sizeof(colors), NULL, GL_STATIC_DRAW); //load data separately glbuffersubdata(gl_array_buffer, 0, sizeof(points), points); glbuffersubdata(gl_array_buffer, sizeof(points), sizeof(colors), colors); Graphics, 6 th Ed., 2012 Addison 18 Wesley
89 Second Vertex Array // vposition and vcolor identifiers in vertex shader loc = glgetattriblocation(program, vposition ); glenablevertexattribarray(loc); glvertexattribpointer(loc, 3, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(0)); loc2 = glgetattriblocation(program, vcolor ); glenablevertexattribarray(loc2); glvertexattribpointer(loc2, 3, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(sizeofpoints)); Graphics, 6 th Ed., 2012 Addison 19 Wesley
90 Vertex Shader Applications Moving vertices - Morphing - Wave motion - Fractals Lighting - More realistic models - Cartoon shaders Graphics, 6 th Ed., 2012 Addison 20 Wesley
91 Wave Motion Vertex Shader in vec4 vposition; uniform float xs, zs, // frequencies uniform float h; // height scale void main() { vec4 t = vposition; t.y = vposition.y + h*sin(time + xs*vposition.x) + h*sin(time + zs*vposition.z); gl_position = t; } Graphics, 6 th Ed., 2012 Addison 21 Wesley
92 Particle System in vec3 vposition; uniform mat4 ModelViewProjectionMatrix; uniform vec3 init_vel; uniform float g, m, t; void main() { vec3 object_pos; object_pos.x = vposition.x + vel.x*t; object_pos.y = vposition.y + vel.y*t + g/(2.0*m)*t*t; object_pos.z = vposition.z + vel.z*t; gl_position = ModelViewProjectionMatrix*vec4(object_pos,1); } Graphics, 6 th Ed., 2012 Addison 22 Wesley
93 Pass Through Fragment Shader /* pass-through fragment shader */ in vec4 color; void main(void) { gl_fragcolor = color; } Graphics, 6 th Ed., 2012 Addison 23 Wesley
94 Vertex vs Fragment Lighting per vertex lighting per fragment lighting Graphics, 6 th Ed., 2012 Addison 24 Wesley
95 Fragment Shader Applications Texture mapping smooth shading environment mapping bump mapping Graphics, 6 th Ed., 2012 Addison 25 Wesley
96 Viewports Do not have use the entire window for the image: glviewport(x,y,w,h) Values in pixels (screen coordinates)
Programming with OpenGL Part 5: More GLSL. Ed Angel Professor Emeritus of Computer Science University of New Mexico
Programming with OpenGL Part 5: More GLSL Ed Angel Professor Emeritus of Computer Science University of New Mexico 1 Objectives Coupling shaders to applications - Reading - Compiling - Linking Vertex Attributes
Comp 410/510 Computer Graphics Spring Programming with OpenGL Part 3: Shaders
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)
Objectives. Programming with OpenGL Part 5: More GLSL. Program Object. Reading a Shader. Shader Reader. Linking Shaders with Application
Objectives Programming with OpenGL Part : More GLSL CS Interactive Computer Graphics Prof. David E. Breen Department of Computer Science Coupling shaders to applications - Reading - Compiling - Linking
Comp 410/510 Computer Graphics Spring Programming with OpenGL Part 2: First Program
Comp 410/510 Computer Graphics Spring 2017 Programming with OpenGL Part 2: First Program Objectives Refine the first program Introduce a standard program structure - Initialization Program Structure Most
OPEN GL BACKGROUND. Objectives. Early History of APIs. SGI and GL. PHIGS and X. Modified from Angel 6e book slides
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
Today s Agenda. Shaders fundamentals. Programming with shader-based OpenGL
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
Programming with OpenGL Part 1: Background
Programming with OpenGL Part 1: Background Ed Angel Professor of Computer Science, Electrical and Computer Engineering, and Media Arts University of New Mexico 1 Objectives Development of the OpenGL API
Objectives. Open GL Shading Language (GLSL)
Open GL Shading Language (GLSL) Objectives Shader applications Vertex shaders Fragment shaders Programming shaders Cg GLSL Coupling GLSL to Applications Example applications 1 Vertex Shader Applications
Introduction to OpenGL Week 1
CS 432/680 INTERACTIVE COMPUTER GRAPHICS Introduction to OpenGL Week 1 David Breen Department of Computer Science Drexel University Based on material from Ed Angel, University of New Mexico Objectives
Objectives. Image Formation Revisited. Physical Approaches. The Programmer s Interface. Practical Approach. Introduction to OpenGL Week 1
CS 432/680 INTERACTIVE COMPUTER GRAPHICS Introduction to OpenGL Week 1 David Breen Department of Computer Science Drexel University Objectives Learn the basic design of a graphics system Introduce graphics
Programming with OpenGL Part 2: Complete Programs Computer Graphics I, Fall
Programming with OpenGL Part 2: Complete Programs 91.427 Computer Graphics I, Fall 2008 1 1 Objectives Refine first program Alter default values Introduce standard program structure Simple viewing 2-D
Lecture 2 CISC440/640 Spring Department of Computer and Information Science
Lecture 2 CISC440/640 Spring 2015 Department of Computer and Information Science Today s Topic The secrets of Glut-tony 2 So let s do some graphics! For the next week or so this is your world: -1 1-1 1
Supplement to Lecture 22
Supplement to Lecture 22 Programmable GPUs Programmable Pipelines Introduce programmable pipelines - Vertex shaders - Fragment shaders Introduce shading languages - Needed to describe shaders - RenderMan
Models and Architectures. Angel and Shreiner: Interactive Computer Graphics 7E Addison-Wesley 2015
Models and Architectures 1 Objectives Learn the basic design of a graphics system Introduce pipeline architecture Examine software components for an interactive graphics system 2 Image Formation Revisited
Computer Graphics. Bing-Yu Chen National Taiwan University
Computer Graphics Bing-Yu Chen National Taiwan University Introduction to OpenGL General OpenGL Introduction An Example OpenGL Program Drawing with OpenGL Transformations Animation and Depth Buffering
Programming 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
Computer Graphics (CS 4731) OpenGL/GLUT(Part 1)
Computer Graphics (CS 4731) Lecture 2: Introduction to OpenGL/GLUT(Part 1) Prof Emmanuel Agu Computer Science Dept. Worcester Polytechnic Institute (WPI) Recall: OpenGL GLBasics OpenGL s function Rendering
Programming with OpenGL Part 1: Background
Programming with OpenGL Part 1: Background Ed Angel Professor of Computer Science, Electrical and Computer Engineering, and Media Arts University of New Mexico 1 Objectives Development of the OpenGL API
Programming 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
OpenGL pipeline Evolution and OpenGL Shading Language (GLSL) Part 2/3 Vertex and Fragment Shaders
OpenGL pipeline Evolution and OpenGL Shading Language (GLSL) Part 2/3 Vertex and Fragment Shaders Prateek Shrivastava CS12S008 shrvstv@cse.iitm.ac.in 1 GLSL Data types Scalar types: float, int, bool Vector
GLSL 1: Basics. J.Tumblin-Modified SLIDES from:
GLSL 1: Basics J.Tumblin-Modified SLIDES from: Ed Angel Professor of Computer Science, Electrical and Computer Engineering, and Media Arts Director, Arts Technology Center University of New Mexico and
GLSL II. Objectives. Coupling GLSL to Applications Example applications
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
Computer Graphics (CS 543) Lecture 1 (Part 2): Introduction to OpenGL/GLUT (Part 1)
Computer Graphics (CS 543) Lecture 1 (Part 2): Introduction to OpenGL/GLUT (Part 1) Prof Emmanuel Agu Computer Science Dept. Worcester Polytechnic Institute (WPI) OpenGL/GLUT Installation OpenGL: Specific
Graphics Programming
Graphics Programming 3 rd Week, 2011 OpenGL API (1) API (application programming interface) Interface between an application program and a graphics system Application Program OpenGL API Graphics Library
An Overview GLUT GLSL GLEW
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
CS450/550. Pipeline Architecture. Adapted From: Angel and Shreiner: Interactive Computer Graphics6E Addison-Wesley 2012
CS450/550 Pipeline Architecture Adapted From: Angel and Shreiner: Interactive Computer Graphics6E Addison-Wesley 2012 0 Objectives Learn the basic components of a graphics system Introduce the OpenGL pipeline
Drawing Primitives. OpenGL basics
CSC 706 Computer Graphics / Dr. N. Gueorguieva 1 OpenGL Libraries Drawing Primitives OpenGL basics OpenGL core library OpenGL32 on Windows GL on most unix/linux systems (libgl.a) OpenGL Utility Library
WebGL A quick introduction. J. Madeira V. 0.2 September 2017
WebGL A quick introduction J. Madeira V. 0.2 September 2017 1 Interactive Computer Graphics Graphics library / package is intermediary between application and display hardware Application program maps
OpenGL and GLUT. COMP413 Computer Graphics. School of Computer Sci. & Eng. Kyungpook National University, Korea. Spring Semester, 2016
OpenGL and GLUT COMP413 Computer Graphics School of Computer Sci. & Eng. Kyungpook National University, Korea Spring Semester, 2016 2007-2016 N Baek 1 Contents OpenGL Libraries OpenGL functions naming
CIS 441/541: Introduction to Computer Graphics Lecture 14: OpenGL Basics
CIS 441/541: Introduction to Computer Graphics Lecture 14: OpenGL Basics Oct. 26th, 2016 Hank Childs, University of Oregon Announcements OH Hank: Weds 1-2, Thursday 11-12 Dan: Weds 4-530, Thursday 930-11
Teacher Assistant : Tamir Grossinger Reception hours: by - Building 37 / office -102 Assignments: 4 programing using
Teacher Assistant : Tamir Grossinger email: tamirgr@gmail.com Reception hours: by email - Building 37 / office -102 Assignments: 4 programing using C++ 1 theoretical You can find everything you need in
3D Game Programming Programmable Pipelines. Ming-Te Chi Department of Computer Science, National Chengchi University
3D Game Programming Programmable Pipelines Ming-Te Chi Department of Computer Science, National Chengchi University Outline Programmable Pipelines(4ed CH15) (5th CH5) Vertex shaders Fragment shaders Introduce
Introduction to OpenGL
CS100433 Introduction to OpenGL Junqiao Zhao 赵君峤 Department of Computer Science and Technology College of Electronics and Information Engineering Tongji University Before OpenGL Let s think what is need
Objectives. Coupling GLSL to Applications Example applications
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
Building Models. CS 537 Interactive Computer Graphics Prof. David E. Breen Department of Computer Science
Building Models CS 537 Interactive Computer Graphics Prof. David E. Breen Department of Computer Science 1 Objectives Introduce simple data structures for building polygonal models - Vertex lists - Edge
CSE 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
CS452/552; EE465/505. Image Formation
CS452/552; EE465/505 Image Formation 1-15-15 Outline! Image Formation! Introduction to WebGL, continued Draw a colored triangle using WebGL Read: Angel, Chapters 2 & 3 Homework #1 will be available on
OpenGL refresher. Advanced Computer Graphics 2012
Advanced Computer Graphics 2012 What you will see today Outline General OpenGL introduction Setting up: GLUT and GLEW Elementary rendering Transformations in OpenGL Texture mapping Programmable shading
VR-programming tools (procedural) More VRML later in this course! (declarative)
Realtime 3D Computer Graphics & Virtual Reality OpenGL Introduction VR-programming Input and display devices are the main hardware interface to users Immersion embeds users through the generation of live-like
Lecture 4 of 41. Lab 1a: OpenGL Basics
Lab 1a: OpenGL Basics William H. Hsu Department of Computing and Information Sciences, KSU KSOL course pages: http://snipurl.com/1y5gc Course web site: http://www.kddresearch.org/courses/cis636 Instructor
2D graphics with WebGL
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
Interaction. CSCI 420 Computer Graphics Lecture 3
CSCI 420 Computer Graphics Lecture 3 Interaction Jernej Barbic University of Southern California Client/Server Model Callbacks Double Buffering Hidden Surface Removal Simple Transformations [Angel Ch.
Computer Graphics (CS 4731) OpenGL/GLUT (Part 2)
Computer Graphics (CS 4731) Lecture 3: Introduction to OpenGL/GLUT (Part 2) Prof Emmanuel Agu Computer Science Dept. Worcester Polytechnic Institute (WPI) Triangulation Generally OpenGL breaks polygonsdownintotriangles
Introduction to Computer Graphics with OpenGL/GLUT
Introduction to Computer Graphics with OpenGL/GLUT What is OpenGL? A software interface to graphics hardware Graphics rendering API (Low Level) High-quality color images composed of geometric and image
Lecture 3 Advanced Computer Graphics (CS & SE )
Lecture 3 Advanced Computer Graphics (CS & SE 233.420) Programming with OpenGL Program Structure Primitives Attributes and States Programming in three dimensions Inputs and Interaction Working with Callbacks
CS 4204 Computer Graphics
CS 4204 Computer Graphics OpenGL Basics Yong Cao Virginia Tech References: 2001 Siggraph, An Interactive Introduction to OpenGL Programming, Dave Shreiner,Ed Angel, Vicki Shreiner Official Presentation
CMSC 425: Lecture 4 More about OpenGL and GLUT Tuesday, Feb 5, 2013
CMSC 425: Lecture 4 More about OpenGL and GLUT Tuesday, Feb 5, 2013 Reading: See any standard reference on OpenGL or GLUT. Basic Drawing: In the previous lecture, we showed how to create a window in GLUT,
Objectives. Topic 4: OpenGL An Example Program. simple.cpp revisited. Defining Objects in OpenGL Programs. Build a complete OpenGL program
Tpic 4: OpenGL An Example Prgram Objectives Build a cmplete OpenGL prgram Initializatin steps and prgram structure GLUT functins Vertex array bjects and vertex buffer bjects Simple viewing Intrduce the
To Do. Computer Graphics (Fall 2008) Course Outline. Course Outline. Methodology for Lecture. Demo: Surreal (HW 3)
Computer Graphics (Fall 2008) COMS 4160, Lecture 9: OpenGL 1 http://www.cs.columbia.edu/~cs4160 To Do Start thinking (now) about HW 3. Milestones are due soon. Course Course 3D Graphics Pipeline 3D Graphics
Rendering. Part 1 An introduction to OpenGL
Rendering Part 1 An introduction to OpenGL Olivier Gourmel VORTEX Team IRIT University of Toulouse gourmel@irit.fr Image synthesis The Graphics Processing Unit (GPU): A highly parallel architecture specialized
Shaders. 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)?
Introduction to OpenGL. CSCI 4229/5229 Computer Graphics Fall 2012
Introduction to OpenGL CSCI 4229/5229 Computer Graphics Fall 2012 OpenGL by Example Learn OpenGL by reading nehe.gamedev.net Excellent free tutorial Code available for many platforms and languages OpenGL:
COMPUTER GRAPHICS LAB # 3
COMPUTER GRAPHICS LAB # 3 Chapter 2: COMPUTER GRAPHICS by F.S HILLs. Initial steps in drawing figures (polygon, rectangle etc) Objective: Basic understanding of simple code in OpenGL and initial steps
Computer Graphics. Making Pictures. Computer Graphics CSC470 1
Computer Graphics Making Pictures Computer Graphics CSC470 1 Getting Started Making Pictures Graphics display: Entire screen (a); windows system (b); [both have usual screen coordinates, with y-axis y
Assignment 1. Simple Graphics program using OpenGL
Assignment 1 Simple Graphics program using OpenGL In this assignment we will use basic OpenGL functions to draw some basic graphical figures. Example: Consider following program to draw a point on screen.
Basic Graphics Programming
CSCI 480 Computer Graphics Lecture 2 Basic Graphics Programming January 11, 2012 Jernej Barbic University of Southern California http://www-bcf.usc.edu/~jbarbic/cs480-s12/ Graphics Pipeline OpenGL API
CS 380 Introduction to Computer Graphics. LAB (1) : OpenGL Tutorial Reference : Foundations of 3D Computer Graphics, Steven J.
CS 380 Introduction to Computer Graphics LAB (1) : OpenGL Tutorial 2018. 03. 05 Reference : Foundations of 3D Computer Graphics, Steven J. Gortler Goals Understand OpenGL pipeline Practice basic OpenGL
Three Main Themes of Computer Graphics
Three Main Themes of Computer Graphics Modeling How do we represent (or model) 3-D objects? How do we construct models for specific objects? Animation How do we represent the motion of objects? How do
RECITATION - 1. Ceng477 Fall
RECITATION - 1 Ceng477 Fall 2007-2008 2/ 53 Agenda General rules for the course General info on the libraries GLUT OpenGL GLUI Details about GLUT Functions Probably we will not cover this part 3/ 53 General
Shaders. Introduction. OpenGL Grows via Extensions. OpenGL Extensions. OpenGL 2.0 Added Shaders. Shaders Enable Many New Effects
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
Programming with OpenGL Complete Programs Objectives Build a complete first program
Programming with OpenGL Complete Programs Objectives Build a complete first program Introduce shaders Introduce a standard program structure Simple viewing Two-dimensional viewing as a special case of
Computer Graphics, Chapt 08
Computer Graphics, Chapt 08 Creating an Image Components, parts of a scene to be displayed Trees, terrain Furniture, walls Store fronts and street scenes Atoms and molecules Stars and galaxies Describe
Copyright Khronos Group 2012 Page 1. Teaching GL. Dave Shreiner Director, Graphics and GPU Computing, ARM 1 December 2012
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
Precept 2 Aleksey Boyko February 18, 2011
Precept 2 Aleksey Boyko February 18, 2011 Getting started Initialization Drawing Transformations Cameras Animation Input Keyboard Mouse Joystick? Textures Lights Programmable pipeline elements (shaders)
11/1/13. Basic Graphics Programming. Teaching Assistant. What is OpenGL. Course Producer. Where is OpenGL used. Graphics library (API)
CSCI 420 Computer Graphics Lecture 2 Basic Graphics Programming Teaching Assistant Yijing Li Office hours TBA Jernej Barbic University of Southern California Graphics Pipeline OpenGL API Primitives: Lines,
CS 548: COMPUTER GRAPHICS INTRODUCTION TO OPENGL AND GLUT SPRING 2015 DR. MICHAEL J. REALE
CS 548: COMPUTER GRAPHICS INTRODUCTION TO OPENGL AND GLUT SPRING 2015 DR. MICHAEL J. REALE OVERVIEW OF LIBRARIES OPENGL CORE LIBRARY (OR BASIC LIBRARY) Hardware and platform independent Specification that
Computer Graphics (Basic OpenGL)
Computer Graphics (Basic OpenGL) Thilo Kielmann Fall 2008 Vrije Universiteit, Amsterdam kielmann@cs.vu.nl http://www.cs.vu.nl/ graphics/ Computer Graphics (Basic OpenGL, Input and Interaction), ((57))
Exercise 1 Introduction to OpenGL
Exercise 1 Introduction to OpenGL What we are going to do OpenGL Glut Small Example using OpenGl and Glut Alexandra Junghans 2 What is OpenGL? OpenGL Two Parts most widely used and supported graphics API
CS770/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
Announcements OpenGL. Computer Graphics. Spring CS4815
Computer Graphics Spring 2017-2018 Outline 1 2 Tutes and Labs Tute02, vector review (see matrix) Week02 lab Lab Marking 10 labs in total each lab worth 3% of overall grade marked on attendance and completion
CS Computer Graphics: OpenGL, Continued
CS 543 - Computer Graphics: OpenGL, Continued by Robert W. Lindeman gogo@wpi.edu (with help from Emmanuel Agu ;-) Last time. OpenGL set up Basic structure OpenGL skeleton Callback functions, etc. R.W.
CS Computer Graphics: OpenGL, Continued
CS 543 - Computer Graphics: OpenGL, Continued by Robert W. Lindeman gogo@wpi.edu (with help from Emmanuel Agu ;-) Last time. OpenGL set up Basic structure OpenGL skeleton Callback functions, etc. R.W.
Lecture 2 2D transformations Introduction to OpenGL
Lecture 2 2D transformations Introduction to OpenGL OpenGL where it fits what it contains how you work with it OpenGL parts: GL = Graphics Library (core lib) GLU = GL Utilities (always present) GLX, AGL,
Computer graphics MN1
Computer graphics MN1 http://www.opengl.org Todays lecture What is OpenGL? How do I use it? Rendering pipeline Points, vertices, lines,, polygons Matrices and transformations Lighting and shading Code
Philip Calderon CSE 520 Lab 3 Color Shader
Philip Calderon CSE 520 Lab 3 Color Shader Summary: The purpose of lab 4 is to produce a pyramid tetrahedron that we are able to rotate it when clicked. Part 1: Color Tetrahedron Part 2: Rotation to show
EECS 487: Interactive Computer Graphics
Integrating GLSL with OpenGL EECS 487: Interactive Computer Graphics Lecture 19: Integrating shaders with OpenGL program Vertex-array objects with shaders Miscellaneous shader related stuff Integrating
last time put back pipeline figure today will be very codey OpenGL API library of routines to control graphics calls to compile and load shaders
last time put back pipeline figure today will be very codey OpenGL API library of routines to control graphics calls to compile and load shaders calls to load vertex data to vertex buffers calls to load
COMP 371/4 Computer Graphics Week 1
COMP 371/4 Computer Graphics Week 1 Course Overview Introduction to Computer Graphics: Definition, History, Graphics Pipeline, and Starting Your First OpenGL Program Ack: Slides from Prof. Fevens, Concordia
This Lecture. Introduction to OpenGL. Outline. Why OpenGL? Programmer s View. Foundations of Computer Graphics
Foundations of Computer Graphics Overview and Motivation This Lecture Introduction to OpenGL and simple demo code mytest1.cpp ; you compiled mytest3.cpp for HW 0 I am going to show (and write) actual code
Lecture 09: Shaders (Part 1)
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
SHADER 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
CS 4731 Lecture 3: Introduction to OpenGL and GLUT: Part II. Emmanuel Agu
CS 4731 Lecture 3: Introduction to OpenGL and GLUT: Part II Emmanuel Agu Recall: OpenGL Skeleton void main(int argc, char** argv){ // First initialize toolkit, set display mode and create window glutinit(&argc,
Draw the basic Geometry Objects. Hanyang University
Draw the basic Geometry Objects Hanyang University VERTEX ATTRIBUTE AND GEOMETRIC PRIMITIVES Vertex Vertex A point in 3D space, or a corner of geometric primitives such as triangles, polygons. Vertex attributes
Announcements OpenGL. Computer Graphics. Autumn 2009 CS4815
Computer Graphics Autumn 2009 Outline 1 Labs 2 Labs Outline 1 Labs 2 Labs Labs Week02 lab Marking 8 10 labs in total each lab worth 2 3% of overall grade marked on attendance and completion of lab completed
API for creating a display window and using keyboard/mouse interations. See RayWindow.cpp to see how these are used for Assignment3
OpenGL Introduction Introduction OpenGL OpenGL is an API for computer graphics. Hardware-independent Windowing or getting input is not included in the API Low-level Only knows about triangles (kind of,
Using OpenGL with CUDA
Using OpenGL with CUDA Installing OpenGL and GLUT; compiling with nvcc Basics of OpenGL and GLUT in C Interoperability between OpenGL and CUDA OpenGL = Open Graphic Library creation of 3D graphic primitives
CS380: Computer Graphics Screen Space & World Space. Sung-Eui Yoon ( 윤성의 ) Course URL:
CS380: Computer Graphics Screen Space & World Space Sung-Eui Yoon ( 윤성의 ) Course URL: http://sglab.kaist.ac.kr/~sungeui/cg Class Objectives Understand different spaces and basic OpenGL commands Understand
OpenGL. Jimmy Johansson Norrköping Visualization and Interaction Studio Linköping University
OpenGL Jimmy Johansson Norrköping Visualization and Interaction Studio Linköping University Background Software interface to graphics hardware 250+ commands Objects (models) are built from geometric primitives
CS452/552; EE465/505. Review & Examples
CS452/552; EE465/505 Review & Examples 2-05 15 Outline Review and Examples:! Shaders, Buffers & Binding! Example: Draw 3 Triangles Vertex lists; gl.drawarrays( ) Edge lists: gl.drawelements( )! Example:
Objectives. OpenGL - Shaders. GLSL A Quick Review
OpenGL - Shaders CITS3003 Graphics & Animatin E. Angel and D. Shreiner: Interactive Cmputer Graphics 6E Addisn-Wesley 2012 1 Objectives The rendering pipeline and the shaders Data types, qualifiers, built-in
Programmable shader. Hanyang University
Programmable shader Hanyang University Objective API references (will be skipped) Examples Simple shader Phong shading shader INTRODUCTION GLSL(OPENGL SHADING LANGUAGE) Scalar Data types Structure Structures
Computer Graphics. Chapter 3 Computer Graphics Software
Computer Graphics Chapter 3 Computer Graphics Software Outline Graphics Software Packages Introduction to OpenGL Example Program 2 3 Graphics Software Software packages General Programming Graphics Packages
Project Sketchpad. Ivan Sutherland (MIT 1963) established the basic interactive paradigm that characterizes interactive computer graphics:
Project Sketchpad Ivan Sutherland (MIT 1963) established the basic interactive paradigm that characterizes interactive computer graphics: User sees an object on the display User points to (picks) the object
Ulf Assarsson Department of Computer Engineering Chalmers University of Technology
Ulf Assarsson Department of Computer Engineering Chalmers University of Technology 1. I am located in room 4115 in EDIT-huset 2. Email: 3. Phone: 031-772 1775 (office) 4. Course assistant: Tomas Akenine-Mőller
This Lecture. Why OpenGL? Introduction to OpenGL. Programmer s View
Foundations of Computer Graphics Overview and Motivation This Lecture Introduction to OpenGL and simple demo code mytest1.cpp ; you compiled mytest3.cpp for HW 0 I am going to show (and write) actual code
CS559: Computer Graphics. Lecture 12: OpenGL Li Zhang Spring 2008
CS559: Computer Graphics Lecture 12: OpenGL Li Zhang Spring 2008 Reading Redbook Ch 1 & 2 So far: 3D Geometry Pipeline Model Space (Object Space) Rotation Translation Resizing World Space M Rotation Translation
Computer Graphics (4731) Lecture 4: 2D Graphics Systems (Drawing Polylines, tiling, & Aspect Ratio)
Computer Graphics (4731) Lecture 4: 2D Graphics Systems (Drawing Polylines, tiling, & Aspect Ratio) Prof Emmanuel Agu Computer Science Dept. Worcester Polytechnic Institute (WPI) Screen Coordinate System
Tutorial 04. Harshavardhan Kode. September 14, 2015
Tutorial 04 Harshavardhan Kode September 14, 2015 1 About This tutorial an extension of the Tutorial 03. So you might see quite a lot similarities. The following things are new. A Plane is added underneath
CS Computer Graphics: Intro to OpenGL
CS 543 - Computer Graphics: Intro to OpenGL by Robert W. Lindeman gogo@wpi.edu (with help from Emmanuel Agu ;-) OpenGL Basics Last time: What is Computer Graphics? What is a graphics library What to expect
Programming Graphics Hardware
Programming Graphics Hardware Computer Graphics, VT 2013 Lecture 10 Johan Nysjö Centre for Image analysis Swedish University of Agricultural Sciences Uppsala University Recap: The fixed-function OpenGL