Docstoc

An Interactive Introduction to OpenGL Programming - PowerPoint

Document Sample
An Interactive Introduction to OpenGL Programming - PowerPoint Powered By Docstoc
					Yrd. Doç. Dr. Altan Mesut
Konular:
 OpenGL’in ve kullanım alanlarının tanıtımı
 OpenGL’in yeteneklerinin ve özelliklerinin gösterimi
  ve tanıtılması
 Etkileşimli bir 3 boyutlu grafik programının OpenGL
  ile yazılması
İlgili WEB siteleri
 http://www.opengl.org/
 http://www.opengl.org/documentation/red_book/
 http://www.opengl.org/resources/libraries/glut/
 http://www.opengl.org/resources/code/samples/s2001/
 http://www.opengl-redbook.com/
 http://www.opengl-redbook.com/s2006/
OpenGL nedir?
 OpenGL bilgisayar grafiği çizmek için bir API’dir
 Temel geometrik şekiller ve görüntüler ile yüksek
  kalitede renkli görüntüler oluşturur
 3 boyutlu grafikler ile etkileşimi uygulamalar yaratır
 İşletim sisteminden ve pencere sisteminden
  bağımsızdır
İlgili kütüphaneler (API’ler)
 GLU (OpenGL Utility Library)
   OpenGL’in bir parçasıdır
   Eğriler, yüzeyler, yüzey döşeme görüntüleri, … içerir.

 AGL, GLX, WGL
   OpenGL ile pencere sistemleri arasındaki katmandır

 GLUT (OpenGL Utility Toolkit)
   Daha yalın bir pencere sistemi bütünleştirmesi sunar
   Resmi anlamda OpenGL’in parçası değildir
OpenGL ve ilgili API’ler
                   uygulama programı

    OpenGL Motif
    veya benzeri         GLUT
             GLX, AGL
             veya WGL             GLU

   X, Win32, Mac O/S                   GL

             yazılım ve/veya donanım
Basit Bir Program
 Siyah bir arka plan üzerine beyaz bir kare çizer.
#include <GL/glut.h>              simple.c
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();
}
Olay Döngüsü
 Her GLUT programı bir gösterim fonksiyonu içerir.
  Bizim programımızda da mydisplay adında bir
  gösterim fonksiyonu vardır.
 Görüntünün tazelenmesini gerektiren bir olay
  olduğunda (mesela pencere açıldığında) gösterim
  fonksiyonu çağrılır.
 Ana fonksiyon (main) programın bir olay döngüsüne
  girmesi ile son bulur.
OpenGL Programının Genel Yapısı

Bir pencere
yapılandır
   ve aç      OpenGL
              durumu
               başlat   Kullanıcı
                        olaylarını
                           işle      Görüntüyü
                                        çiz
Bir OpenGL Programı
#include <GL/glut.h>
#include "cube.h"

void main( int argc, char *argv[] )
{
  glutInit( &argc, argv );
  glutInitDisplayMode( GLUT_RGBA |
                       GLUT_DEPTH );
  glutCreateWindow( argv[0] );          Programın ‘main’
                                       bölümünde: OpenGL
    init();                            penceresini açmak ve
    glutDisplayFunc( display );         kullanıcıdan girdi
    glutReshapeFunc( reshape );         almak için GLUT
                                            kullanılır.
    glutMainLoop();
}
Bir OpenGL Programı (devam)
void init( void )
{                                             Bir başlangıç
  glClearColor( 0, 0, 0, 1 );
  gluLookAt( 2, 2, 2, 0, 0, 0, 0, 1, 0 );
                                             OpenGL durumu
  glEnable( GL_DEPTH_TEST );                  yapılandırılır.
}


void reshape( int width, int height )
{                                                   Kullanıcı
  glViewport( 0, 0, width, height );                 pencere
  glMatrixMode( GL_PROJECTION );
  glLoadIdentity();                                 boyutunu
  gluPerspective( 60, (GLfloat) width / height,   değiştirdiğinde
                  1.0, 10.0 );                      kullanılır.
  glMatrixMode( GL_MODELVIEW );
}
Bir OpenGL Programı (devam)
void display( void )
{
  int i, j;

    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
                                                              OpenGL
    glBegin( GL_QUADS );                                         3D
    for ( i = 0; i < NUM_CUBE_FACES; ++i ) {                noktalardan
      glColor3fv( faceColor[i] );
      for ( j = 0; j < NUM_VERTICES_PER_FACE; ++j ) {       (vertices) bir
        glVertex3fv( vertex[face[i][j]] );                    küp çizer.
      }
    }
    glEnd();

    glFlush();
}
  OpenGL Komut Biçimi
                  glVertex3fv( v )

kütüphane


                         Veri Tipi                 Vektör
                    b    -   byte             skalar düzende “v”
 Bileşen Sayısı     ub   -   unsigned byte        yer almaz
                    s    -   short
  2 - (x,y)         us   -   unsigned short
  3 - (x,y,z)                                 glVertex2f( x, y )
                    i    -   int
  4 - (x,y,z,w)     ui   -   unsigned int
                    f    -   float
                    d    -   double
Programlarda neler gerekli?
 Header Dosyalar
    #include <GL/gl.h>
    #include <GL/glu.h>
    #include <GL/glut.h>
 Kütüphaneler
   opengl32.lib, glut.lib, glut32.lib
 Veri Tipleri (uyumluluk için)
   GLfloat, GLint, GLenum, …
GLUT Callback Fonksiyonları
 Bir olay gerçekleştiğinde çağrılacak rutin
   Pencere büyüklüğü değişimi
   Kullanıcı girişi
   Animasyon
 GLUT ile callback’lerin kaydedilmesi
    glutDisplayFunc( display );
    glutIdleFunc( idle );
    glutKeyboardFunc( keyboard );
    …
OpenGL neleri çizebilir?
 Temel geometrik şekiller
   noktalar, çizgiler ve çokgenler

 Temel resimler (image)
   Resim ve bitmap’ler
   Resim ve geometri için farklı işlem hattı var
                                                      s11-Fig1.2
       doku kaplaması sırasında birbirine bağlanır
 Duruma bağlı çizimler
   renkler, materyaller, ışık kaynakları, ...
 OpenGL Geometrik Şekilleri
  Tüm geometrik şekiller köşe noktaları ile belirlenir



 GL_POINTS                                               GL_POLYGON
             GL_LINES   GL_LINE_STRIP

                                        GL_LINE_LOOP


               GL_TRIANGLES
                                                      GL_QUAD_STRIP

