Introduction to OpenGL Prof. Dr.-Ing. Lars Linsen - Faculty.jacobs ...

Jacobs University 

Introduction to OpenGL 

Prof. Dr.-Ing. Lars Linsen 

School of Engineering and Science 

Jacobs University Bremen 

320621: Advanced Visualization Lab 

Visualization and Computer Graphics Lab


1. What is OpenGL? 



Graphics Programming 

• Graphical user interface (GUI) 

• Windowing system 

– X 

– Integrated in OS: Microsoft Windows, Mac OS 

• Microsoft Direct3D 

• OpenGL (Open Graphics Library) 

• OpenGL 2.0 (and higher) 

– GLSL (GL Shading Language) 

• Cg (nVidia) 

• HLSL (high level shader language, DirectX) 

• GPGPU programming: CUDA (nVidia), CTM (ATI), 

OpenCL 

Visualization and Computer Graphics Lab 

320621: Advanced Visualization Lab 3


What is OpenGL? 

• OpenGL is a software interface for 3D computer graphics 

• Originally developed by SGI (IRIS GL) 

since 1992 under control of ARB (Architecture Review Board) 

• OpenGL specification is 

• hardware-independent, 

• window system independent and 

• operating system independent. 

• Different implementations (as hardware and/or software) 

•C library 



CPU 


OpenGL Architecture 

Polynomial 

Evaluator 

Display 

List 

Pixel 

Operations 

Per Vertex 

Operations & 

Primitive 

Assembly 

Rasterization 

Texture 

Memory 

Per Fragment 

Operations 


320621: Advanced Visualization Lab 5 

Frame 

Buffer


OpenGL as a Renderer 

• Geometric primitives 

– points, lines, and polygons 

• Image Primitives 

– images and bitmaps 

• Separate pipeline for images and geometry 

– linked through texture mapping 

• Rendering depends on state 

– colors, materials, light sources, etc. 



Setting State 

Controlling current state 


glPointSize( size ); 

glLineStipple( repeat, pattern ); 

glShadeModel( GL_SMOOTH ); 

Enabling Features 

glEnable( GL_LIGHTING ); 

glDisable( GL_TEXTURE_2D ); 



Number of 

components 

2 - (x,y) 

3 - (x,y,z) 

4 - (x,y,z,w) 

OpenGL Command Formats 


glVertex3fv( v ) 

Data Type 

b - byte 

ub - unsigned byte 

s - short 

us - unsigned short 

i - int 

ui - unsigned int 

f - float 

d - double 

Vector 

omit “v” for 

scalar form 

glVertex2f( x, y ) 



• AGL, GLX, WGL 


Related APIs 

– glue between OpenGL and windowing systems 

• GLU (OpenGL Utility Library) 

– part of OpenGL 

– NURBS, tessellators, quadric shapes, etc. 

• GLUT (OpenGL Utility Toolkit) 

– portable windowing API 

– not officially part of OpenGL 



OpenGL and Related APIs 

OpenGL Motif 

widget or similar 


GLX, AGL 

or WGL 

X, Win32, Mac O/S 

application program 

GLUT 

GLU 

software and/or hardware 

GL 



• Headers Files 

• #include 

• #include 

• #include 

• Libraries 

• Enumerated Types 


Preliminaries 

– OpenGL defines numerous types for compatibility 

– GLfloat, GLint, GLenum, etc. 




2. Getting Started 


Getting started with OpenGL 

Installation of Mesa3D: http://www.mesa3d.org 




Getting started with OpenGL 

Installation of Mesa3D: http://www.mesa3d.org 





Setting up GLUT 

• To use GLUT its header file has to be included in the 

source: 

– #include 

• The program has to be linked against the GLUT library 

– For GCC just compile with -lglut 

– For MSVC and other of the sort add glut to the libraries in 

the project options 



• Application Structure 

– Configure and open window 


GLUT Basics 

– Initialize OpenGL state 

– Register input callback functions 

• render 

• resize 

• input: keyboard, mouse, etc. 

– Enter event processing loop 




Initializing GLUT 

• void glutInit(int argc, char **argv); 

– Initializes GLUT library. Should be called before any other 

routine. Processes window system specific command line 

arguments. 

• void glutInitDisplayMode(unsigned int mode); 

– Sets the GLUT display mode for windows created with 

glutCreateWindow() 

