An Interactive Introduction to OpenGL Programming

An Interactive Introduction to

OpenGL Programming

Dr. Mohammad Iqbal

Agenda

z

_{General OpenGL Introduction}

z

_{Rendering Primitives}

z

_{Rendering Modes}

z

_Lighting

z

_{Texture Mapping}

Goals for Today

z

_{Tujuan : mendemonstrasikan OpenGL}

dalam menghasilkan program grafik

interaktif dalam

z Membuat model 3D obyek atau imagery

z Lighting - pencahayaan

z texture mapping

OpenGL and GLUT Overview

z

_{Apakah OpenGL & apa manfaatnya?}

z

_{OpenGL dalam sistem window}

z

_{Mengapa GLUT}

Apakah OpenGL?

z

_{Graphics rendering API (Application}

Programming Interface)

z citra warna high-quality yang terdiri dari geometric dan citra primitif

z Independen window system

Arsitektur OpenGL

Display List

Polynomial Evaluator

Per Vertex Operations &

Primitive Assembly

Rasterization Per Fragment

OpenGL sebagai Renderer

z

_{Geometric primitif}

z titik, garis dan poligon

z

_{Image Primitif}

z Citra dan bitmap

z Memisahkan pipeline untuk citra dan geometry

z linked ketika penerapan texture mapping

z

_{Rendering tergantung pada status}

API yang Terkait OpenGL

z AGL, GLX, WGL

z Perekat antara OpenGL dan sistem window z GLU (OpenGL Utility Library)

z Bagian OpenGL

z NURBS, tessellators, quadric shapes, dll. z GLUT (OpenGL Utility Toolkit)

z portable windowing API

API yang Terkait OpenGL

GLUT

GLU

GL

GLX, AGL or WGL

X, Win32, Mac O/S

software and/or hardware application program

Preliminaries

z

_{Headers Files}

z #include <GL/gl.h> z #include <GL/glu.h> z #include <GL/glut.h>

z

_Libraries

z

_{Enumerated Types}

z OpenGL defines numerous types for compatibility

Dasar-dasar GLUT

z

_{Struktur Aplikasi}

z Configure dan open window

z Initialisasi status OpenGL

z Register fungsi input callback

z render z resize

z input: keyboard, mouse, dll.

Contoh Program