GL_TRIANGLE_STRIP        GL_TRIANGLE_FAN
                                           GL_QUADS
Bir Geometrik Şekli Tanımlama
 Temel şekiller aşağıdaki iki fonksiyon ile tanımlanır:
       glBegin( şekilTipi );
       glEnd();
   şekilTipi noktaların nasıl bir araya getirileceğini belirler

    glBegin( şekilTipi );
    for ( i = 0; i < n; ++i ) {
      glColor3f( red[i], green[i], blue[i] );
      glVertex3fv( coords[i] );
    }
    glEnd();
OpenGL Nasıl Çalışır?

     OpenGL’in
    nesneyi nasıl
                        Nesneyi çiz
     çizeceğini
       tanımla
OpenGL’in Çizimini Kontrol Etme
 OpenGL’in çizim durumunu (state) tanımlama:
   Durum, nesnelerin nasıl çizileceğini belirleyen değerler
    kümesidir.
   Mavi bir üçgen çizilecekse, önce mavi renk glColor
    fonksiyonu ile ayarlanır, sonra çizgiler glVertex ile
    oluşturulur.
     gölgelendirme             – ışık
     doku kaplama              – çizgi stilleri (stipples)
     çokgen kalıpları          – şeffaflık
OpenGL durum kontrolünün gücü

Görünüm
OpenGL’in
durumunu
tanımlamakla
kontrol edilir.
OpenGL’in Durumunu Tanımlama
    OpenGL’in durumunu tanımlamak için 3 yöntem
     vardır:
    1.   Noktaları işlemek için kullanılan değerleri tanımlama
            Durumu tanımlamanın en genel yöntemleri:
                glColor() / glIndex()
                glNormal()
                glTexCoord()
            Durum glVertex() ten önce tanımlanmalıdır.
OpenGL’in Durumunu Tanımlama
 2.   Bir çizim biçimini açma
                glEnable() / glDisable()
 3.   Belirli bir çizim biçiminin özelliklerini tanımlama
         Her biçim kendi değerlerini tanımlamak için özel
          komutlar içerir.
                         glMaterialfv()
OpenGL’de Renk Modeli
 OpenGL RGB renk uzayını kullanır
    Sıralı renk (indexed color) biçimi de vardır, ama pek
     kullanılmaz
 Renkler [ 0.0, 1.0] aralığındaki ondalıklı sayılar ile veya
  [0,255] aralığındaki tamsayılar ile temsil edilirler
    Örneğin pencerenin arka plan rengini belirlemek için
    aşağıdaki fonksiyon kullanılabilir:
      glClearColor( 1.0, 0.3, 0.6, 1.0 );
          glColor3ub( 240, 130, 100 );
Genişletilmiş simple.c
 Çıktı aynı olacak, fakat tüm ilgili durum değerleri
  tanımlanacak.
 Tanımlanan değerler:
   Renkler
   Görüntüleme koşulları
   Pencere özellikleri
                                           gl.h ve glu.h da
#include <GL/glut.h>
                                           glut.h ile eklenir

int main(int argc, char** argv)
{
  glutInit(&argc,argv);
  glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);
  glutInitWindowSize(500,500);
  glutInitWindowPosition(0,0);
  glutCreateWindow("simple");     Pencere özellikleri tanımlandı
  glutDisplayFunc(mydisplay);
                                        Görüntüleme callback fonksiyonu
    init();
                        OpenGL durumu tanımlandı
    glutMainLoop();
}                            Olay döngüsüne giriş
GLUT fonksiyonları
 glutInit uygulamanın komut satırından bilgi almasını ve
  sistemi başlatmasını sağlar
 gluInitDisplayMode pencere için çizim özelliklerini
  belirler. Örneğimizde seçilen değerler:
   RGB renk biçimi
   Tekli tampon biçimi
 glutWindowSize piksel olarak pencere boyutu
 glutWindowPosition ekranın sol üst köşesinden uzaklığı
 glutCreateWindow “simple” adındaki pencerenin
  yaratılması
 glutDisplayFunc görüntüleme callback fonksiyonu
 glutMainLoop sonsuz olay döngüsüne giriş
                    Siyah arka plan rengi
void init()                       Mat pencere
{
  glClearColor (0.0, 0.0, 0.0, 1.0);

    glColor3f(1.0, 1.0, 1.0);               Beyaz ile çizme veya doldurma

    glMatrixMode (GL_PROJECTION);
    glLoadIdentity ();
    glOrtho(-1.0, 1.0, -1.0, 1.0, -1.0, 1.0);
}
                  Görünüm biçimi
Şekiller Uygulaması
3D Görüntüleme = Fotoğraf
Çekme
 3 boyutlu görüntüleme fotoğraf çekmeye benzer.
    Objenin konumlandırılması (modeling)
    Kameranın yerleştirilmesi (viewing)
    Lens seçimi (projection)
                                 görüş alanı
    Görüş alanı (viewport)

  kamera

                                model
   tripod
Koordinat Sistemleri ve
Dönüşümler
    Görüntüyü oluşturma adımları:
    1.   Geometriyi belirleme (dünya koordinatları)
    2.   Kamerayı belirleme (kamera koordinatları)
    3.   Görüntüleme biçimini belirleme (pencere koordinatları)
    4.   Görüş alanına eşleme (ekran koordinatları)
    Bütün adımlarda dönüşümler kullanılabilir.
    Her dönüşüm koordinat sistemlerinde bir
     değişime denk gelir.
Homojen Koordinatlar
  Her vertex (köşe noktası) bir vektördür (kolon).
                            x 
                            y
                           
                         v
                            z 
                             
                             w
  w genellikle 1’dir.
  Tüm dönüşüm işlemleri matris çarpımları ile
  yapılır.
3D Dönüşümler
 Noktalar 4 x 4 boyutunda matrisler ile çarpılarak
  dönüştürülürler
 Tüm matrisler sütun-öncelikli olarak kaydedilirler
 En son tanımlanan matris en önce çarpılandır (dönüşüm
  matrisi solda, vertex matrisi sağda)
 Matrisin gösterimi:


                    m0     m4   m8    m12 
                    m      m5   m9    m13 
                  M 1                    
                     m2    m6   m10   m14 
                                          
                     m3    m7   m11   m15 