– The display mode is a bitwise or combination of GLUT_RGBA 

or GLUT_INDEX, GLUT_SINGLE or GLUT_DOUBLE, and any 

of the buffer-enabling flags GLUT_DEPTH, GLUT_STENCIL, 

or GLUT_ACCUM. 




Initializing GLUT 

• void glutInitWindowSize(int width, int height); 

– width and height of the window 

• void glutInitWindowPosition(int x, int y); 

– Sets the coordinates of the top-left corner 

• int glutCreateWindow(char *name); 

– Creates a window with the name name and returns a unique 

window identifying integer (handle). Useful when rendering is 

done in multiple windows of the same application. 



Handling events with GLUT 

• Callback functions are registered to the corresponding 

event, i.e., when the respective event takes place, the 

function is called to handle it. 

• Window events: 

– void glutDisplayFunc(void (*func)(void)); 

• The function given as argument is called whenever the window has 

to be redrawn 

– void glutReshapeFunc(void (*func)(int width, int height)); 

• The function is called when the window is resized. Width and 

height are the new width and height of the resized window. 

• When no function is specified (NULL), a default one is assigned. 




Handling Events with GLUT 

• Input events 

– void glutKeyboardFunc(void (*func)(unsigned int key, int x, int y); 

• The function is called when a key is pressed. Key is the ASCII of 

the pressed key, x and y are the mouse coordinates (window 

relative) at the moment the key is pressed 

– void glutSpecialFunc(void (*func)(int key, int x, int y)); 

• Triggered when a special key is pressed (F1..F12, arrows, Insert, 

Home, etc.). 

– void glutMouseFunc(void (*func)(int button, int state, int x, int y)); 

• Triggered when a mouse button is pressed or released. Button is left, 

right or middle, state is down or up, x and y are as above. 

– void glutMotionFunc(void (*func)(int x, int y)); 

• Specifies the function that is called when the mouse is moved while 

one or more buttons are pressed. 




Handling Events with GLUT 

• Redisplaying 

– void glutPostRedisplay(void); 

• Posts a message to the queue that redisplaying is required. At the 

first opportunity, the function is called. 

• Idling 

– void glutIdleFunc(void (*func)(void)); 

• Function is called when nothing is happening. Sometimes this 

function is set to the displaying function and timed to force a 

certain FPS 





Running the Application 

• Entering the process loop 

– void glutMainLoop(void); 



First example: Main function (1) 





Main function (2) 




Reshape function 




Keyboard function 




Display function (1) 












3. Viewing 




Camera analogy 

• 3D is just like taking a photograph (lots of 

photographs!) 

camera 

tripod 

viewing 

volume 

model 



Camera analogy and transformations 

• Projection transformations 

– adjust the lens of the camera 

• Viewing transformations 

– tripod–define position and orientation of the viewing volume in the 

world 

• Modeling transformations 

– moving the model 

• Viewport transformations 

– enlarge or reduce the physical photograph 




Programming transformations 

• Prior to rendering, view, locate, and orient: 

– eye/camera position 

– 3D geometry 

• Manage the matrices 

– including matrix stack 

• Combine (composite) transformations 




v 

e 

r 

t 

e 

x 

Modelview 

Matrix 

Modelview 

Modelview 

 

 

 


Transformation pipeline 

object eye clip normalized 

device 

Projection 

Matrix 

Projection 

CPU 

CPU 

Perspective 

Division 

Per 

Poly. Per 

Poly. Vertex 

Vertex 

DL 

DL 

Pixel 

Pixel 

Texture 

Texture 

Viewport 

Transform 

• other calculations here 

– material color 

– shade model (flat) 

– polygon rendering mode 

– polygon culling 

– clipping 



Raster 

Raster 

Frag 

Frag 

window 

FB 

FB

Coordinate systems and transformations 

• Steps in forming an image 

– specify geometry (world coordinates) 

– specify camera (camera coordinates) 

– project (window coordinates) 

– map to viewport (screen coordinates) 

• Each step uses transformations 

• Every transformation is equivalent to a change in coordinate 

systems (frames) 




Homogeneous coordinates 

– each vertex is a column vector 

– w is usually 1.0 

– all operations are matrix multiplications 

– directions (directed line segments) can be represented with w = 0.0 


⎡x 

⎤ 

⎢ 

y 

⎥ 

v = ⎢ ⎥ 

⎢z 

⎥ 

⎢ ⎥ 

⎣w⎦ 

r 



M 

= 


3D transformations 

• A vertex is transformed by 4 x 4 matrices 

– all affine operations are matrix multiplications 

– all matrices are stored column-major in OpenGL 

– matrices are always post-multiplied 

– product of matrix and vector is 

v M 

⎡m 

⎢ 

m 

⎢ 

⎢m 

⎢ 

⎣m 

0 

1 

2 

3 

m 

m 

m 

m 

4 

5 

6 

7 

m 

m 

m 

m 

8 

9 

10 

11 

m 

m 

m 

m 

⎤ 

⎥ 

⎥ 

⎥ 

⎥ 

⎦ 



12 

13 

14 

15

Specifying transformations 

• Specify Current Matrix Stack 

glMatrixMode( 

glMatrixMode( 

GL_MODELVIEW or GL_PROJECTION ) 

• Programmer has two styles of specifying 

transformations 

– specify matrices (glLoadMatrix, glLoadMatrix, glMultMatrix) 

glMultMatrix 

– specify operation (glTranslate 

glTranslate, , glRotate, glRotate, 

glOrtho) 

glOrtho 




Projection Transformation 

•Shape of viewing frustum 

• Perspective projection 

gluPerspective( fovy, aspect, zNear, zFar ) 

glFrustum( left, right, bottom, top, zNear, zFar ) 

• Orthographic parallel projection 

glOrtho( left, right, bottom, top, zNear, zFar ) 

gluOrtho2D( left, right, bottom, top ) 

calls glOrtho with z values near zero 





Orthogonal projection 

• void glOrtho(GLdouble left, GLdouble right, GLdouble 

bottom, GLdouble top, GLdouble near, GLdouble far); 

– Creates a matrix for an orthographic parallel view and 

multiplies it by the current matrix 



Applying projection transformations 

• Typical use (orthographic projection) 

glMatrixMode( GL_PROJECTION ); 

glLoadIdentity(); 

glOrtho( left, right, bottom, top, zNear, zFar ); 





Perspective projection 

• void glFrustum(GLdouble left, Gldouble right, Gldouble 

bottom, Gldouble top, Gldouble near, Gldouble far); 

– Creates a matrix for the frustrum and multiplies the current 

matrix by it. Near and far are the distances to the clipping 

planes 




Perspective projection 

• More intuitive: 

void gluPerspective(GLdouble fovy, Gldouble aspect, 

Gldouble near, Gldouble far); 

– fovy is the field of view in x-z plane. Aspect is the aspect ratio 

width/height 




Viewing transformations 

• Position the camera/eye in the scene 

– place the tripod down; aim camera 

• To “fly through” a scene 

– change viewing transformation and 

redraw scene 

gluLookAt( eye x , eye y , eye z , 

aim x , aim y , aim z , 

up x , up y , up z ) 

– up vector determines unique orientation 

– careful of degenerate positions 



tripod


Viewing transformation 



Modeling transformations 

• Move object 

glTranslate{fd}( x, y, z ) 

• Rotate object around arbitrary axis 

glRotate{fd}( 

glRotate{fd}( 

angle, x, y, z ) 

– angle is in degrees 

• Dilate (stretch or shrink) or mirror object 

glScale{fd}( x, y, z ) 





Viewing and modeling 

• Moving camera is equivalent to moving every object in 

the world towards a stationary camera 

• Viewing transformations are equivalent to several 

modeling transformations 



Viewport Transformations 

• Viewport 

– usually same as window size 

– can be used to see part of the screen to which is rendered 

– viewport aspect ratio should be same as projection transformation or 

resulting image may be distorted 

glViewport( 

glViewport 

glViewport( ( x, y, width, height ) 





Matrix Operations 

• Specify Current Matrix Stack 

glMatrixMode( GL_MODELVIEW or GL_PROJECTION ) 

• Other Matrix or Stack Operations 

glLoadIdentity() glPushMatrix() 

glPopMatrix() 




Matrix stacks 

• The matrices manipulated by all operations discussed 

so far are the ones that sit on the top of the matrix 

stack. 

• When a matrix is pushed onto the stack, the current 

topmost matrix is duplicated, so that first and second 

matrices contain the same entries. 

• When popping a matrix, the topmost matrix is deleted 

and the second one becomes the topmost one. 



Matrix stacks - some applications 

• Modelview matrices 

– E.g.: Save the current position, go somewhere else, draw 

something, return to the previous position, go elsewhere, draw 

the same thing scaled by a factor of 2, return to the initial 

position, … 

– The stack may contain at least 32 matrices (depends on the 

OpenGL implementation) 

• Projection matrices 

– E.g. useful when a text box needs to be displayed (since text is 

best viewed in orthogonal projection and realistic applications 

are using perspective projections). 

– At least 2 matrices (again depends on implementation) 




4. Object Representation 



Points: 


OPenGL primitive types 




OPenGL primitive types 

Line segments & sequences thereof: 




OpenGL primitive types 

Convex simple polygons & meshes: 



Using OpenGL primitives 

• Primitives are specified using 

glBegin( primType ); 

glEnd(); 

– primType is any of the primitive types and determines how 

vertices are combined. 

GLfloat red, green, blue; 

Glfloat coords[3]; 

glColor3f( red, green, blue ); 

glBegin( glBegin( 

primType ); 

for ( i = 0; i < nVerts; ++i ) { 

glVertex3fv( coords ); 

} 

glEnd(); 




Using OpenGL Primitives 




Using OpenGL Primitives 


glBegin(GL_POLYGON); 

glVertex2f(0.0, 0.0); 





glEnd(); 




GLUT objects 

• void glutWireSphere(GLdouble radius, GLint slices, GLint stacks); 

void glutSolidSphere(GLdouble radius, GLint slices, GLint stacks); 

• void glutWireCube(GLdouble size); 

void glutSolidCube(GLdouble size); 

• void glutWireTorus(GLdouble innerRadius, GLdouble outerRadius, 

GLint nsides, GLint rings); 

• void glutSolidTorus(GLdouble innerRadius, GLdouble outerRadius, 

GLint nsides, GLint rings); 




GLUT objects 




GLUT objects 




GLUT objects 

• void glutWireIcosahedron(void); 

void glutSolidIcosahedron(void); 

• void glutWireOctahedron(void); 

void glutSolidOctahedron(void); 

• void glutWireTetrahedron(void); 

void glutSolidTetrahedron(void); 

• void glutWireDodecahedron(GLdouble radius); 

void glutSolidDodecahedron(GLdouble radius); 




GLUT objects 

• void glutWireCone(GLdouble radius, GLdouble height, GLint slices, 

GLint stacks); 

void glutSolidCone(GLdouble radius, GLdouble height, GLint slices, 

GLint stacks); 

• void glutWireTeapot(GLdouble size); 

void glutSolidTeapot(GLdouble size); 




GLUT objects 




5. Displaying 


CPU 

CPU 


DL 

DL 

Rasterization 

Per 

Poly. Per 

Poly. Vertex 

Vertex 

Pixel 

Pixel 

Texture 

Texture 

Raster 

Raster 

Frag 

Frag 

FB 

FB 



Front 

Buffer 

1 

2 4 8 16 


Double Buffering 

1 

2 4 8 16 

Display 

Back 

Buffer 



Animation Using Double Buffering 

Request a double buffered color buffer 

glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE ); 

Clear color buffer 

glClear( GL_COLOR_BUFFER_BIT ); 

Render scene 

Request swap of front and back buffers 

glutSwapBuffers(); 

Repeat steps 2 - 4 for animation 




An Updated Program Template (cont.) 

• • void drawScene( void ) 

{ 

GLfloat vertices[] = { … }; 

GLfloat colors[] = { … }; 

glClear( GL_COLOR_BUFFER_BIT); 

• glBegin( GL_TRIANGLE_STRIP ); 

/* calls to glColor*() and glVertex*() */ 

glEnd(); 

glutSwapBuffers(); 

} 





Antialiasing 

• Removing the Jaggies 

• glEnable( mode ) 

• GL_POINT_SMOOTH 

• GL_LINE_SMOOTH 

• GL_POLYGON_SMOOTH 

– alpha value computed by computing 

sub-pixel coverage 

– available in both RGBA and colormap modes 



Full Scene Antialiasing : Jittering the view 

• Each time we move the viewer, the image shifts 

– Different aliasing artifacts in each image 

– Averaging images using accumulation 

buffer averages out 

these artifacts 





Blending 

• Combine pixels with what’s in already 

in the framebuffer 

• glBlendFunc( src, dst ) 

v 

C 

r 

= 

Fragment 

(src src) 

src 

v 

C 

f 

+ 

Framebuffer 

Pixel 

(dst dst) 

dst 

v 

C 

p 

Blending 

Equation 



Blended 

Pixel

– operations 


Accumulation Buffer 

• glAccum( op, value ) 

• within the accumulation buffer: GL_ADD, GL_MULT 

• from read buffer: GL_ACCUM, GL_LOAD 

• transfer back to write buffer: GL_RETURN 

– glAccum(GL_ACCUM, 0.5) multiplies each value in write 

buffer by 0.5 and adds to accumulation buffer 




Accumulation Buffer 

• Problems of compositing into color buffers 

– limited color resolution 

• clamping 

• loss of accuracy 

– Accumulation buffer acts as a “floating point” color buffer 

• accumulate into accumulation buffer 

• transfer results to frame buffer 




Multi-pass Rendering 

• Blending allows results from multiple drawing passes 

to be combined together 

– enables more complex rendering algorithms 

Example of bump-mapping 

done with a multi-pass 

OpenGL algorithm 



Color 

Buffer 

1 

2 4 8 16 


Depth Buffering 

1 

2 4 8 16 

Display 

Depth 

Buffer 



Depth Buffering Using OpenGL 

Request a depth buffer 

glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE | 

GLUT_DEPTH ); 

Enable depth buffering 

glEnable( GL_DEPTH_TEST ); 

Clear color and depth buffers 

glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); 

Render scene 

Swap color buffers 





6. Colors & Shading 


Specifying Geometric Primitives 




How OpenGL Simulates Lights 

• Phong lighting model 

– Computed at vertices 

• Lighting contributors 

– Surface material properties 

– Light properties 

– Lighting model properties 





Surface Normals 

• Normals define how a surface reflects light 

• glNormal3f( x, y, z ) 

– Current normal is used to compute vertex’s color 

– Use unit normals for proper lighting 

• scaling affects a normal’s length 

glEnable( GL_NORMALIZE ) 

or 

glEnable( GL_RESCALE_NORMAL ) 




Material Properties 

• Define the surface properties of a primitive 

• glMaterialfv( face, property, value ); 

GL_DIFFUSE Base color 

GL_SPECULAR Highlight Color 

GL_AMBIENT Low-light Color 

GL_EMISSION Glow Color 

GL_SHININESS Surface Smoothness 

– separate materials for front and back 




Light Properties 

• glLightfv( light, property, value ); 

– light specifies which light 

• multiple lights, starting with GL_LIGHT0 

glGetIntegerv( GL_MAX_LIGHTS, &n ); 

– properties 

• colors 

• position and type 

• attenuation 



• Light color properties 

– GL_AMBIENT 

– GL_DIFFUSE 

– GL_SPECULAR 


Light Colors 




Types of Lights 

• OpenGL supports two types of Lights 

– Local (Point) light sources 

– Infinite (Directional) light sources 

• Type of light controlled by w coordinate 

w = 

0 

w ≠ 0 

Infinite 

Local 

Light 

Light 

directed 

positioned 

along 

at 

( x y z) 

( ) 

x y z 



w 

w 

w

• Light attenuation 


Attenuation 

– decrease light intensity with distance 

• GL_CONSTANT_ATTENUATION 

• GL_LINEAR_ATTENUATION 

• GL_QUADRATIC_ATTENUATION 

f 

i 

= 

k 

c 

+ 

k 

l 

1 

d + k 

q 

d 

2 



• Flip each light’s switch 


Turning on the Lights 

glEnable( GL_LIGHTn ); 

• Turn on the power 

glEnable( GL_LIGHTING ); 




Light & Material 



• Spotlights 

Advanced Lighting Features 

– localize lighting affects 

• GL_SPOT_DIRECTION 

• GL_SPOT_CUTOFF 

• GL_SPOT_EXPONENT 




• Setting State 


Shading 

glShadeModel( 

glShadeModel 

glShadeModel( ( GL_SMOOTH 

GL GL_SMOOTH SMOOTH | GL_FLAT); 




8. Textures 



CPU 

CPU 

• Apply a 1D, 2D, or 3D image to geometric 

primitives 


Texture Mapping 

Per 

Poly. Per 

Poly. Vertex 

Vertex 

DL 

DL 

Pixel 

Pixel 

Texture 

Texture 

Raster 

Raster 

Frag 

Frag 

FB 

FB 



Texture Mapping and the OpenGL Pipeline 

• Images and geometry flow through separate pipelines 

that join at the rasterizer 

– “complex” textures do not affect geometric complexity 

vertices 

image 


geometry pipeline 

pixel pipeline 

rasterizer 



• Three steps 

specify texture 


Applying Textures 

• read or generate image 

• assign to texture 

• enable texturing 

assign texture coordinates to vertices 

specify texture parameters 

• wrapping, filtering 




Texture Objects 

• Like display lists for texture images 

– one image per texture object 

– may be shared by several graphics contexts 

• Generate texture names 

glGenTextures( n, *texIds ); 



Texture Objects (cont.) 

• Create texture objects with texture data and state 

• Bind textures before using 

glBindTexture( target, id ); 





Specify Texture Image 

• Define a texture image from an array of 

texels in CPU memory 

glTexImage2D( target, level, components, 

w, h, border, format, type, *texels ); 



• Based on parametric texture coordinates 

• glTexCoord*() specified at each vertex 

t 

0, 1 

a 

b 


1, 1 

0, 0 1, 0 

Mapping a Texture 

Texture Space Object Space 

c 

s 

(0.4, 0.2) 

(s, t) = (0.2, 0.8) 

A 

B C 

(0.8, 0.4) 




Example 

// Loading a Texture, specifying properties 

glGenTextures(1, &texName); 

glBindTexture(GL_TEXTURE_2D, texName); 

glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); 

glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); 

glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, 

GL_UNSIGNED_BYTE, Image_Buffer); 

// later while describing polygons... 

glTexCoord2f(0.0, 0.0); glVertex3f(-2.0, -1.0, 0.0); 

glTexCoord2f(0.0, 1.0); glVertex3f(-2.0, 1.0, 0.0); 

… 




Example 




Applying Textures 

– specify textures in texture objects 

– set texture filter 

– set texture function 

– set texture wrap mode 

– set optional perspective correction hint 

– bind texture object 

– enable texturing 

– supply texture coordinates for vertex 

• coordinates can also be generated 



• Filter Modes 

– minification or magnification 

– special mipmap minification filters 

• Wrap Modes 

Texture Application Methods 

– clamping or repeating (tiling) 

• Texture Functions 

– how to mix primitive’s color with texture’s color 

• blend, modulate or replace texels 





Filter Modes 

Example: 

glTexParameteri( target, type, mode ); 

Texture Polygon 

Texture Polygon 

Magnification Minification 




Mipmapped Textures 

• Mipmap allows for prefiltered texture maps of decreasing resolutions 

• Lessens interpolation errors for smaller textured objects 

• Declare mipmap level during texture definition 

glTexImage*D( GL_TEXTURE_*D, level, … ) 

• GLU mipmap builder routines 

gluBuild*DMipmaps( … ) 

• OpenGL 1.2 introduces advanced LOD controls 




Wrapping Mode 

• Example: 

glTexParameteri( GL_TEXTURE_2D, 

GL_TEXTURE_WRAP_S, GL_CLAMP ) 

glTexParameteri( GL_TEXTURE_2D, 

GL_TEXTURE_WRAP_T, GL_REPEAT ) 

t 

texture 

s 

GL_REPEAT 

wrapping 

GL_CLAMP 

wrapping 




Texture Functions 

• Controls how texture is applied 

• glTexEnv{fi}[v]( GL_TEXTURE_ENV, prop, param ) 

• GL_TEXTURE_ENV_MODE modes 

– GL_MODULATE 

– GL_BLEND 

– GL_REPLACE 

• Set blend color with GL_TEXTURE_ENV_COLOR 



Perspective Correction Hint 

• Texture coordinate and color interpolation 

– either linearly in screen space 

– or using depth/perspective values (slower) 

• Noticeable for polygons “on edge” 

• glHint( GL_PERSPECTIVE_CORRECTION_HINT, hint ) 

where hint is one of 

• GL_DONT_CARE 

• GL_NICEST 

• GL_FASTEST 





Done.

Introduction to OpenGL Prof. Dr.-Ing. Lars Linsen - Faculty.jacobs ...

Create successful ePaper yourself

Delete template?

Save as template?