void main( int argc, char** argv ) {

int mode = GLUT_RGB|GLUT_DOUBLE; glutInitDisplayMode( mode );

glutCreateWindow( argv[0] ); init();

glutDisplayFunc( display ); glutReshapeFunc( resize ); glutKeyboardFunc( key );

glutIdleFunc( idle ); glutMainLoop();

Inisialisasi OpenGL

z Set up status yg ingin digunakan

void init( void ) {

glClearColor( 0.0, 0.0, 0.0, 1.0 ); glClearDepth( 1.0 );

Fungsi input Callback GLUT

z

_{Rutin yang dipanggil ketika sesuatu}

terjadi

z window resize atau redraw

z user input

z animasi

z

_{Me-“register” callbacks pada GLUT}

glutDisplayFunc( display );

glutIdleFunc( idle );

Rendering Callback

z

_{Lakukan penggambaran grafik}

pada bagian ini :

glutDisplayFunc( display );

void display( void ) {

glClear( GL_COLOR_BUFFER_BIT ); glBegin( GL_TRIANGLE_STRIP );

glVertex3fv( v[0] ); glVertex3fv( v[1] ); glVertex3fv( v[2] ); glVertex3fv( v[3] ); glEnd();

Idle Callbacks

z Gunakan untuk animasi dan update yang continyu

glutIdleFunc( idle );

void idle( void ) {

t += dt;

User Input Callbacks

z Untuk pemrosesan input dari user

glutKeyboardFunc( keyboard );

void keyboard( unsigned char key, int x, int y ) {

switch( key ) {

case ‘q’ : case ‘Q’ : exit( EXIT_SUCCESS ); break;

case ‘r’ : case ‘R’ : rotate = GL_TRUE;

glutPostRedisplay(); break;

Agenda Elementary Rendering

z

_{Geometric Primitives}

OpenGL Geometric Primitif

GL_POINTS GL_LINESGL_LINES

GL_LINE_LOOP

z

Semua jenis geometric primitif

Contoh Sederhana

void drawRhombus( GLfloat color[] ) {

glBegin( GL_QUADS ); glColor3fv( color );

glVertex2f( 0.0, 0.0 ); glVertex2f( 1.0, 0.0 ); glVertex2f( 1.5, 1.118 ); glVertex2f( 0.5, 1.118 ); glEnd();

Format Perintah OpenGL

glVertex3fv(

glVertex3fv(

v

v

)

)

Number of Number of components

Data Type Data Type b

b -- bytebyte ub

ub -- unsigned byteunsigned byte s

s -- shortshort us

us -- unsigned shortunsigned short i

i -- intint ui

ui -- unsigned intunsigned int f scalar form scalar form

Specifying Geometric Primitives

z

Primitif dispesifikasikan menggunakan :

glBegin(

glBegin( primType primType ););

glEnd();

glEnd();

z primType menentukan bagaimana vertice dikombinasikan

GLfloat red, green, blue; Glfloat coords[3];

glBegin( primType );

for ( i = 0; i < nVerts; ++i ) { glColor3f( red, green, blue ); glVertex3fv( coords );

Model Warna

OpenGL

color index mode

Display

Red Green Blue 0

Poly. Per Vertex

2

Mengendalikan tampilan

Appearance

(Rendering)

Dari

Mesin Status OpenGL

z

_{Setiap atribut rendering di encapsulapsi}

dalam

OpenGL State

z rendering styles

z shading

z lighting

Manipulasi Status OpenGL

z Tampilan dikendalikan oleh status terakhir

for each ( primitive to render ) {

update OpenGL state render primitive

}

z Manipulasi atribut vertex adalah cara umum untuk memanipulasi status

glColor*() / glIndex*() glNormal*()

Mengendalikan Status terakhir

z

_{Setting Status}

glPointSize(

glPointSize( sizesize ););

glLineStipple(

glLineStipple( repeatrepeat, , pattern pattern ););

glShadeModel(

glShadeModel( GLGL__SMOOTHSMOOTH ););

z

_{Enabling Features}

glEnable(

glEnable( GLGL__LIGHTING LIGHTING ););

glDisable(

Transformasi dalam OpenGL

z

_Modeling

z

_Viewing

z orientasi kamera

z projection

z

_Animasi

Analogi Kamera

z

3D adalah seperti mengambil citra pada

fotografi (Banyak foto!)

camera

tripod model

Analogi Kamera dan Transformasi

z Projection transformations

z Mengatur lensa kamera z Viewing transformations

z Mengatur posisi tripod dan orientasi viewing suatu

volume dalam dunia nyata (world)

z Modeling transformations

z memindahkan model

z Viewport transformations

z Memperbesar atau mengurangi fotografi secara

Sistem Koordinat dan Transformasi

z Langkah dalam menyiapkan citra

z spesifikasikan geometri (world coordinates) z spesifikasikan kamera (camera coordinates) z proyeksi (window coordinates)

z Petakan ke viewport (screen coordinates)

z Setiap langkah menggunakan transformasi

Transformasi Affine

z

_{Transformasi yang mempertahankan}

bentuk geometri

z garis, poligon, quadric

z

_{Affine = mempertahankan garis (line}

preserving)

z Rotasi, translasi, skala

z Proyeksi

Koordinat Homogen

z Setiap vertex adalah vector kolom

z w umumnya bernilai 1.0

z Semua operasi adalah perkalian matriks

z Arah (directed line segments) direpresentasikan w = 0.0

⎥

3D Transformations

z _{Vertex ditransformasikan oleh 4 x 4 matrik}

z Semua operasi affine adalah perkalian matriks

z Semua matrik disimpan secara column-major

dalam OpenGL

z matriks selalu dalam kondisi post-multiplied

Menspesifikasikan Transformasi

z

_{Programmer memiliki 2 styles untuk}

men-spesifikasikan transformasi

z spesifikasikan matriks (glLoadMatrix, glLoadMatrix,

glMultMatrix

glMultMatrix)

z spesifikasikan operasi (glRotate, glRotate, glOrtho

glOrtho)

z

_{Programmer tidak perlu mengingat jenis}

matriksnya secara tepat

z cek lampiran buku Red Book (Programming

Programming Transformations

z

Sebelum proses rendering, view, locate,

dan orientasi :

z Posisi mata/kamera

z 3D geometri

z

Mengatur matriks

z Termasuk matriks stack

v

object eye clip normalized

device window

z Bbrp kalkulasi tambahan :

z material Î color z shade model (flat)

z polygon rendering mode z polygon culling

z clipping

Pipeline

Transformasi

CPUCPU DLDL Poly.

Operasi Matriks

z Spesifikasikan Matriks Stack terkini

glMatrixMode( GL_MODELVIEW atau

GL_PROJECTION )

z Matriks atau operasi Stack lain

glLoadIdentity() glPushMatrix()

glLoadIdentity() glPushMatrix()

glPopMatrix()

glPopMatrix()

z Viewport

z Biasanya sama dengan ukuran window size z aspek rasio viewport harus sama dengan

transformasi proyeksi atau citra hasilnya akan terdistorsi

Transformasi Proyeksi

Bentuk untuk menampilkan (viewing) frustum :

z Perspective projection

gluPerspective( fovy, aspect, zNear, zFar )

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

)

z Orthographic parallel projection

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

gluOrtho2D( left, right, bottom, top )

Mengaplikasikan Transformasi Proyeksi

z Pengunaan Umum (orthographic projection)

glMatrixMode( GL_PROJECTION ); glMatrixMode( GL_PROJECTION ); glLoadIdentity();

glLoadIdentity();

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

Viewing Transformations

z Posisi Kamera/mata dalam scene

z Posisikan tripod (eye) ; persiapkan (aim) Kamera z Untuk Scene “fly through”

z Ubah transformasi viewing dan

re-draw scene

gluLookAt( eye_x, eye_y, eye_z, aim_x, aim_y, aim_z, up_x, up_y, up_z )

z up vector menghasilkan orientasi unik z Berhati-hati dalam de-generate posisi

4

Modeling Transformations

z Memindahkan obyek glTranslate{fd}(

glTranslate{fd}( x, y, zx, y, z ))

z Rotasi obyek di sekitar sumbu utama glRotate

glRotate{{fdfd}( }( angle, x, y, zangle, x, y, z ))

z angle dalam derajat

z _{Dilasi (stretch atau shrink) atau mirror object}

glScale{fd}(

glScale{fd}( x, y, zx, y, z ))

4

Connection: Viewing dan Modeling

z

Memindahkan kamera equivalent

dengan memindahkan setiap obyek di

dunia nyata di depan kamera diam

z

_{Viewing transformation equivalent}

dengan transformasi modeling

Proyeksi dengan kaidah tangan kiri

z

_{Projection transformations}

(

gluPerspective, glOrtho

) berdasarkan

kaidah tangan kiri

z bayangkan zNear dan zFar sebagai jarak tertentu dari view point

z

_{Setiap hal selain itu adalah kaidah}

tangan kanan, termasuk vertex yang di

render

y

y z+

Penggunaan Umum Transformasi

z

3 contoh rutin resize()

z Re-status proyeksi & viewing transformations

z

Umumnya dipanggil ketika window

resize

z

_{Di-register sebagai callback untuk}

resize()

: Perspective & LookAt

void resize( int w, int h ) {

glViewport( 0, 0, (GLsizei) w, (GLsizei) h );

glMatrixMode( GL_PROJECTION ); glLoadIdentity();

gluPerspective( 65.0, (GLdouble) w / h, 1.0, 100.0 );

glMatrixMode( GL_MODELVIEW ); glLoadIdentity();

resize()

: Perspective & Translate

Efek yang sama dengan LookAt :

void resize( int w, int h ) {

glViewport( 0, 0, (GLsizei) w, (GLsizei) h ); glMatrixMode( GL_PROJECTION );

glLoadIdentity();

gluPerspective( 65.0, (GLdouble) w/h, 1.0, 100.0 );

glMatrixMode( GL_MODELVIEW ); glLoadIdentity();

resize()

: Ortho (bagian 1)

void resize( int width, int height ) {

GLdouble aspect = (GLdouble) width / height;

GLdouble left = -2.5, right = 2.5; GLdouble bottom = -2.5, top = 2.5; glViewport( 0, 0, (GLsizei) w,

(GLsizei) h );

glMatrixMode( GL_PROJECTION ); glLoadIdentity();

if ( aspect < 1.0 ) { left /= aspect;

right /= aspect; } else {

bottom *= aspect; top *= aspect;

}

glOrtho( left, right, bottom, top, near, far );

glMatrixMode( GL_MODELVIEW ); glLoadIdentity();

}

Membangun Modeling Transformations

z Masalah 1: hirarki obyek

z Suatu posisi tergantung pada posisi sebelumnya z Lengan robot atau tangan ; sub-assemblies

z Solusi 1: memindahkan sistem koordinat lokal

z modeling transformation untuk memindahkan

sistem koordinat

Membangun Modeling Transformations

z Masalah 2 : obyek berpindah secara relatif pada absolute world origin

z Obyek berotasi di area yang salah pada origin

z Membuat obyek spin di sekitar center atau suatu area

z Solusi 2: fixed coordinate system

z modeling transformations akan memindahkan

obyek disekitar fixed coordinate system

z pre-multiply column-major matrices z OpenGL post-multiplies matrices

z harus me-reverse order operasi untuk

Area Clipping Tambahan

z Paling tidak ada 6 atau lebih area clipping

z Baik untuk perhitungan cross-sections

z Modelview matrix memindahkan area clipping clipped

glEnable( GL_CLIP_PLANEi )

glClipPlane( GL_CLIP_PLANEi, GLdouble* coeff )

0

< +

+

Reversing Koordinat Proyeksi

z

_{Screen space kembali ke world space}

glGetIntegerv( GL_VIEWPORT, GLint viewport[4] ) glGetDoublev( GL_MODELVIEW_MATRIX, GLdouble

mvmatrix[16] )

glGetDoublev( GL_PROJECTION_MATRIX,

GLdouble projmatrix[16] ) gluUnProject( GLdouble winx, winy, winz,

mvmatrix[16], projmatrix[16], GLint viewport[4],

GLdouble *objx, *objy, *objz )

z gluProject

untuk memindahkan

Prinsip Pencahayaan

z

_{Pencahayaan mensimulasikan}

bagaimana obyek memantulkan cahaya

z Komposisi material obyek

z Warna cahaya dan posisi

z Parameter global pencahayaan

z Cahaya ambien

z Pencahayaan dua sisi

Bagaimana OpenGL

Mensimulasikan Cahaya

z

_{Model Pencahayaan Phong}

z Perhitungan pada vertices

z

Kontributor Pencahayaan

z Properti permukaan material

z Properti cahaya

Surface

Normals

z Normal mendefinisikan bagaimana pemukaan memantulkan cahaya

z

z glNormal3f( x, y, zglNormal3f( x, y, z ))

z Current normal digunakan untuk menghitung warna

vertex

z Gunakan unit normals untuk pencahayaan yang

tepat

z Skalakan efek pada panjang normal

glEnable( GL_NORMALIZE )

or

glEnable( GL_RESCALE_NORMAL )

CPU CPU

DL DL Poly.

Material Properties

z Definisikan properti permukaan obyek primitif

glMaterialfv( face, property, value );

z Pisahkan material antara bagian front dan back GL_DIFFUSE Base color

GL_SPECULAR Highlight Color

GL_AMBIENT Low-light Color

GL_EMISSION Glow Color

Properti Cahaya

glLightfv( light, property, value );

z

light

menspesifikasikan jenis cahaya

z multiple lights, mulai dari GL_LIGHT0

glGetIntegerv( GL_MAX_LIGHTS, &n );

z

properties

z Warna

z posisi dan type

Sumber cahaya

z

_{Light color properties}

Tipe Cahaya

z

_{OpenGL mendukung 2 tipe Cahaya :}

z Local (Point) light sources

z Infinite (Directional) light sources

z

_{Tipe cahaya dikendalikan oleh koordinat}

w

Infinite

0 0

Menyalakan (Turning on) Cahaya

z

_{Flip setiap “switch” cahaya}

glEnable( GL_LIGHTn );

z

Turn on the power

6

Mengendalikan Posisi Cahaya

z

_{Modelview matrix berpengaruh pada}

posisi cahaya:

z Perbedaan efek berdasarkan kapan posisi cahaya dispesifikasikan

z eye coordinates z world coordinates z model coordinates

7

Fitur Pencahayaan Lanjut

z

_Spotlight

z Melokalisasi efek cahaya

z GL_SPOT_DIRECTION z GL_SPOT_CUTOFF

Fitur Pencahayaan Lanjut

z

_{Perambatan cahaya (Light attenuation)}

z decrease light intensity with distance

z GL_CONSTANT_ATTENUATION z GL_LINEAR_ATTENUATION

z GL_QUADRATIC_ATTENUATION

Properti Model Cahaya

glLightModelfv( property, value );

z Enabling two sided lighting GL_LIGHT_MODEL_TWO_SIDE

z Global ambient color

GL_LIGHT_MODEL_AMBIENT

z Local viewer mode

GL_LIGHT_MODEL_LOCAL_VIEWER

z Separate specular color

Tips untuk pencahayaan yg baik

z

_{Pemanggilan Pencahayaan dikomputasi}

hanya pada vertices

z Pemanggilan pada model tessellation memang menghasilkan kualitas

pencahayaan yang lebih baik tapi proses geometrinya lebih kompleks

z

_{Gunakan cahaya tunggal}

_infinite

_untuk

perhitungan pencahayaan cepat

dan

Animation dan Depth Buffering

z

_{Mendikusikan double buffering dan}

animasi

z

Mendiskusikan

hidden surface removal

Double

Animasi menggunakan Double Buffering

c Defenisikan double buffered pada color buffer glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE

);

d Clear color buffer

glClear( GL_COLOR_BUFFER_BIT );

e _{Render scene}

f Definisikan swap untuk front dan back buffers

glutSwapBuffers();

Depth Buffering dan

Hidden Surface Removal

Depth Buffering menggunakan OpenGL

c Defenisikan depth buffer

glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH );

d Enable depth buffering

glEnable( GL_DEPTH_TEST );

e Clear color dan depth buffers

glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );

f _{Render scene}

An Updated Program Template

void main( int argc, char** argv ) {

glutInit( &argc, argv );

glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH );

glutCreateWindow( “Tetrahedron” ); init();

glutIdleFunc( idle );

glutDisplayFunc( display ); glutMainLoop();

An Updated Program Template

(Lanjutan)

void init( void ) {

glClearColor( 0.0, 0.0, 1.0, 1.0 );

}

void idle( void ) {

An Updated Program Template

(Lanjutan)

void drawScene( void ) {

GLfloat vertices[] = { … }; GLfloat colors[] = { … };

glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );

glBegin( GL_TRIANGLE_STRIP );

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

glEnd();

glutSwapBuffers();

Texture

Mapping

CPUCPU DLDL Poly.

Poly. Per Vertex

z

mengaplikasikan citra 1D, 2D, atau 3D

ke geometrik primitif

z

_{Hal yang digunakan untuk proses}

Texturing

z simulasi material

z Mengurangi kompleksitas geometrik

z image warping

8

7

s

t

x

y

z

image

geometry

Texture Mapping dan OpenGL

Pipeline

geometry pipeline vertices

pixel pipeline image

rasterizer

z

_{Citra dan geometri mengalir dalam}

pipeline yang terpisah pada proses di

rasterizer

Contoh Tekstur

z

_{Tekstur ini adalah citra}

Cara mengaplikasikan Tekstur I

z

_{Three steps}

c specify texture

zread or generate image

zassign to texture

zenable texturing

d assign texture coordinates to vertices

e specify texture parameters

Tekstur Obyek

z Like display lists for texture images

z one image per texture object

z may be shared by several graphics contexts

z _{Generate texture names}

Cara mengaplikasikan Tekstur II

z specify textures in texture objects

z set texture filter

z set texture function

z set texture wrap mode

z set optional perspective correction hint

z bind texture object

z enable texturing

z supply texture coordinates for vertex

Tekstur Obyek (lanjutan)

z Create texture objects with texture data and state

glBindTexture( target, id );

z _{Bind textures before using}

z Define a texture image from an array of texels in CPU memory

z glTexImage2D( target, level, components, w, h, border, format, type, *texels );

z dimensions of image must be powers of 2

z Texel colors are processed by pixel pipeline

z pixel scales, biases and lookups can be

done

Memilih citra

untuk Tekstur

CPUCPU DLDL Poly.

Konversikan citra Tekstur

z If dimensions of image are not power of 2

z gluScaleImage( format, w_in, h_in, type_in, *data_in, w_out, h_out,

type_out, *data_out );

z *_in is for source image

z *_out is for destination image

z _{Image interpolated and filtered during}

Memilih Tekstur: Methode Lainnya

z Use frame buffer as source of texture image

z uses current buffer as source image

glCopyTexImage1D(...)

glCopyTexImage1D(...)

glCopyTexImage2D(...)

glCopyTexImage2D(...)

z Modify part of a defined texture

glTexSubImage1D(...)

glTexSubImage1D(...)

glTexSubImage2D(...)

glTexSubImage2D(...)

glTexSubImage3D(...)

glTexSubImage3D(...)

z Based on parametric texture coordinates

z glTexCoord*() _{specified at each vertex}

s

Texture Space Object Space

Memetakan

(Mapping) Tekstur

CPU_CPU

DL DL Poly.

Membuat Koordinat Tekstur

z Automatically generate texture coords

glTexGen{ifd}[v]()

z specify a plane

z generate texture coordinates based upon distance

from plane

z generation modes

z GL_OBJECT_LINEAR z GL_EYE_LINEAR

z GL_SPHERE_MAP

9

z Filter Modes

z minification or magnification

z special mipmap minification filters

z Wrap Modes

z clamping or repeating z Texture Functions

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

z blend, modulate or replace texels

Filter Modes

Texture Polygon

Magnification Minification

Polygon Texture

Example:

glTexParameteri(

Tekstur Mipmapped

z Mipmap allows for prefiltered texture maps of

decreasing resolutions

z Lessens interpolation errors for smaller textured

objects

z Declare mipmap level during texture definition

glTexImage*D(

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

z GLU mipmap builder routines

gluBuild*DMipmaps(

gluBuild*DMipmaps( …… ))

Mode Wrapping

z Example:

glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP ) glTexParameteri( GL_TEXTURE_2D,

GL_TEXTURE_WRAP_T, GL_REPEAT )

texture s t

GL_CLAMP wrapping GL_REPEAT

Fungsi berkaitan dengan Tekstur

z

Controls how texture is applied

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

z

GL_TEXTURE_ENV_MODE

modes

z GL_MODULATE

z GL_BLEND

z GL_REPLACE

Tips untuk Koreksi Perspektif

z Texture coordinate and color interpolation

z either linearly in screen space

z or using depth/perspective values (slower) z Noticeable for polygons “on edge”

z glHint( GL_PERSPECTIVE_CORRECTION_HINT, hint )

where hint is one of

z GL_DONT_CARE z GL_NICEST

Adakah tempat untuk Tekstur?

z Query largest dimension of texture image

z typically largest square texture

z doesn’t consider internal format size

z glGetIntegerv( GL_MAX_TEXTURE_SIZE, &size

)

z Texture proxy

z will memory accommodate requested texture size? z no image specified; placeholder

z if texture won’t fit, texture state variables set to 0

z doesn’t know about other textures

Texture Residency

z Working set of textures

z _{high-performance, usually hardware accelerated} z textures must be in texture objects

z _{a texture in the working set is resident} z for residency of current texture, check

GL_TEXTURE_RESIDENT state

z If too many textures, not all are resident

z can set priority to have some kicked out first

Imaging and Raster Primitives

z

_{Describe OpenGL’s raster primitives:}

bitmaps and image rectangles

Pixel-based primitives

z

_Bitmaps

z 2D array of bit masks for pixels

z update pixel color based on current color

z

_Images

z 2D array of pixel color information

z complete color information for each pixel

Frame Buffer Rasterization

(including Pixel Zoom)

Per Fragment Operations

Texture Memory Pixel-Transfer

Operations (and Pixel Map) CPU

Pixel Storage

Modes

glReadPixels(), glCopyPixels() glBitmap(), glDrawPixels()

glCopyTex*Image();

Pixel Pipeline

z

_{Programmable pixel storage}

and transfer operations

CPU CPU

DL DL Poly.

Positioning Image Primitives

z

glRasterPos3f(

x, y, z

)

z raster position transformed like geometry

z discarded if raster position is outside of viewport

z may need to fine tune

viewport for desired results

Rendering Bitmaps

z glBitmap( width, height, xorig, yorig, xmove, ymove, bitmap )

z render bitmap in current color at

Rendering Fonts using Bitmaps

z

_{OpenGL uses bitmaps for font rendering}

z each character is stored in a display list containing a bitmap

z window system specific routines to access system fonts

z glXUseXFont()

Rendering Images

z glDrawPixels( width, height, format, type, pixels )

z render pixels with lower left of image at current raster position

z numerous formats and data types for specifying storage in memory

z best performance by using format and type that

Reading Pixels

z glReadPixels( x, y, width, height, format, type, pixels )

z read pixels from specified ₍x,y) position in

framebuffer

z pixels automatically converted from

framebuffer format into requested format and type

z

Framebuffer pixel copy

z glCopyPixels( x, y, width, height,

Raster

Position glPixelZoom(1.0, -1.0);

Pixel Zoom

z

_glPixelZoom(

_{x, y}

₎

z expand, shrink or reflect pixels around current raster position

Storage and Transfer Modes

z

_{Storage modes control accessing}

memory

z byte alignment in host memory

z extracting a subimage

z

Transfer modes allow modify pixel

values

z scale and bias pixel component values

Advanced OpenGL Topics

z

_{Display Lists and Vertex Arrays}

z

_{Alpha Blending and Antialiasing}

z

_{Using the Accumulation Buffer}

z

_Fog

z

_{Feedback & Selection}

Immediate Mode versus Display Listed

Rendering

z Immediate Mode Graphics

z Primitives are sent to pipeline and display right

away

z No memory of graphical entities z Display Listed Graphics

z Primitives placed in display lists

z Display lists kept on graphics server z Can be redisplayed with different state

Immediate Mode versus

Display Lists

Immediate Mode

Display Listed

Display List

Polynomial Evaluator

Per Vertex Operations &

Primitive Assembly

Rasterization Per Fragment

Display Lists

z

Creating a display list

GLuint id;

void init( void ) {

id = glGenLists( 1 );

glNewList( id, GL_COMPILE ); /* other OpenGL routines */ glEndList();

}

z

Call a created list

void display( void ) {

glCallList( id ); }

Display Lists

z Not all OpenGL routines can be stored in display lists

z State changes persist, even after a display list is finished

z Display lists can call other display lists

z Display lists are not editable, but you can fake it

Display Lists and Hierarchy

z

_{Consider model of a car}

z Create display list for chassis

z Create display list for wheel

z glNewList( CAR, GL_COMPILE ); z glCallList( CHASSIS );

z glTranslatef( … ); z glCallList( WHEEL ); z glTranslatef( … ); z glCallList( WHEEL );

z …

Advanced Primitives

z

_{Vertex Arrays}

z

_{Bernstein Polynomial Evaluators}

z basis for GLU NURBS

z NURBS (Non-Uniform Rational B-Splines)

z

_{GLU Quadric Objects}

z sphere

z cylinder (or cone)

Vertex

Poly. Per Vertex

z Pass arrays of vertices, colors, etc. to OpenGL in a large chunk

z glVertexPointer( 3, GL_FLOAT, 0, coords ) z glColorPointer( 4, GL_FLOAT, 0, colors ) z glEnableClientState( GL_VERTEX_ARRAY ) z glEnableClientState( GL_COLOR_ARRAY ) z glDrawArrays( GL_TRIANGLE_STRIP, 0,

numVerts );

Why use Display Lists or Vertex

Arrays?

z

_{May provide better performance than}

immediate mode rendering

z

_{Display lists can be shared between}

multiple OpenGL context

z reduce memory usage for multi-context applications

z

_{Vertex arrays may format data for better}

Alpha: the 4

th

Color Component

z

_{Measure of Opacity}

z simulate translucent objects

z glass, water, etc.

z composite images

z antialiasing

z ignored if blending is not enabled

Blending

z

_{Combine pixels with what’s in already}

in the framebuffer

z

glBlendFunc(

src, dst

)

Framebuffer

Multi-pass Rendering

z

_{Blending allows results from multiple}

drawing passes to be combined together

z enables more complex rendering algorithms

Example of bump-mapping done with a multi-pass

Antialiasing

z

_{Removing the Jaggies}

z

glEnable(

mode

)

z GL_POINT_SMOOTH z GL_LINE_SMOOTH

z GL_POLYGON_SMOOTH

z alpha value computed by computing sub-pixel coverage

Accumulation Buffer

z

_{Problems of compositing into color}

buffers

z limited color resolution

z clamping

z loss of accuracy

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

Accessing Accumulation Buffer

z

glAccum(

op, value

)

z operations

z within the accumulation buffer: GL_ADD,

GL_MULT

z from read buffer: GL_ACCUM, GL_LOAD z transfer back to write buffer: GL_RETURN

z glAccum(GL_ACCUM, 0.5) multiplies

Accumulation Buffer Applications

z

_Compositing

z

_{Full Scene Antialiasing}

z

_{Depth of Field}

z

_Filtering

Full Scene Antialiasing :

Jittering

the view

z

_{Each time we move the viewer, the}

image shifts

z Different aliasing artifacts in each image

z Averaging images using accumulation buffer averages out

Depth of Focus :

Keeping a

Plane in Focus

z

_{Jitter the viewer to keep one plane}

unchanged

Front Plane Back Plane

Focal Plane

Fog

z glFog{if}( property, value )

z

Depth Cueing

z Specify a range for a linear fog ramp

z GL_FOG_LINEAR

z

Environmental effects

z Simulate more realistic fog

1

3

Feedback Mode

z

_{Transformed vertex data is returned to}

the application, not rendered

z useful to determine which primitives will make it to the screen

z

Need to specify a feedback buffer

z glFeedbackBuffer( size, type, buffer )

z

Select feedback mode for rendering

Selection Mode

z

_{Method to determine which primitives are}

inside the viewing volume

z

Need to set up a buffer to have results

returned to you

glSelectBuffer(

glSelectBuffer( size, buffersize, buffer ))

z

Select selection mode for rendering

Selection Mode (cont.)

z

_{To identify a primitive, give it a name}

z “names” are just integer values, not strings

z

Names are stack based

z allows for hierarchies of primitives

z

_{Selection Name Routines}

glLoadName( name ) glPushName( name )

Picking

z

_{Picking is a special case of selection}

z

_{Programming steps}

z restrict “drawing” to small region near pointer

use gluPickMatrix() on projection matrix

z enter selection mode; re-render scene

z primitives drawn near cursor cause hits

Picking Template

glutMouseFunc( pickMe );

void pickMe( int button, int state, int x, int y ) {

GLuint nameBuffer[256]; GLint hits;

GLint myViewport[4];

if (button != GLUT_LEFT_BUTTON || state != GLUT_DOWN) return;

glGetIntegerv( GL_VIEWPORT, myViewport ); glSelectBuffer( 256, nameBuffer );

Picking Template (cont.)

glMatrixMode( GL_PROJECTION ); glPushMatrix();

glLoadIdentity();

gluPickMatrix( (GLdouble) x, (GLdouble)

(myViewport[3]-y), 5.0, 5.0, myViewport );

/* gluPerspective or glOrtho or other projection */

glPushName( 1 );

/* draw something */

glLoadName( 2 );

Picking Template (cont.)

glMatrixMode( GL_PROJECTION ); glPopMatrix();

hits = glRenderMode( GL_RENDER );

/* process nameBuffer */

Picking Ideas

z For OpenGL Picking Mechanism

z only render what is pickable (e.g., don’t clear

screen!)

z use an “invisible” filled rectangle, instead of text

z if several primitives drawn in picking region, hard to

use z values to distinguish which primitive is “on top”

z Alternatives to Standard Mechanism

z color or stencil tricks (for example, use

Getting to the Framebuffer

Test DitheringDithering

Scissor Box

z

_{Additional Clipping Test}

z

glScissor(

x, y, w, h

)

z any fragments outside of box are clipped

z useful for updating a small section of a viewport

Alpha Test

z

_{Reject pixels based on their alpha value}

z

glAlphaFunc(

func, value

)

z

glEnable(

GL_ALPHA_TEST

)

z use alpha as a mask in textures

CPU CPU

DL DL Poly.

Stencil Buffer

z

_{Used to control drawing based on values}

in the stencil buffer

z Fragments that fail the stencil test are not drawn

z Example: create a mask in stencil buffer and draw only objects not in mask area

CPU CPU

DL DL Poly.

Controlling Stencil Buffer

z glStencilFunc( func, ref, mask )

z compare value in buffer with ref using func z only applied for bits in mask which are 1

z func is one of standard comparison functions

z glStencilOp( fail, zfail, zpass )

z Allows changes in stencil buffer based on passing

or failing stencil and depth tests: GL_KEEP,

Creating a Mask

z glInitDisplayMode( …|GLUT_STENCIL|… ); z glEnable( GL_STENCIL_TEST );

z glClearStencil( 0x0 );

z glStencilFunc( GL_ALWAYS, 0x1, 0x1 ); z glStencilOp( GL_REPLACE, GL_REPLACE,

GL_REPLACE );

Using Stencil Mask

z

_{Draw objects where stencil = 1}

z glStencilFunc( GL_EQUAL, 0x1, 0x1 )

z

_{Draw objects where stencil != 1}

z glStencilFunc( GL_NOTEQUAL, 0x1,

0x1 );

z glStencilOp( GL_KEEP, GL_KEEP,

GL_KEEP );

Dithering

z glEnable( GL_DITHER )

z

Dither colors for better looking results

Logical Operations on Pixels

z

_{Combine pixels using bitwise logical}

operations

z

glLogicOp(

mode

)

z Common modes

Advanced Imaging

z

_{Imaging Subset}

z Only available if GL_ARB_imaging defined

z Color matrix z Convolutions z Color tables z Histogram z MinMax

On-Line Resources

z http://www.opengl.org

z start here; up to date specification and lots of sample code

z news:comp.graphics.api.opengl

z http://www.sgi.com/software/opengl

z http://www.mesa3d.org/

z Brian Paul’s Mesa 3D

z http://www.cs.utah.edu/~narobins/opengl.html

Buku

z

_{OpenGL Programming Guide, 3}

rd

_Edition

z

_{OpenGL Reference Manual, 3}

rd

_Edition

z

_{OpenGL Programming for the X Window}

System

z includes many GLUT examples

z

_{Interactive Computer Graphics: A}