Dönüşümleri Belirleme
 Dönüşümler iki farklı yöntem ile belirlenebilir:
    Matrisleri belirleyerek
     glLoadMatrix, glMultMatrix
    İşlemi belirleyerek
     glRotate, glOrtho
 Programcı gerçek matrisin ne olduğunu bilmek
 zorunda değildir.
Dönüşümleri Programlama
 Kameranın pozisyonu ve cisimlerin 3D geometrisi ile
  ilgili çizme, görüntüleme, konumlandırma ve
  yönlendirme işlemlerinden önce matrislerin hangi
  işlem için düzenleneceği belirtilmelidir:
  glMatrixMode(GL_PROJECTION)
 Dönüşümler ilgili sırada bir araya getirilir. Artarda
  yazılan dönüşümler son yazılandan ilk yazılana doğru
  gerçekleştirilir.
Matris İşlemleri
 Matris yığınını (stack) belirleme
   glMatrixMode(GL_MODELVIEW veya GL_PROJECTION)
 Diğer Matris veya Yığın İşlemleri
           glLoadIdentity()                glPushMatrix()
                            glPopMatrix()
 Viewport
    Genellikle pencere genişliği ile aynıdır
    Eğer viewport genişlik/yükseklik oranı projeksiyondakinden
     farklı ise nesneler olduklarından farklı biçimde görünebilirler
     (daha geniş, daha yüksek, …)
        glViewport( x, y, genişlik, yükseklik )
Projeksiyon Dönüşümü
 Perspektif izdüşümde (projeksiyon)
  görünüm uzayı frustum adı verilen
  kesik piramit gibidir.
 Perspektif izdüşüm
  gluPerspective( fovy, aspect, zNear, zFar )
  glFrustum( left, right, bottom, top, zNear, zFar )
 Orthografik parallel izdüşüm
  glOrtho(left, right, bottom, top, zNear, zFar)
  gluOrtho2D( left, right, bottom, top )
       calls glOrtho with z values near zero
İzdüşüm Dönüşümlerini
Uygulamak
 Orthografik izdüşüm için tipik kullanım örneği:
  glMatrixMode( GL_PROJECTION );
  glLoadIdentity();
  glOrtho(left, right, bottom, top, zNear, zFar);
 Dönüşümleri Görmek
 Kamerayı konumlandırma
   Kamera ayağını aç ve kamerayı yerleştir
                                                  tripod
 Bir sahnede hareket etmek için
   Görüntüleme dönüşümünü değiştir ve sahneyi
    tekrar çiz
       gluLookAt( eyex, eyey, eyez,
                       aimx, aimy, aimz,
                       upx, upy, upz )
   Yukarı (up) vektör kameranın üstünün neresi
    olduğunu belirler
İzdüşüm Uygulaması
Konumlandırma Dönüşümlerini
Uygulamak
 Nesneyi taşımak:
  glTranslate{fd}( x, y, z )
 Nesneyi bir eksen etrafında döndürmek:
  glRotate{fd}( açı, x, y, z )
   Açı derece cinsinden girilir

 Nesneyi büyütmek/küçültmek,
  genişletmek/daraltmak ve yansımasını
  oluşturmak:
  glScale{fd}( x, y, z )
Dönüşüm Uygulaması
Kamera yeri ve konumlandırma
arasındaki ilişki
 Kamerayı belirli bir doğrultuda taşıma ile
  görüntülenen dünyadaki tüm nesneleri tam tersi olan
  doğrultuda taşıma arasında bir fark yoktur.
 Görüntüleme dönüşümleri birçok konumlandırma
  dönüşümüne eşittir.
   gluLookAt() komutunun yaptığı işi birçok
    glTranslete ve glRotate kombinasyonu ile
    yapabilirsiniz.
Konumlandırma Dönüşümlerini
Beraber Kullanma
 Problem: Hiyerarşik Nesneler
   Bir pozisyon bir önceki pozisyona bağlı
   Robot kolu veya el gibi birleşik yapılar
 Çözüm:
   Sütun-öncelikli matrisler ilgili sırada çarpılmalıdır
   Taşımayı takip eden döndürme ile döndürmeyi takip
   eden taşıma aynı sonucu vermez
       Matris çarpımı sıra-bağımlı bir işlemdir.
Konumlandırma Dönüşümlerini
Beraber Kullanma
 Problem: Nesne görüntülenen dünyanın
 merkezine göre konumlanır
   Nesneyi kendi etrafında döndürmek isterken başka bir
    eksen etrafında dönüyor
 Çözüm: sabit koordinat sistemi
   Konumlandırma dönüşümlerinden önce nesneyi
    merkeze taşı
   İstenilen döndürmeyi yaptıktan sonra önceki taşımanın
    tersi ile tekrar eski noktaya taşı
Çift Tampon


           1                    1
               2                    2
                   4                    4
   Ön Tampon           8                    8         Arka Tampon
                           16                   16




                                            Görüntü
Animasyon
 Çift renk tamponu kullanımı isteği yapılır
      glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE );
 Renk tamponu temizlenir
      glClear( GL_COLOR_BUFFER_BIT );
 Sahne çizimi yapılır
 Ön ve arka tamponlar yer değiştirilir
      glutSwapBuffers();
 2, 3 ve 4. adımlar tekrar edilerek animasyon
   sağlanır
      glutIdleFunc() callback kullanılır
Derinlik Tamponu ve
Saklı Yüzeylerin Atılması


            1                    1
                2                    2
                    4                    4
  Renk Tamponu          8                    8         Derinlik Tamponu
                            16                   16




                                             Görüntü
Derinlik Tamponu Kullanımı
 Derinlik tamponu kullanımı isteği yapılır
      glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE
        | GLUT_DEPTH );
 Özellik aktif hale getirilir
      glEnable( GL_DEPTH_TEST );
 Renk ve derinlik tamponları temizlenir
      glClear( GL_COLOR_BUFFER_BIT |
        GL_DEPTH_BUFFER_BIT );
 Sahne çizilir
 Renk tamponları yer değiştirilir
Işıklandırma İlkeleri
 Işıklandırma işleminde nesnelerin ışığı nasıl
  yansıtacağı belirlenir.
 Etki eden faktörler:
   Nesnelerin malzeme bileşimi
   Işığın rengi ve yönü
   Evrensel ışıklandırma parametreleri
     Çevresel ışıl
     İki yönlü ışık

   Hem color index hem de
    RGBA biçimlerinde çalışır
OpenGL ışığı nasıl kullanır
 OpenGL’de ışıklandırma Phong ışıklandırma modeline
  dayanır. Çizim ilkelinin her noktasında, bir renk o
  ilkelin malzeme özelliklerinin ışık ayarları ile birlikte
  kullanılması ile hesaplanır.
 Bir noktanın ışık altındaki rengini bulmak için, o
  noktaya verilen renk haricinde 4 bileşenin daha
  bilinmesine gerek vardır. Bunlar:
   Ambient
   Diffuse
   Specular
   Emmission
Işığın Bileşenleri
 Ambient: Hangi noktadan geldiği tam olarak
  belirlenemeyen (tüm yönlerden geliyormuş gibi
  görünen) çevresel ışık bileşenidir.
 Diffuse: Tek bir noktadan gelen ışık bileşenidir.
 Specular: Belirli bir noktadan gelen ve parlak yüzeyli
  nesnelerde yansıma yapan ışık bileşenidir.
 Emission: Işık yayan yüzeylerdeki ışık bileşenidir. Işık
  sanki nesnenin içinde parlıyor gibi algılanır.
Yüzey Normalleri
 Normaller bir yüzeyin ışığı nasıl yansıtacağını belirler
  glNormal3f( x, y, z )
 Geçerli olan normal vektörü vertex’in renginin
  hesaplanmasında kullanılır.
 Normallerin otomatik olarak ayarlanması için
  glEnable( GL_NORMALIZE )
  veya düzgün olmayan ölçeklemelerde
  glEnable( GL_RESCALE_NORMAL )
  kullanılır.
Malzeme Özellikleri
 Yüzey özelliklerini belirleyen fonksiyon:
    glMaterialfv( yüzey, özellik, değer );
  GL_DIFFUSE         Temel renk
  GL_SPECULAR        Yansıma noktasındaki renk

  GL_AMBIENT         Nesnenin direkt ışık almadığı zamanki rengi

  GL_EMISSION        Nesnenin yaydığı ışığın rengi
  GL_SHININESS       Işığı yansıtma değeri (0-128)

   Ön ve arka yüzeyde farklı malzeme kullanılmış olabilir
     GL_FRONT, GL_BACK, GL_FRONT_AND_BACK
Işık Kaynakları
  glLightfv( ışık, özellik, değer );
   ışık parametresi n farklı ışık değerinden birini alır
       GL_LIGHT0 – GL_LIGHTn
            glGetIntegerv( GL_MAX_LIGHTS, &n );
   özellikler
       Renkler (GL_AMBIENT, GL_DIFFUSE, GL_SPECULAR)
       Yer (GL_POSITION)
       Tip (GL_SPOT_...)
       Zayıflama (GL_..._ATTENUATION)
Işık Tipleri
 OpenGL iki farklı ışık tipi sağlar
    Lokal (Nokta) ışık kaynakları
    Sonsuz (Doğrusal) ışık kaynakları
 Işık tipi w koordinatı ile belirlenir

        w  0    sonsuz bir ışık x y z 
   eğer 
                                    
          w  0 noktasal bir ışık x w y w z w   
Işıkları Aktif Hale Getirme
 Işıklandırmayı açma:
   glEnable( GL_LIGHTING );
 Işık kaynağının düğmesini açma:
   glEnable( GL_LIGHTn );
Işık Malzeme Uygulaması
Işığın yer ve yön kontrolü
 Modelview matrisindeki değişim ışığın yönünü de
 etkiler
   Işığın ne zaman tanımlandığına göre farklılık gösterir
     göz koordinatları (ışık hep aynı noktadan geliyor; güneş)
     dünya koordinatları (sahnede sabit ışık kaynakları var; lamba)
     model koordinatları (hareketli ışık; el feneri & araba farı)

   Işığın yerini kontrol etmek için matrisler push ve pop
    edilebilir.
Işık Yönü Uygulaması
Spot Işık
 Işığın etkisini merkezileştirir
    GL_SPOT_DIRECTION
    GL_SPOT_CUTOFF
    GL_SPOT_EXPONENT




                                    65
Işığın Mesafe ile Zayıflaması
 Mesafe arttıkça ışık yoğunluğu azalır.
 Bu özellik kullanılırsa gerçeklik artar.
    GL_CONSTANT_ATTENUATION
    GL_LINEAR_ATTENUATION
    GL_QUADRATIC_ATTENUATION


                             1
               fi 
                    k c  kl d  k q d 2




                                             66
Işık Modeli Özellikleri
       glLightModelfv( özellik, değer );
 İki yönlü ışıklandırma sağlamak için
  GL_LIGHT_MODEL_TWO_SIDE,{0.2, 0.2, 0.2, 1.0}
 Evrensel bir çevresel ışık rengi vermek için
  GL_LIGHT_MODEL_AMBIENT, GL_FALSE (GL_TRUE)
 Viewpoint değiştikçe ışığın etkisinin de değişmesi
  GL_LIGHT_MODEL_LOCAL_VIEWER, GL_FALSE
   (GL_TRUE)
 Doku kaplamada daha iyi renk kontrolü için
  GL_LIGHT_MODEL_COLOR_CONTROL, GL_SINGLE_COLOR
  (GL_SEPARATE_SPECULAR_COLOR)
                                                       67
Işığı iyi kullanmak için:
 Modeldeki ayrıntının çokluğunun ışık işlemlerini de
  yavaşlatacağı unutulmamalıdır.
 Hızlı ışıklandırma için tek bir sonsuz ışık kaynağı
  kullanılmalıdır.
   Vertex başına en düşük hesaplama
Doğrudan çizim yerine
Görüntüleme Listeleri ile çizim
 Doğrudan çizim
   Çizim ilkelleri çizim hattına gönderilerek direkt olarak
    çizilir
   Çizilenler hafızada kalıcı değildir
 Görüntüleme Listeleri ile çizim
   Çizim ilkelleri görüntüleme listelerine yerleştirilir
   Görüntüleme listeleri grafik sunucusunda tutulur
   Farklı bir şekilde tekrar çizim yapılabilir
   OpenGL grafik ortamları tarafından paylaşılabilir
Doğrudan çizim yerine
Görüntüleme Listeleri ile çizim
                Doğrudan Çizim



                 Polinom         Vektör tabanlı
                Hesaplayıcı         işlemler &
                                  İlkel Montajı



          Görüntüleme                                 Bölümleme     Çerçeve
CPU                                   Tarama İşlemi
            Listesi                                    İşlemleri   Tamponu


Görüntüleme
Listeli Çizim                         Doku
                                     Hafızası
                       Piksel
                     İşlemleri
Listeyi yaratma ve çağırma
 Görüntüleme Listesini Oluşturma
   GLuint id;
   void init( void )
   {
      id = glGenLists( 1 );
      glNewList( id, GL_COMPILE );
      /* diğer OpenGL fonksiyonları */
      glEndList();
   }

 Yaratılmış bir listeyi çağırma
   void display( void )
   {
      glCallList( id );
   }
Görüntüleme Listeleri
 Bir liste sonlandıktan sonra bile içerdiği durum
  değişiklikleri kalıcıdır. *
 Tüm OpenGL fonksiyonları görüntüleme
  listelerinde saklanamaz.
 Görüntüleme listeleri başka görüntüleme
  listelerini çağırabilir.
 Görüntüleme listeleri düzenlenebilir değildir, ama;
  başka listeleri çağıran bir A listesi yapılabilir ve
  çağırdığı listeler gerekirse silinip değiştirilebilir.
Görüntüleme Listeleri
Matris İşlemleri : Matris hesaplamaları OpenGL’de
  bir listede tutulur.
Işık, Madde Özellikleri, Aydınlatma Modelleri :
  Kompleks aydınlatma içeren bir sahne
  çizdiğimizde, sahnedeki her nesne için malzeme
  durumlarını değiştirebiliriz. Bu işlem ciddi
  hesaplamalar içerdiği için malzeme ayarları
  yavaşlayabilir. Eğer malzeme tanımlarını liste
  yöntemiyle tutarsak bu hesaplamaları malzemeleri
  her değiştirdiğimizde yapmak durumunda
  kalmayız. Sadece hesaplama sonuçlarını saklarız,
  bunun sonucunda ise ışık sahnesi hızlanır.
Görüntüleme Listeleri
İmajlar : Taradığımız data formatı donanım için uygun
  olmayabilir. Bir liste derlendiğinde OpenGL veriyi
  donanımın tercih ettiği gösterime dönüştürür. Karakterler
  bitmap’lerden oluştuğu için liste yöntemi ile taranan
  karakter, çizim hızında kayda değer bir etki yapar.
Kaplama : Kaplamayı liste derlenirken tanımlarsak
  maksimum verim elde ederiz. Bu işlem kaplama imajını
  hafızaya alır, böylece her kullanımda bu imajı yeniden
  oluşturmak zorunda kalmayız. Ayrıca kaplamanın
  donanım formatı OpenGL formatından farklı olabilir ve
  dönüşüm liste derleme anında yapılabilir.
Çokgen Desenleri: Geometrik şekiller için de liste yöntemi
  program hızını ve verimliliği artırır.
Görüntüleme Listeleri ve Hiyerarşi
 Bir araba örneğinde;
    Şase için bir görüntüleme listesi oluştur
    Tekerlek için bir görüntüleme listesi oluştur (4 kere
     çağır)
glNewList( CAR, GL_COMPILE );
  glCallList( CHASSIS );
  glTranslatef( … );
  glCallList( WHEEL );
  glTranslatef( … );
  glCallList( WHEEL );
      …
glEndList();
Piksel-tabanlı ilkeller
 Bitmap
    Her piksel için 1 bit bilgi kullanılır.
    Geçerli renk temel alınarak piksel rengi güncellenir.
 Görüntü (Image)
    Her piksel için tüm renk bilgisi kodlanır.
 OpenGL; JPEG, PNG veya GIF gibi görüntü biçimlerini
 tanımaz.
Piksel İşlemleri
 Piksel saklama ve aktarma işlemleri:
Görüntüyü Konumlandırma
          glRasterPos3f( x, y, z )
  Görüntünün çizileceği konum belirlenirken sol-alt
   noktası referans alınır (Tarama Konumu).
  Tarama konumuna geometrik
   cisimlerin köşe noktaları gibi
   dönüşüm uygulanabilir.
  Tarama konumu viewport
   dışında ise göz ardı edilir.


                           Tarama Konumu
Bitmap’lerin Çizimi
  glBitmap( genişlik, yükseklik, xorig, yorig,
                   xmove, ymove, bitmap )
  glRasterPos3f’ten önce kullanılan
   son glColor3f ile belirlenen renk ile
   x  xorig y  yorig
   konumunda çizilir.
 glRasterPos3f ile glBitmap arasında
                                       yorig
 bir glColor3f kullanılması bitmap
 rengini değiştirmez                                   width
  Çizimden sonra tarama konumunu              xorig

   xmove, ymove kadar taşır.                           xmove




                                                                 81
Bitmap kullanarak Font Çizimi
 OpenGL bitmap’leri font çizimi için kullanır.
   Her karakter bitmap içeren bir görüntü listesinde
    saklanır.
   Sistem fontlarına erişmek için pencere sistemine özel
    komutlar da kullanılabilir:
        glXUseXFont()
        wglUseFontBitmaps()
        glutBitmapCharacter(void *font, int char);
          GL_BITMAP_TIMES_ROMAN_24

          GL_BITMAP_HELVETICA_10

          …


                                                            82
Görüntüleri Çizme
  glDrawPixels( genişlik, yükseklik,
      biçim, veri tipi, pikseller)
 Belirlenen tarama konumunu sol-alt
  nokta kabul ederek yukarı doğru
  taranarak görüntü çizilir.
 Hafızadaki saklama türünü belirlemek için birçok
  biçim ve veri tipi vardır (Redbook Tablo 8.1 & 8.2).
   En iyi performansı almak için donanım ile uyumlu biçim
    ve veri tipi kullanılmalıdır.
Pikselleri Okumak
 Çerçeve tamponunda (framebuffer) (x, y) noktasından
 başlayarak belirli genişlik ve yükseklikte piksel verisi
 almak:
  glReadPixels( x, y, genişlik, yükseklik,
          biçim, veri tipi, pikseller )
   Pikseller otomatik olarak çerçeve tamponu biçiminden
    istenilen biçime ve veri tipine dönüştürülür
 Çerçeve tamponundan piksel kopyalama:
  glCopyPixels( x, y, genişlik, yükseklik,
                    tampon )
      glCopyPixels = glReadPixels + glDrawPixels
Piksel Ölçeklendirme (Zoom)
              glPixelZoom( x, y )
  Geçerli olan tarama konumunda pikselleri genişletir,
   daraltır ya da yansıtır.
  Kesirli ölçeklendirme de kullanılabilir.

                            Raster     glPixelZoom(1.0, -1.0);
                            Position




                                                                 85
Saklama ve Aktarma Biçimleri
 Saklama biçimleri hafızaya erişimi denetler
    Hafızadaki bayt sıralamasını ayarlama
    Bir Görüntüden alt-Görüntü çıkarımı
    glPixelStore(): kitap s:325
 Aktarma biçimleri piksel değerlerinin değişimine izin
 verir
   Ölçeklendirme ve meyillendirme
   Piksel haritaları kullanarak renk değişimi
   glPixelTransfer(): kitap s:330


                                                          86
Doku Kaplama
          y


  z           x
                      geometri        ekran



      t
                            Görüntü


                  s
Doku Kaplama ve OpenGL İşlem
Hatları
 Görüntüler ve geometri farklı işlem hatlarını takip
  ederek rasterizer aşamasında birleşirler
 Dokunun karmaşıklığı kaplandığı geometrik nesnenin
  karmaşıklığını etkilemez

      Vektörel
                    geometri işlem hattı
      işlemler
                                            rasterizer
   Piksel tabanlı
      işlemler        piksel işlem hattı
Örnek Uygulama
 Yandaki örnekte 256 × 256
 boyutunda bir Görüntü perspektif
 izdüşümde görüntülenen bir
 poligon üzerine kaplanmıştır.
Doku Kaplamanın Adımları
 1. Dokuyu tanımla
     Bir Görüntüyü oluştur veya dosyadan oku
     Görüntüyü doku ile eşleştir
     Doku kaplamayı etkinleştir

 2. Doku koordinatlarını köşe noktaları ile
    eşleştirme
 3. Doku parametrelerini tanımlama
      Sarmak (wrapping), filtrelemek
Doku Nesneleri
 Görüntüler saklanırken:
   Her doku nesnesi için bir görüntü tanımlanabilir
   Birden fazla grafik içeriği tek bir görüntüyü paylaşabilir

 Doku isimlerinin oluşturulması:
   glGenTextures( n, *texIds );
 Kullanmadan önce dokunun bağlanması:
   glBindTexture( target, id );
       target: GL_TEXTURE_{1,2,3}D
Bir Doku Görüntüsünün
Tanımlanması
  Hafızadaki texel’lerin dizisinden bir doku görüntüsü
  oluşturma:
    glTexImage2D( target, level, internalFormat,
         w, h, border, format, type, *texels );
                                                             Sayfa 380
    level: mipmap haricinde hep sıfır olur.
    internalFormat: R, G, B, A; Luminance; Intensity (38 sabit)
    w, h: görüntünün boyutları (2’nin katları olmalıdır).         Örn:
    border: kenar çizgisi kalınlığı                         Resimden
                                                             sadece R
    format: R, G, B, A; Luminance… ~ glDrawPixels()           bileşeni
    type: veri tipi ~ glDrawPixels()                         seçilebilir
    *texels: görüntünün tanımlı olduğu dizi
Bir Doku Görüntüsünün
Dönüştürülmesi
 Eğer görüntünün boyutları 2’nin katları değilse:
     gluScaleImage( format, w_in, h_in,
           type_in, *data_in, w_out, h_out,
                type_out, *data_out );
   *_in : kaynak Görüntü için
   *_out : hedef Görüntü için
 Ölçeklendirme yapılırken Görüntü interpole edilir
  (tahmin) ve filtrelenir.
Dokuyu Tanımlama:
Diğer Yöntemler
 Doku görüntüsünün kaynağı olarak çerçeve tamponunu
 kullanma:
                 glCopyTexImage1D(...)
                 glCopyTexImage2D(...)
 Tanımlanmış olan bir dokunun belirli bir bölümünü
 kullanma:
                  glTexSubImage1D(...)
                  glTexSubImage2D(...)
                  glTexSubImage3D(...)
 Çerçeve tamponunun bir bölümünü kullanma:
               glCopyTexSubImage*(...)

                                                       95
Bir dokunun eşlenmesi
 glTexCoord*() ile her köşe noktası için
  tanımlanır.
           Doku Uzayı                         Nesne Uzayı
    t                   1, 1                    (s, t) = (0.2, 0.8)
 0, 1                                                      A
           a


                    c            (0.4, 0.2)
               b
                                         B                      C
    0, 0                1, 0 s                            (0.8, 0.4)
Doku Koordinatlarının
Oluşturulması
 Doku koordinatlarının otomatik olarak
 oluşturulması:
   glTexGen{ifd}[v]()
 Bir düzlemden uzaklığına göre oluşturma:
         Ax  By  Cz  D  0
 Oluşturma biçimleri:
   GL_OBJECT_LINEAR: Doku nesneye sabitlenir.
   GL_EYE_LINEAR: Doku kameraya göre sabit durur.
   GL_SPHERE_MAP: Nesnenin etraftaki renkleri
    yansıtması (Terminator 2’deki parlak adam)
Dokuyu Uygulama Yöntemleri
 Filtreleme Yöntemleri
   minification - magnification
   özel mipmap minification filtreleri

 Sarma (Wrap) Yöntemleri
   Kenetleme (clamping)
   Tekrarlama (repeating)

 Doku Fonksiyonları
   Nesnenin rengi ile dokunun renginin nasıl karışacağı
       blend, modulate, replace
Filtreleme Yöntemleri
Örnek:
  glTexParameteri( target, type, mode );




 Doku             Polygon   Doku            Polygon
     Magnification                 Minification
Mipmap
 Mipmap: doku görüntülerinin çözünürlüğünün azaltılmasına
  olanak sağlar.
 İnterpolasyon hatalarını azaltır.
 mipmap seviyesi level parametresi ile belirlenir:
   glTexImage*D( GL_TEXTURE_*D, level, … )
 GLU mipmap oluşturma rutinleri de vardır:
   gluBuild*DMipmaps( … )
 OpenGL 1.2 bu konuda yenilikler getirmiştir:
    Her mipmap seviyesini belirlemeye gerek kalmadı.
Sarma Yöntemleri
 Örnek:
   glTexParameteri( GL_TEXTURE_2D,
        GL_TEXTURE_WRAP_S, GL_CLAMP )
   glTexParameteri( GL_TEXTURE_2D,
        GL_TEXTURE_WRAP_T, GL_REPEAT )


      t


                    s
                        GL_REPEAT   GL_CLAMP
          texture        wrapping    wrapping
Doku Fonksiyonları
 Nesnenin rengi ile dokunun renginin nasıl karışacağı
   glTexEnv{fi}[v]( GL_TEXTURE_ENV, prop, param )
 Özellikler (prop):
   GL_TEXTURE_ENV_MODE yöntemleri:
       GL_MODULATE : doku ile kaplandığı nesnenin rengini
        çarpar
       GL_BLEND: doku, nesne ve verilen renk değerlerinin
        karışımını kullanır
       GL_REPLACE: nesnenin rengi yerine doku rengi kullanılır
   GL_TEXTURE_ENV_COLOR
     Blend rengi için kullanılır
Doku Kaplama Uygulaması
Alpha: 4. Renk Bileşeni
 Şeffaflığın birimidir
    Transparan nesneleri (cam, su, vb.) taklit eder
 Nerede kullanılır:
    Görüntülerin renklerini birleştirmede (blending)
    Örtüşme-önlemede (antialiasing)
    Eğer “blending” etkin değilse göz ardı edilir
                    glEnable( GL_BLEND )
Blending
 Çerçeve tamponunda bulunan değerler ile yeni
 çizilecek değerleri birleştirir.
            glBlendFunc( src, dst )

                                
               Cr  src C f  dst C p
                             Blending
                             Equation
                                             Blended
    Fragment                                  Pixel
     (src)
               Framebuffer
                   Pixel
                  (dst)
Antialiasing (Örtüşme Önleme)
 Eğik çizgilerdeki çentikli görüntüyü azaltır
 glEnable( mode )
       GL_POINT_SMOOTH
       GL_LINE_SMOOTH
       GL_POLYGON_SMOOTH
 Hem RGBA hem de Indexed-Color renk
  tipinde çalışabilir.
 Görüntü kalitesi ile hız arasında seçim yapmak
  için glHint(target, hint) kullanılabilir.
   GL_NICEST, GL_FASTEST, GL_DONT_CARE
Fog
 Atmosfer efektlerini tanımlayan genel bir terimdir. Sis,
    buhar, duman, hava kirliliği gibi durumları temsil etmek
    için kullanılır.
   Görüntüyü daha doğal yapmak için kullanılır. Nesneler
    uzaklaştıkça görüntü soldurulur.
   Fog aktif hale gelince, nesneler görüş alanından
    uzaklaştıkça fog rengi kullanarak soluklaştırılır.
   Görsel simülasyon uygulamalarında kısıtlı görüntü elde
    etmek için Fog kullanımı gereklidir. Özellikle uçak
    simülatörlerinde sıklıkla kullanılır.
   Karmaşık simülasyon programlarında fog kullanmak
    performansı artırıcı etki yapar. Çünkü uzakta olduğu için
    görünmeyen nesneleri çizmeye gerek duyulmaz.
Fog Modları
Linear Fog Mode :
 Depth Cueing (derinlik işareti) efektleri için kullanılır.
  Gözün başlangıç ve bitiş uzaklıkları arası fog rengi ile
  harmanlanır.

Exponential Fog Mode :
 Sis, buhar, duman gibi daha doğal çevresel efekleri
  vermek için kullanılır. Bu modda fog yoğunluğu
  (density) gözden uzaklaştıkça exponansiyel olarak
  arttırılır.
Fog Denklemleri
 Fog, bir fog rengi ile nesnenin rengini fog karışım faktörünü
  kullanarak birleştirir. Bu faktör aşağıdaki üç denklemden biri
  kullanılarak hesaplanır ve 0-1 aralığına indirgenir.

 GL_LINEAR fog denklemi:


 GL_EXP fog denklemi:


 GL_EXP2 fog denklemi:


 Z : parçanın fog’lanmaya başladığı göz koordinatları uzaklığı.
Fog Kullanımı
 glEnable(GL_FOG): Fog etkin hale getirilir.
 glFog*(pname, param): Yoğunluğu kontrol etmek için
  renk ve denklem seçimi yapılır.
    pname GL_FOG_MODE ise; param GL_LINEAR, GL_EXP veya
     GL_EXP2 olur
    pname GL_FOG_DENSITY, GL_FOG_START veya
     GL_FOG_END ise param sayısal bir değerdir. Varsayılan
     değerler sırasıyla 1, 0 ve 1’dir.
 glHint(): GL_NICEST, GL_FASTEST, GL_DONT_CARE
Fog Örneği
Çerçeve Tamponu Sıralaması
 Fragment



             Makas                     Alfa                  Şablon
             Testi                     Testi                  Testi




                                                                        Framebuffer
                   Karıştırma              Titreklik
  Derinlik                                                  Mantıksal
                   Blending              Dithering
   Testi                                                    İşlemler

                            Per
                    Poly.
                            Vertex

             CPU     DL               Raster   Frag    FB
                            Texture
                    Pixel
Makas Testi
 Dikdörtgen biçiminde bir alan tanımlanarak bunun
 içinde kalan kesimlerin çizilmesi sağlanır.
            glScissor( x, y, w, h )
         glEnable( GL_SCISSOR_TEST )
   Dışarıda kalan fragment’ler kırpılır.
   Bir viewport’un küçük bir bölümünün güncellenmesi
    için kullanışlıdır.
       glClear() işlemlerini etkiler.




                                                        115
Alfa Testi
 Pikselleri alfa değerlerine göre kabul etme veya
 reddetme
        glAlphaFunc( func, value )
        glEnable( GL_ALPHA_TEST )
   func aşağıdakilerden biri olabilir:
    GL_NEVER       GL_LESS
    GL_EQUAL       GL_LEQUAL
    GL_GREATER     GL_NOTEQUAL
    GL_GEUQAL      GL_ALWAYS
Şablon Tamponu
 Şablon tamponundaki değerler ile çizimi kontrol
 etmek için kullanılır
   Şablon testinde başarısız olan parçalar çizilmez
   Örnek: şablon tamponunda bir maske oluştur ve sadece
    bu maske dışında kalan nesneleri çiz.
Şablon Tamponu Kullanımı
glStencilFunc( func, ref, mask )
  func karşılaştıma fonksiyonunu kullanarak şablon
   tamponundaki değeri ref değeri ile karşılaştırır
  func alfa testinde de kullanılan karşılaştırma
   fonksiyonlarından biri olabilir.
  Sadece mask maskesinde 1 olan bitlere uygulanır.
glStencilOp( fail, zfail, zpass )
  Şablon tamponundaki değerlerin; şablon testinde
   başarı, derinlik testinde başarısızlık ve derinlik testinde
   başarı durumlarında nasıl güncelleneceğini belirler:
   GL_KEEP, GL_ZERO, GL_REPLACE, …

                                                                 118
Bir Maske Yaratmak
 glInitDisplayMode( …|GLUT_STENCIL|… );
 glEnable( GL_STENCIL_TEST );
 glClearStencil( 0x0 );

 glStencilFunc( GL_ALWAYS, 0x1, 0x1 );
 glStencilOp( GL_REPLACE, GL_REPLACE,
                  GL_REPLACE );
   maskeyi çiz




                                           119
Şablon Maskesini Kullanmak
 stencil = 1 olan nesneleri çiz:
  glStencilFunc( GL_EQUAL, 0x1, 0x1 )
 stencil != 1 olan nesneleri çiz:
  glStencilFunc( GL_NOTEQUAL, 0x1, 0x1 );
  glStencilOp( GL_KEEP, GL_KEEP, GL_KEEP
  );




                                        120
Dithering (Titreklik)
 Renkleri daha iyi görünmeleri için titretir.
    Az renk içeren uygulamalarda daha fazla renk varmış
     gibi gösterme tekniğidir. Örneğin sadece siyah beyaz
     basılan gazetelerde fotoğraflar görüntülenirken gri
     tonlar siyah noktaların sıklığına göre belirlenir.
             glEnable( GL_DITHER )




                                                            121
Pikseller üzerinde
mantıksal işlemler
 Renk tamponunda var olanlar ile yeni gelen fragment
 değerlerini mantıksal işlemler kullanarak birleştirme:
               glLogicOp( mode )
   Genel Modlar:
     GL_XOR
     GL_OR
                        glEnable(GL_COLOR_LOGIC_OP)
     GL_AND
                        glEnable(GL_INDEX_LOGIC_OP)
     GL_NOR
     GL_COPY
     GL_INVERT
     …



                                                          122
Biriktirme Tamponu
 Renk tamponlarının bir araya getirilmesi sorunları
   Sınırlı renk çözünürlüğü
     Kenetlemek (clamping)
     Doğruluk kaybı

   Biriktirme tamponu : “kayan nokta” renk tamponu
     Sahneler biriktirme tamponunda biriktirilir
     Daha sonra sonuçlar çerçeve tamponuna aktarılır
Biriktirme Tamponu Uygulamaları
 Birçok Görüntüyü tek Görüntüde birleştirme
 Tüm sahne için Antialiasing
 Belirli bir nesneye odaklanma
 Filtreleme
 Hareket eden nesnenin bulanıklığı
Biriktirme Tamponunun Kullanımı
                glAccum( op, value )
  İşlemler:
    Biriktirme tamponunda: GL_ADD, GL_MULT

    Okuma tamponunda: GL_ACCUM, GL_LOAD

    Yazma tamponuna geri aktarma: GL_RETURN

  glAccum(GL_ACCUM, 0.5)
      Okuma tamponundaki her değeri (R,G,B,A) 0.5 ile çarpar ve
       biriktirme tamponuna ekler.
      ACCUM yerine LOAD olursa, ekleme yerine değiştirme.
      ADD ve MULT biriktirme tamponunda işlem yapar ve
       sonuçlar yine biriktirme tamponuna işlenir.

                                                                   125
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
GPUs and GLSL
 Over the past few years, graphical processing units
  (GPUs) have become more powerful and now are
  programmable
 Support first through OpenGL extensions and
  OpenGL Shading Language (GLSL)
 Incorporated in OpenGL 2.0
OpenGL Pipeline Revisited
                              texels                    Texture
             CPU
                                                        Memory

vertices                vertices            fragments


           Geometry                                     Fragment
                                   Rasterization        Processing
           Processing

                                                                     pixels

                                                          Frame
                                                          Buffer
Geometry Processing
 Coordinate Transformations
 Primitive Assembly
 Clipping
 Per-vertex lighting
 Programmable through a vertex program or vertex
 shader
Rasterizer
 Outputs fragments (“potential pixels”) that are interior
  to primitives
 Interpolates colors, depth, texture coordinates, and
  other per vertex variables to obtain values for each
  fragment
 Not programmable
Fragment Processing
 Assigns color to each fragment and updates frame
  buffer
 Handles hidden surface removal, texture mapping,
  and blending
 Programmable through fragment program or fragment
  shader
GLSL
 OpenGL Shading Language
 C like language for writing both vertex and fragment
  shaders
 Adds matrix and vector data types + overloading of
  operators
 OpenGL state variables available to shaders
 Variables can be passed among shaders and
  applications
Vertex Shader Applications
 General Vertex Lighting
 Off loading CPU
 Dynamic Meshes
 Morphing
 Additional Application Specific Vertex Attributes
Vertex Shader Execution
Fragment Shader
Applications
 Per Fragment Lighting
 Bump Maps
 Environment Maps
 Texture Manipulation
 Shadow Maps
Fragment Shader Execution
Linking with Application
 In OpenGL application, we must:
    Read shaders
    Compile shaders
    Define variables
    Link everything together
 OpenGL 2.0 contains a set of functions for each of
 these steps
Advanced Primitives
 Vertex Arrays
 Bernstein Polynomial Evaluators
   basis for GLU NURBS
       NURBS (Non-Uniform Rational B-Splines)
 GLU Quadric Objects
   sphere
   cylinder (or cone)
   disk (circle)
     Ed Angel
Dave Shreiner
Vicki Shreiner
On-Line Resources
  http://www.opengl.org
    start here; up to date specification and lots of sample code

  news:comp.graphics.api.opengl
  http://www.sgi.com/software/opengl
  http://www.mesa3d.org/
      Brian Paul’s Mesa 3D
  http://www.cs.utah.edu/~narobins/opengl.html
      very special thanks to Nate Robins for the OpenGL Tutors
      source code for tutors available here!
Books
 OpenGL Programming Guide, 5th Edition
 OpenGL Reference Manual, 4th Edition
 Interactive Computer Graphics: A top-down approach
  with OpenGL, 4rd Edition
 OpenGL Programming for the X Window System
   includes many GLUT examples
Thanks for Coming
Questions and Answers
    Ed Angel       angel@cs.unm.edu
    Dave Shreiner shreiner@siggraph.org
    Vicki Shreiner vshreiner@sgi.com
Course Evaluations
 Please don’t forget to tell us what you think:
      http://www.siggraph.org/courses_evaluation

				
DOCUMENT INFO