Renk Kenetleme,Renk-Endeks Modu,Bir Gölgeleme Modeli Belirlemek

Renk Kenetleme,Renk-Endeks Modu,Bir Gölgeleme Modeli Belirlemek

Renk Kenetleme

OpenGL 3.0 Sürümü, RGBA renk bileşenlerinin gerçek noktalı sayı değerleri olarak saklandığı noktalı sayı çerçeve bellekleri getirdi. Noktalı sayı değerlerinin daha büyük dinamik aralığı nedeniyle aslen OpenGL tarafından 0.0 ila 1.0 olarak tanımlanan kenetlenmiş renk değerleri aralığı dışında kalan renk değerlerine izin vermek isteyebilirsiniz.

void glClampColor(GLenum target, GLenum clamp);

glClampColor glReadPixels sırasında kenetlecek renkleri kontrol eder. Hedef GL_CLAMP_VERTEX_COLOR,GL_CLAMP_FRAGMENT_COLOR,veyaGL_CLAMP_READ_COLOR olabilir. Kelepçe(clamp) GL_TRUE ise, renk sıkıştırma etkin olur; Kelepçe(clamp) GL_FALSE ise, renk sıkıştırma devre dışı . Kelepçe(clamp) GL_FIXED_ONLY ise, renk sıkıştırma seçilen okuma tamponu noktası bileşenleri sabit ve aksi kapatmıştır.

OpenGL Sürüm 3.0 mevcut olan renk-kenetleme seçenekleri  aşagıdaki tabloda’de verilmektedir.

Parametre	Özellikler
GL_TRUE	Renkler [0, 1] aralığına kenetlenmeli
GL_FALSE	Kenetlenmeyecek renkler
GL_FIXED_ONLY	Renkler sadece hedef çerçeve bellek sabit nokta ise Kenetlenir.

Renk-Endeks Modunda Bir Rengi Belirlemek

glIndex

Renk-endeks modunda tek-değerli bir renk endeksini geçerli renk endeksi olarak seçmek için glIndex*()  komutunu kullanılır.

Void glIndex{sifd ub}(TYPE c);
Void glIndex{sifd ub}v(const TYPE *c);

Geçerli renk endeksini c’ye ayarlanır. Bu komutun ilk soneki parametreler için veri tipini belirler: kısa, tamsayı, noktalı sayı, çift veya işaretsiz bayt. İkincisi, seçeneksel sonek v,  argümanı verilen veri tipinin bir değer dizisi olduğunu gösterir (dizi sadece bir değer içerir.)  

glClearIndex

Pencereyi Temizlemek” kısmında glClearColor() komutunun özelliklerini gördünüz. Renk-endeks modu için buna karşılık gelen birglClearIndex() modu bulunur.

void glClearIndex(GLfloat  cindex); 

Geçerli temizleme rengini renk-endeks modunda ayarlanır. Bir renk-endeks mod penceresinde bir glClear(GL_COLOR_BUFFER_BIT) çağrısı belleği temizlemek için cindex kullanır. Varsayılan endeks; 0.0’dır.

Not: OpenGL, renk-bakma tablosuna değer yüklemek için herhangi bir şablona sahip değildir. Pencere sistemleri genel olarak bu tür operasyonlara sahiptir. GLUT pencere-sistemine-özgü komutları çağırmak için glutSetColor() komutuna sahiptir. 

Bir Gölgeleme Modeli Belirlemek

Bir çizgi veya dolu bir poligon primitif tek bir renk (düz gölgeleme) veya pek çok renk (düzgün gölgeleme, ayrıca Gouraud Gölgeleme de denir) ile çizilebilir. Arzu edilen gölgeleme tekniğini glShadeModel() komutu ile belirlenir.

void glShadeModel(GLenum mode);

glShadeModel Gölgeleme modelini ayarlar. Mod parametresi ya GL_SMOOTH (varsayılan) veya GL_FLAT olabilir.

Düz gölgeleme ile bağımsız bir primitifin belli bir köşesinin rengi, bu primitifi kaplamak için tüm primitiflerin köşeleri boyunca çoğaltılır. Düzgün gölgeleme ile her bir köşedeki renk münferit olarak ele alınır. Bir çizgi primitif için çizgi boyunca uzana renkler köşe renkleri arasında ortalanır. Bir poligon primitif için poligon içindeki renkler köşe renkleri arasında ortalanır. 

Örnek Kod:

#include<GL/glut.h>
void init (void)
    {
      
      glClearColor(0.0,0.0,0.0,0.0);
      glShadeModel(GL_SMOOTH);
            
    }
    
    
    void triangle(void)
    {
      glBegin(GL_TRIANGLES);
      glColor3f(1.0,0.0,0.0);
      glVertex2f(5.0,5.0);
      glColor3f(0.0,1.0,0.0);
      glVertex2f(25.0,5.0);
         glColor3f(0.0,0.0,1.0);
      glVertex2f(5.0,25.0);
      glEnd();
    }
    
    void display(void)
    {
      
      glClear(GL_COLOR_BUFFER_BIT);
      triangle();
      glFlush();      
    }
    void reshape(int w,int h)
    {
      glViewport(0,0,(GLsizei)w,(GLsizei)h);
      glMatrixMode(GL_PROJECTION);
      glLoadIdentity();
      if(w<=h)
 gluOrtho2D(0.0,30.0,0.0,30.0 *(GLfloat)h/(GLfloat) w);
      else
      gluOrtho2D(0.0,30.0 *(GLfloat)w/(GLfloat) h,0.0,30.0);
      glMatrixMode(GL_MODELVIEW);
       }
    
    int main (int argc, char ** argv)
    {
      glutInit (&argc,argv);
      glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
      glutInitWindowSize(500,500);
      glutInitWindowPosition(100,100);
      glutCreateWindow(argv[0]);
      init();
      glutDisplayFunc(display);
      glutReshapeFunc(reshape);
      glutMainLoop();
      return(0);
    }

Düzgün gölgeleme ile komşu pikseller biraz daha farklı renk değerlerine sahip olur. RGBA modunda biraz daha farklı değerlere sahip bitişik pikseller benzer görünürler, bu nedenle bir poligon boyunca renk değişimleri kademeli olarak görünür. Renk-endeks modunda bitişik pikseller, renk-endeks tablosunda kesinlikle benzer renklere denk gelmeyen farklı konumlara başvurabilir. Bitişik renk-endeks girişleri oldukça farklı renkler içerebilir bu nedenle renk-endeks modunda düzgün-gölgeli bir poligon sanrısal görünebilir.

 Bu problemden kaçınmak için renk haritasında bitişik bir dizin seti arasında düzgünce değişen renklerden bir renk rampası yaratmak zorundasınız. Bir renk haritasına renk yüklemenin OpenGL yerine pencere sisteminiz yoluyla gerçekleştirildiğini unutmayın. Eğer GLUT kullanıyorsanız belirlenmiş kırmızı, yeşil ve mavi değerlere sahip renk haritasında tek bir endeks yüklemek için glutSetColor() ı kullanabilirsiniz. glutSetColor()  ın ilk argümanı endekstir ve diğerleri kırmızı, yeşil ve mavi değerleridir. Hafifçe farklı sarı tonlara ait 32 bitişik renk dizini yüklemek için (16 ila 47 arası renk dizinleri);

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

glutSetColor(16+i, 1.0*(i/32.0), 1.0*(i/32.0), 0.0);

}

döngüsünü kullanabilirsiniz

Şimdi eğer sadece 16 ila 47 arası renklerden kullanan düzgün gölgeli poligonları kaplıyorsanız bu poligonlar kademeli olarak değişen sarı tonlarına sahip olacaktır.

Düz gölgeleme ile tek bir köşenin rengi tüm bir primitifin rengini belirler. Bir çizgi parçası için çizginin rengi, ikinci (son) köşe tanımlandığından geçerli renktir. Bir poligon için kullanılan renk, aşşagıdaki tabloda gösterildiği gibi belli bir köşe tanımlandığında yürürlükte olan renktir. Tablo, köşe ve poligonların 1.OpenGL’den başlayarak bu kuralları tutarlı şekilde takip ettiğini varsayar ancak bir düz-gölgeli primitifin nasıl çizileceği hakkında belirsizlikten kaçınmanın en iyi yolu pirimitif için sadece bir tek renk belirlemektir.

Poligon Tipi	i.nci Poligon için Renk Seçiminde Kullanılan Köşe
Tek Poligon	1
Üçgen şerit	i+2
Üçgen fan	i+2
Bağımsız Üçgen	3i
Dörtlü şerit	2i+2
Bağımsız dörtlü	4i

Bir renk belirlemek

Bir renk belirlemek

OpenGL geçerli bir renk (RGBA modunda) ve geçerli bir renk endeksi (renk-endeks modunda) sürdürmektedir. Işıklandırma veya desen haritalama gibi daha karmaşık bir renklendirme modeli kullanmadığınız sürece her bir nesne geçerli bir renk (veya renk endeksi) kullanılarak çizilir. Aşağıdaki örnegi inceleyelim;

Renk(Kirmizi);
nesne_cizim(A);
nesne_cizim(B);
Renk(Yesil);
Renk(Mavi);
nesne_cizim(B);

A ve B nesneleri kırmızıyla ve C nesnesi mavi ile çizilidir. Geçerli rengi yeşile ayarlayan  çizginin ise hiçbir etkisi yoktur (biraz zaman kaybı olması haricinde). Hiçbir ışıklandırma ve desenleme olmadan, geçerli renk ayarlandığında sonradan çizilen tüm nesneler geçerli renk değişene kadar o renkle çizilir. 

Bir Renk Belirlemek

RGBA modunda geçerli bir renk seçmek için glColor*()  komutu kullanılır.

voidglColor3{b s i f d ub us ui}(TYPEr,TYPEg,TYPEb);
voidglColor4{b s i f d ub us ui}(TYPEr,TYPEg,TYPEb,TYPEa);
voidglColor3{b s i f d ub us ui}v(constTYPE*v);
voidglColor4{b s i f d ub us ui}v(constTYPE*v);
Örnek kod:

#include<GL/glut.h>
void cizgi(void)
{
glBegin(GL_LINES);
glVertex2f(-0.4f,0.4f);
glVertex2f(0.4f,0.4f);
glEnd();
}
void pencere(void)
{
glClearColor(1.0,1.0,1.0,0.0);
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(1.0,0.0,0.0);//--------------->
cizgi();
glTranslatef(0.0,-0.2,0.0);
glColor3f(0.0,1.0,0.0);//---------------->
cizgi();
glTranslatef(0.0,-0.2,0.0);
glColor3f(0.0,0.0,1.0);//---------------->
cizgi();
glFlush();
}
int main(int argcp,char **argcv)
{
glutInit(&argcp,argcv);
glutInitDisplayMode(GLUT_SINGLE);
glutInitWindowPosition(200, 200);
glutInitWindowSize(250, 250); 
glutCreateWindow("OpenGLTurk");
glutDisplayFunc(pencere);
glutMainLoop();
return 0;
} 

glColor*()Geçerli kırmızı, yeşil, mavi ve alfa değerlerini ayarlar. Bu komut kabul edilen parametrelerin varyasyonlarını farklılaştırabilecek üç adete kadar son eke sahip olabilir. İlk son ek, kırmızı, yeşil ve mavi değerlere ek olarak bir alfa değeri verip vermediğinizi göstermek için 3 veya 4 olabilir. Eğer bir alfa değeri vermiyorsanız otomatikman 1.0’a ayarlanır. İkinci son ek, parametreler için veri tipini gösterir: bayt(bayt), kısa tamsayı(short), tamsayı(int), noktalı sayı(float), çift(double), işaretsiz bayt(unsigned bayt), işaretsiz kısa sayı(unsigned short) veya işaretsiz tamsayı(unsigned int). Üçüncü son ek, argümanın verilmiş veri tipinin bir değer dizisinin bir işaretçisi olduğunu gösteren seçeneksel bir v’dir. 

noktalı sayı  veri tiplerini kabul eden  glColor*() sürümleri için değerler tipik olarak, çerçeve bellekte saklanabilecek minimum ve maksimum yani 0.0 ile 1.0 aralığında olmalıdır. işaretsiz-tamsayı renk bileşenleri, belirtildiklerinde, en büyük temsil edilebilir değerin 1.0’a (tam şiddet) haritalanabilecek şekilde ve sıfırın 0.0’a (sıfır şiddet) haritalanabileceği şekilde noktalı sayıları doğrusal olarak haritalanırlar. işaretli-tamsayı renk bileşenleri, belirtildiklerinde, en fazla  pozitif temsil edilebilir değeri 1.0’a ve en negatif temsil edilebilir değeri -1.0’a haritalanabileceği şekilde noktalı sayıları doğrusal olarak haritalanırlar (bakınız aşşagıdaki tabloya).

sonek	veri Türü	Minimum Değer	Min Değer Haritalar	maksimum Değer	Max Değer Haritalar
b	1-byte integer	-128	-1.0	127	1.0
s	2-byte integer	-32,768	-1.0	32,767	1.0
i	4-byte integer	-2,147,483,648	-1.0	2,147,483,648	1.0
ub	unsigned 1-byte integer	0	0.0	255	1.0
us	unsigned 2-byte integer	0	0.0	65,535	1.0
ui	unsigned 4-byte integer	0	0.0	4,294,967,295	1.0

 Ne noktalı sayılar ne de işaretli-tamsayı değerleri, geçerli rengi veya geçerli ışıklandırma malzeme parametresi güncellenmeden [0, 1] aralığına kenetlenmez.  Işıklandırma hesaplarından sonra, [0, 1] aralığının dışında kalan sonuç renk değerleri ortalanmadan veya bir renk belleğe yazılmadan önce [0, 1]’e kenetlenir. Işıklandırma pasifleştirilmiş olsa bile renk bileşenleri kafeslemeden önce kenetlenir. 

Benzer bir  glSecondaryColor*() şablon desen haritalamadan sonra (eğer ışıklandırma pasifleştirilmişse) uygulanacak rengi belirlemek için kullanılır. Daha fazla ayrıntı için bakını “Desenlemeden Sonra İkinci Renk Uygulamak”.

Bilgisayar Rengi

Bilgisayar Rengi

Bir  bilgisayar ekranı üzerinde, donanım ekrandaki her bir pikselin farklı miktarlarda kırmızı, yeşil ve mavi ışık yaymasına neden olur. Bunlara R, G ve B değerleri denir. Çoğunlukla birlikte paketlenirler (bazen alfa veya A denilen dördüncü bir değerle birlikte) ve paketli değere RGB (veya RGBA) denir.  Her bir pikseldeki renk bilgisi ya her bir piksel için R,G, B ile muhtemelen A değerlerinin tutulduğu RGBA modunda veya her bir piksel için tek bir sayının ( renk endeksi ) depolandığı renk-endeks modunda tutulabilir. Her bir renk endeksi, belirli bir R, G ve B değerleri seti tanımlayan bir tablodaki bir kaydı gösterir. Böyle bir tabloya renk haritası denir.

         Renk-endeks modunda, renk haritasının değerlerini değiştirmek isteyebilirsiniz. Renk haritaları pencere sistemi tarafından kontrol edildiğinden, bunu yapacak hiçbir OpenGL komutu yoktur. Kullandıgınız pencere sitemine göre(glut, winap,vs..) renk-görüntü modunu ayarlamamız gerekmektedir.

Farklı grafik donanım platformları arasında hem piksel dizisi büyüklüğü hem de her bir pikselde gösterilebilecek renk sayısı bakımından büyük bir çeşitlilik söz konusudur. Herhangi grafik sisteminde her bir piksel rengini depolamak için aynı miktarda belleğe sahiptir ve tüm piksellerin tüm belleğine renk belleği denir. Bir belleğin boyutu genellikle bit olarak ölçülür, yani 8 bitlik bellek, her bir piksel için 8 bit veriyi depolayabilir (256 olası farklı renk). Olası belleklerin boyutu makineden makineye değişir. (Çerçeve Arabellek konusunda bu durum incelenmektedir).

R, G ve B değerleri 0.0’dan (hiç yok) 1.0’a (tam şiddet) kadar değişebilir. Örneğin R=0.0, G=0.0 ve B=1.0 olası en parlak maviyi temsil eder. Eğer R, G ve B’nin tümü 0.0 ise ekran tamamen siyah ve eğer hepsi 1.0 ise pikseller ekran üzerinde en parlak beyaz ile çizilir. Yeşil ve maviyi harmanlamak deniz mavisinin tonlarını oluşturur. Mavi ve kırmızı patlıcan moru için karıştırılır. Yeşil ve kırmızı sarıyı verir. R, G ve B bileşenlerinden renkleri oluşturmanıza yardımcı olmak için Tabaka 12’de gösterilen renkli küpe bakın. Bu küpün eksenleri kırmızı, yeşil ve mavinin şiddetlerini temsil etmektedir. Küpün bir siyah-beyaz sürümü Şekil 4.1’de gösterilmektedir.

            Bir nesneye (bu örnekte bir noktaya) bir renk tanımlamak için kullanılan komutlar bu kadar basit olabilir:

 glColor3f(1.0,0.0,0.0);      
glBegin(GL_POINTS);
glVertex3fv(point_array);
glEnd();

Belli modlarda (örneğin ışıklandırma ve biçimlendirme hesaplamaları gerçekleştirilmişse) atanan renk, bir piksel için bir rengi temsil eden bir değer olarak çerçeve belleğine ulaşmadan önce başka operasyonlardan geçebilir. Gerçekte bir pikselin rengi uzun bir operasyon dizisi ile belirlenir.

Bir programın             yürütülmesi esnasında başlangıçta renk-görüntü modu ya RGBA modu veya renk-endeks moduna ayarlanır. Renk-görüntü modu başlatıldığı anda artık değiştirilemez. Program çalışırken bir renk (ya bir renk-endeks veya bir RGBA değeri) her bir geometrik primitif için bir köşe-başına temelinde belirlenir. Bu renk sizin bir köşe için açıkça belirlediğiniz bir renktir veya eğer ışıklandırma etkinleştirilmiş ise, dönüşüm matrislerinin yüzey normalleri veya diğer materyal özellikleri ile etkileşimi sonucunda belirlenir. Diğer bir deyişle üzerine mavi ışık düşmüş bir top, hiç ışık almayan bir toptan daha farklı görünür (detaylar için ışık konusuna bakınız). İlgili ışıklandırma hesaplarının yerine getirilmesinden sonra seçili gölgeleme modeli uygulanır.  Her biri bir pikselin nihai rengi üzerinde farklı etkilere sahip olan düz veya düzgün gölgelemeyi seçebilir.

            Daha sonra primitifler kafeslenir veya bir iki-boyutlu görüntüye dönüştürülür. Kafesleme, pencere koordinatlarında hangi  grid karenin primitif tarafından kaplandığını belirlemeyi ve daha sonra bu kareye renk ve diğer değerleri atamayı içerir. Kendisine eşlik eden renk değeri, z-derinliği ve doku koordinatları ile birlikte  grid kareye  fragman denir. Pikseller, çerçeve belleğin öğeleridir; bir fragman bir primitiften gelir ve yeni bir piksel vermek üzere karşılık gelen pikseliyle birleşiktir.  Bir fragman oluşturulduğu anda – eğer etkinleştirilmişlerse – fragmanlara desenleme, sis ve anti-pürüzlenme (antialiasing) uygulanır. Sonrasında  her tür belirlenmiş alfa harmanlama, kararsızlaştırma, ve bit-akıllı mantıksal operasyonlar çerçeve belleğinde tutulmuş olan fragman ve pikseli kullanarak yürütülür. Son olarak fragmanın renk değeri (renk-endeksi veya RGBA) piksele yazılır ve pencerenin renk-gösterme modu kullanılarak pencerede gösterilir.  

RGBA Gösterme Modu

RGBA modunda, donanım her bir R, G, B ve A bileşeni için  belli sayıda (hepsi için aynı olması şart değil) bit düzlem ayırır. R, G ve B değerleri genellikle noktalı sayılar yerine tamsayı olarak tutulurlar ve depolama ve geri çağırma için mevcut bit sayısına ölçeklenirler. Örneğin, eğer bir sistem R bileşeni için 8 bite sahipse 0 ile 255 arasındaki tam sayılar depolanabilir; böylece bit düzlemlerdeki 0, 1, 2, …, 255, 0/255 = 0.0, 1/255, 2/255, …, 255/255 = 1.0 R değerlerine karşılık gelir. Bit düzlem sayısına bakılmaksızın 0.0 minimum şiddeti ve 1.0 ise maksimum şiddeti belirtir.

Not: Alfa değerinin (RGBA’da A) ekranda gösterilen renk üzerinde hiçbir etkisi yoktur. Harmanlama ve şeffaflık dâhil pek çok şey için kullanılabilir ve yazılı olan R, G ve B değerleri üzerinde bir etkiye sahip olabilir. (Alfa değerleri hakkında daha fazla bilgi için bakınız  “Harmanlama”).

Tek bir pikselde gösterilebilen farklı renklerin sayısı, bit düzlemlerin sayısı ile donanımın bu bit düzlemlerini yorumlama kapasitesine bağlıdır. farklı renklerin sayısı, n bit düzlemlerin sayısı olmak üzere 2ⁿ’i aşamaz. Böylece RGB için 24 bit düzlemi olan bir makine 16,77 milyon farklı renge kadar gösterebilir.

Alıştırma

Bazı grafik donanımlar, belirgin renklerin sayısını artırmak için kararsızlaştırmayı kullanır. Alalaştırma, diğer renklerin etkisini yaratmak için bazı renklerin kombinasyonlarını kullanmaktadır. Alalaştırmanın nasıl çalıştığını canlandırmak için sisteminizin  her bir R, G ve B bileşeni için sadece 1 bite sahip olduğunu ve böylece sadece sekiz renk gösterebikeceğini varsayın: siyah, beyaz, kırmızı, yeşil, sarı, deniz mavisi ve patlıcan moru. Bir pembe bölge göstermek için donanım bölgeyi bir dama tahtası tarzında dönüşümlü olarak kırmızı ve beyaz piksellerle doldurabilir. Eğer gözleriniz ekrandan münferit pikselleri ayırt edemeyecek yeteri uzaklıktaysa bölge kırmızı ile beyazın ortalaması, pembe olarak görünür. Kırmızımsı pembeler piksellerin büyük bir kısmının kırmızı ile doldurulmasıyla elde edilebilir, daha açık pembeler daha çok beyaz pikseller kullanabilir ve benzeri.

Bu teknikle orada hiçbir pembe piksel yoktur. “Pembelik” efektini elde etmenin tek yolu çok sayıda pikselden oluşan bir bölgenin kapsanmasıdır – tek bir pikseli alalaştıramazsınız. Mevcut olmayan bir renk için bir RGB değeri belirler ve bir poligonu doldurursanız, donanım poligonun içini ortalamaları gözünüze istediğiniz renk gibi gelen civar renklerin bir karışımı ile doldurur (Buna karşın, eğer piksel değerlerini çerçeve belleğinden okuyorsanız, orada pembe piksel olmadığından fiili kırmızı ve beyaz piksel sayısını alırsınız. Piksel değerlerini okuma hakkında daha fazla bilgi için bakınız (Çizim Pikselleri)).

Yukarıdaki şekilde  gri tonları oluşturmak üzere siyah ve beyaz piksellerin bazı basit alalaştırmasını göstermektedir. Soldan sağa doğru üstteki 4x4 düzen %50, %19 ve %69 oranında gri alalaştırma düzenlerini göstermektedir. Her bir düzenin altında, her bir düzenin tekraren küçültülmüş kopyalarını görüyorsunuz ama bu siyah ve beyaz kareler hâlâ çoğu pikselden daha büyüktür. Eğer onlara odanın karşısından bakarsanız birlikte bulanıklaştıklarını ve üç farklı gri ton olarak göründükleri görebilirsiniz.

Her bir R, G ve B için yaklaşık 8 bitle birlikte alalaştırma olmaksızın oldukça yüksek kalitede bir görüntü elde edebilirsiniz. Bununla birlikte makinenizin sırf 24 renk bit düzlemine sahip olması alalaştırmanın istenmediği anlamına gelmez. Örneğin, çift-bellek modunda çalışıyorsanız bit düzlemler 12’lik iki sete bölünebilir, bu nedenle her bir R, G ve B bileşeni için orada gerçekten sadece 4 bit bulunur. Alalaştırma olmadan bileşen başına 4 bit çoğu durumda tatmin edici olmaktan uzak sonuçlar verebilir.

Alalaştırmayı GL_DITHER komutunu  glEnable() veya glDisable() ’a göndererek etkinleştirebilir veya pasifleştirebilirsiniz.

Renk-Endeks Görüntü Modu

Renk-endeks modu ile OpenGL, bir sayı-ile-boya ekranı için hazırlamak üzere boyaları karıştırmak için bir palet kullanıma benzer bir renk haritası (veya bakma tablosu) kullanır. Bir ressamın paleti boyaları birbirine karıştırmak için alan sağlar; benzer olarak bir bilgisayarın renk haritası da  ilk kırmızı, yeşil ve mavi değerlerin karıştırılabileceği endeksler sağlar.

 Bir sayı-ile-boya ekranını dolduran bir ressam renk paletinden bir renk seçer ve ilgili numaralı bölgeleri o renkle doldurur. Bir bilgisayar her bir piksel için renk endekslerini bit düzlemlerde saklar.Daha sonra bu bit düzlem değerleri renk haritasına başvurur ve  renk haritasından karşılık gelen kırmızı, yeşil ve mavi değerlerle boyanır.

Renk-indeks modda eş zamanlı mevcut renk sayısı renk haritasının boyutu ve mevcut bit düzlem sayısı ile sınırlıdır. Renk haritasının boyutu donanımın ona ayırdığı miktar ile belirlenir. Renk haritasının boyutu daima 2’nin üssüdür ve tipik boyutlar 256 (2⁸)’den 4906 (2¹²)’ye kadar uzanır, burada üs kullanılmakta olan bit düzlemlerin sayısıdır. Eğer renk haritasında 2ⁿ endeks ve m sayıda mevcut bir düzlem varsa kullanılabilir kayıt sayısı 2ⁿ artı 2^m’den küçüktür.

RGBA modu ile her bir pikselin rengi diğer piksellerin renginden bağımsızdır. Bununla birlikte renk-endeks modunda aynı endeksle kendi bit düzleminde saklanan her bir piksel aynı renk haritası konumunu paylaşır. Eğer renk haritasında bir kaydın içeriği değişirse, o zaman o renk endeksine ait tüm pikseller renklerini değiştirir.

RGBA ile Renk-Endeks Modu arasında Seçim Yapmak

RGBA veya renk-endeks modu kullanma kararınızı hangi donanımın mevut olduğuna ve uygulamanızın gerektirdiklerine dayanarak verin. Çoğu sistem için RGBA modu ile renk-endeks moduna göre daha çok renk eşzamanlı olarak temsil edilebilir. Ayrıca gölgeleme, ışıklandırma, desen haritalama ve sis gibi birkaç efekt için RGBA renk-endeks modundan daha fazla esneklik sağlar.

Aşağıdaki durumlarda renk-endeks modunu seçmeyi isteyebilirsiniz:

• Renk-endeks modundan önemli derecede yararlanan mevcut bir uygulamayı uyarlıyorsanız RGBA moduna geçmemek daha kolay olabilir.
• Eğer az sayıda mevcut bit düzleminiz varsa RGBA belirgin şekilde iri renk tonları yaratabilir. Örneğin eğer sadece 8 bit düzleminiz varsa RGBA modunda kırmızı için sadece 3, yeşil için 3 ve mavi için 2 bite sahip olabilirsiniz. Sadece 8 (2³) kırmızı ve yeşil tonuna ve sade 4 mavi tonuna sahip olursunuz. Renk tonları arasındaki değişimin bariz olması çok mümkündür.

Bu durumda, eğer sınırlı gölgeleme gereksiniminiz varsa daha fazla renk tonu yüklemek için renk-bakma tablosunu kullanabilirsiniz. Örneğin sadece mavinin tonlarına ihtiyacınız varsa renk-endeks modunu kullanabilir ve 256 (2⁸) ‘ya kadar mavi tonu renk-bakma tablosunda saklayabilirsiniz ki bu RGBA modunda sahip olabileceğiniz 4 tondan çok daha iyidir. Elbette bu örnek sizin tüm renk-bakma tablonuzu kullanabilir, bu yüzden hiçbir kırmızı, yeşil veya diğer renk bileşiğinin tonlarını içermeyecektir.

• Renk-endeks modu, renk-harita animasyonu ve tabakalar halinde çizim çeşitli hileler için yararlı olabilir.

Genel olarak RGBA’yı mümkün olan her yerde kullanın. Desen haritalama ile çalışır ve ışıklandırma, gölgeleme, sis, anti-pürüzlenme ve harmanlama ile daha da iyi çalışır.

Görüntü Modları Arasında Geçiş

 Tüm olası dünyaların en iyisinde, RGBA ile renk-endeks görüntü modu arasında bir seçim yapmaktan kaçınmayı isteyebilirsiniz. Örneğin bir renk-harita animasyon efekti için renk-endeks modu kullanmak ve daha sonra, gerektiğinde, ekranı desen haritalama için hemen RGBA moduna değiştirmek isteyebilirsiniz.

Benzer olarak tekli ve çiftli bellek arasında geçiş yapmak isteyebilirsiniz. Örneğin çok az sayıda bit düzleme, diyelim ki 8 bit düzleme sahip olabilirsiniz. Tekli bellek modunda 256 (2⁸) renginiz olabilir ama eğer animasyonlu programınızdan ışık titreşmelerini yok etmek için çift bellek kullanıyorsanız sadece 16 (2⁴) renginiz olur. Muhtelemen titreşim olmadan hareketli bir nesne çizmek istiyorsunuz ve çift bellek modunu kullanmak için renklerden fedakârlık etmeye hazırsınızdır (belki nesne o kadar hareketlidir ki seyirci detayları fark etmeyecektir.) Ancak nesne durduğunda onu, daha fazla renk kullanabilmek için tekli-bellek modunda çizmek isteyeceksiniz.

Maalesef çoğu pencere sistemi kolay bir geçişe izin vermez. Örneğin  Pencere Sisteminde renk-görüntü modu  X Visual’ın bir niteliğidir. Bir X-Visual pencere yaratılmadan önce belirtilmelidir. Bir kez belirtildiğinde pencerenin ömrü boyunca değiştirilemez. Bir çift-bellek, RGBA görüntü modunda bir pencere yarattıktan sonra ona bağlı kalırsınız.

Bu problemin hileli bir çözümü, her biri farklı bir görüntü modunda olan birden fazla pencere yaratmaktır. Her bir pencerenin görünürlüğünü kontrol etmek (örneğin bir X penceresi haritalamak veya haritalamamak veya bir Motif veya Athena parçacığını yönetmek veya yönetmemek) ve nesneyi uygun, görünür pencerede çizmek zorundasınız. 

Renk Algısı

Renk Algısı

Fiziksel olarak ışık fotonlarıdan her biri kendi yolu üzerinde ilerleyen ve her biri kendine özgü frekansla (veya dalga boyu veya enerji ile frekans, dalga boyu veya enerjinin herhangi biri diğerlerini belirler) titreşen küçük ışık taneciklerinden oluşur. Bir foton konumu, doğrultusu ve frekansı/dalga boyu/enerjisi ile tamamen karakterize edilir. 390 nanometre (nm) (mor) ile 720 nanometre (kırmızı) aralığında dalga boylarına sahip fotonlar görünür spektrumun renklerini kapsayarak, gökkuşağının renklerini oluştururlar (mor, lacivert, mavi, yeşil, sarı, turuncu, kırmızı). Bununla birlikte gözlerimiz gökkuşağında olmayan pek çok rengi de algılar; mesela siyah, beyaz, kahverengi, pembe. Bu nasıl oluyor?

Gözlerimizin aslında gördüğü şey farklı frekanslara sahip foton karışımlarıdır. Gerçek ışık kaynağı yaydıkları foton frekansları dağılımı ile karakterize edilirler. İdeal beyaz ışık tüm frekanslardan eşit miktarda ışık içerir. Lazer ışığı genellikle oldukça saftır ve tüm fotonlar neredeyse özdeş frekansa (doğrultu ve faza da) sahiptir. Bir sodyum-buhar lambasından çıkan bir ışık çoğunlukla sarı frekansa sahip fotonlardan oluşur. Uzaydaki çoğu yıldızdan gelen ışık büyük ölçüde kendi sıcaklıklarına bağlı olan (siyah-cisim ışıması) bir dağılıma sahiptir. Yakın çevrenizdeki çoğu kaynaktan gelen ışığın frekans dağılımı daha karmaşıktır.

            İnsan gözü renkleri, retinadaki belli hücrelerin (konik hücreler veya sadece konikler) fotonlara maruz kalarak uyarılmasından sonra algılar. Işığın üç dalga boyuna en iyi şekilde tepki veren üç farklı konik hücre bulunur. Bir konik hücre tipi kırmızı ışığa, biri yeşil ışığa ve diğeri de mavi ışığa duyarlıdır (renk körü olan bir kişide genellikle bir veya daha fazla konik hücre tipi eksiktir.)  Belli bir foton karışımı göze girdiğinde, retinadaki konik hücreler tiplerine bağlı olarak farklı uyarılma seviyeleri kaydeder ve eğer farklı bir foton karışımı üç değişik konik hücre tipini aynı derecede uyarırsa rengi ilk karışımdan ayırt edilemez.

            Her bir renk göz tarafından, gelen fotonların konik hücreleri uyarma seviyesi olarak algıladığından bir prizma veya gökkuşağı tarafından üretilen spektrumda bulunmayan renkleri algılayabilir. Örneğin eğer bir kırmızı ve mavi karışımı foton gönderirseniz gözdeki hem mavi hem de kırmızı konikleri uyarmış olursunuz, gözleriniz spektrumda olmayan patlıcan rengini görür. Diğer kombinasyonlar hiçbiri spektrumda olmayan kahverengi, türkuaz ve leylâk rengini verir.

            Bir bilgisayar grafik ekranı, pikselleri retinadaki kırmızı, yeşil, mavi-duyarlıklı konik hücreleri yaymaya çalıştığı foton karışımı tarafından üretilen uyarılma seviyesiyle uyuşacak şekilde uyaran oranlarda bir yeşil, mavi ve kırmızı foton karışımı ile ışıklandırır. Eğer insanların örneğin sarı ışığa duyarlı daha fazla tipte konik hücreleri olsaydı renkli ekranlar muhtemelen sarı bir teçhizata da sahip olur ve biz de renkleri belirlemek için RGBY (kırmızı, yeşil, mavi, sarı) dörtlüsünü kullanırdık. 

            Belli bir rengi göstermek için ekran, gözünüzdeki farklı tip konik hücreleri uygun şekilde uyarmak amacıyla doğru miktarlarda kırmızı, mavi ve yeşil ışık yayar. Renkli bir ekran her bir piksele farklı oranlarda kırmızı, mavi ve yeşil ışık gönderir ve göz her biri kendi rengine sahip bir milyon veya yaklaşık sayıda ışık noktacıkları görür.

Ek Kırpma

Ek Kırpma

Görüntüleme hacmini altıya kadar ek kırpma düzlemi (sol, sağ, alt, üst, yakın ve uzak)  tanımlayabilirsiniz. Bu, bir sahnedeki konu dışı nesnelerin çıkarılmasında yararlıdır—örneğin eğer bir nesnenin bir kesit görünüşünü göstermek istiyorsanız.
Her bir düzlem, eşitliğine ait katsayılarla belirtilir: Kırpma düzlemleri modelleme ve görüntüleme dönüşümleri ile otomatik olarak uygun şekilde dönüştürülürler. Kırpma hacmi, görüntüleme hacmi ile ek kırpma düzlemleri tarafından tanımlanan tüm yarım-yerlerin kesişimi haline gelir. otomatik olarak kırpılan poligonların kenarlarının OpenGL tarafından uygun şekilde yeniden yapılandırıldığını aklınızda bulundurun.

Tanımladığınız her bir ek kırpma düzlemini etkinleştirmeniz gerekir:
glEnable(GL_CLIP_PLANEi);
Bir düzlemi şu komutla geçersiz hale getirebilirsiniz:
glDisable(GL_CLIP_PLANEi);
Bazı uygulamalar daha fazlasına izin verebilmelerine rağmen OpenGL’nin tüm uygulamaları  altı kırpma düzlemini desteklemek zorundadır.  Kaç düzlemin desteklendiğini bulmak için GL_MAX_CLIP_PLANES ile birlikte glGetIntegerv() ’yi kullanabilirsiniz.
Not: glClipPlane()komutunun bir sonucu olarak gerçekleştirilen kırpma, kırpıntı koordinatlarında değil göz koordinatlarında yapılır. Bu fark, projeksiyonun matrisinin tekil (yani üç-boyutlu koordinatları iki-boyutlu koordinatlara düzleştiren bir gerçek projeksiyon matrisi) olması durumunda belirgindir. Göz koordinatlarında gerçekleştirilen kırpma, projeksiyon matrisinin tekil olması durumunda bile işlemeye devam eder.
Bir Kırpma Düzlemi Kod Örneği
aşşagıdaki Örnek Clip2 bir kafes çerçeve küreyi, orijinal kürenin 4’te üçünü kesip atan iki kırpma düzlemi ile  clip1 deki  gibi dönüştürür.

Örnek Clip2 İki Kırpma Düzlemli Kafes-çerçeveli Küre: clip.c

void init(void)
{
glClearColor(0.0, 0.0, 0.0,0.0);
glShadeModel(GL_FLAT);
}
void display(void)
{
GLdoubleeqn[4]= {0.0,1.0, 0.0,0.0};
GLdoubleeqn2[4]= {1.0,0.0, 0.0, 0.0};
glClear(GL_COLOR_BUFFER_BIT); 
glColor3f(1.0, 1.0, 1.0);  
 glPushMatrix();  
 glTranslatef(0.0, 0.0, -5.0);
/*                     cliplower half -- y< 0           */  
 glClipPlane(GL_CLIP_PLANE0, eqn); 
  glEnable(GL_CLIP_PLANE0);
/*         clipleft half -- x <0   */
glClipPlane(GL_CLIP_PLANE1, eqn2);
glEnable(GL_CLIP_PLANE1);
glRotatef(90.0,1.0, 0.0, 0.0);  
 glutWireSphere(1.0, 20,16);  
 glPopMatrix();
glFlush();
} 
 void reshape(int w,int h)
{
glViewport(0, 0,(GLsizei) w, (GLsizei) h); 
glMatrixMode(GL_PROJECTION); glLoadIdentity();
gluPerspective(60.0, (GLfloat) w/(GLfloat) h, 1.0, 20.0);
glMatrixMode(GL_MODELVIEW);
}
 
 int main(int argc,char** argv)
{
glutInit(&argc,argv); 
 glutInitDisplayMode(GLUT_SINGLE |GLUT_RGB); 
 glutInitWindowSize(500,500);  
 glutInitWindowPosition(100, 100);  
 glutCreateWindow(argv[0]);
init();
glutDisplayFunc(display);  
 glutReshapeFunc(reshape);  
 glutMainLoop();
return0;
}

Modelleme Dönüşümleri(ÖTELEME)

Modelleme Dönüşümleri(ÖTELEME)
OpenGL de üç temel model dönüşümü vardır, glTranslate*(), glRotate*(),ve glScale*( )dir. Bu rutinler nesneyi hareketle, döndürerek, uzatarak, küçülterek, yada yansıtarak öteler.
Bu üç komut uygun öteleme, döndürme, ve ölçü matrisini üretmek için yeterlidir. OpenGL otomatik olarak matrisleri sizin için hesaplanır.
ÖTELEME(glTranslate)

void glTranslated (GLdouble x,GLdouble y,GLdouble z)
void glTranslatef ( GLfloat x,GLfloat y,GLfloat z)

glTranslate nin x y z parametresi gecerli matrix modu ile belirlenen matrix
çarpılarak ötelenmektedir.

Örnek olarak kup programında bu uygulamaları yapa biliriz.

#include<GL/glut.h>

void init(void)
{
glClearColor(1.0, 1.0, 1.0, 1.0);
glShadeModel(GL_FLAT);
}

void display(void)
{
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(0.0, 0.0, 0.0); 


glLoadIdentity(); /* matrix temizleniyor */
gluLookAt(0.0, 1.0, 3.0,0.0, 0.0, 0.0, 0.0, 1.0, 0.0);/* Görüş dönüşümleri*/
glTranslatef(0.0, 0.0, 0.0); /* model Dönüşümleri */ 
glutWireCube(1.0);

glFlush();
}

void reshape(int w, int h)
{
glViewport(0, 0, (GLsizei) w, (GLsizei) h); 
glMatrixMode(GL_PROJECTION); 
glLoadIdentity();
glFrustum(-1.0, 1.0, -1.0, 1.0, 1.5, 20.0);
glMatrixMode(GL_MODELVIEW);
}

int main(int argc, char** argv)
{
glutInit(&argc, argv); 
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize(300, 300); 
glutInitWindowPosition(100, 100); 
glutCreateWindow("OpenGLTurk");
init();
glutDisplayFunc(display); 
glutReshapeFunc(reshape); 
glutMainLoop();
return 0;

}

kodun display fonksiyonunda gltranslate x y z degerleri 0.0 verilmiş

void display(void)
{
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(0.0, 0.0, 0.0);
glLoadIdentity(); /* matrix temizleniyor */
gluLookAt(0.0, 1.0, 3.0,0.0, 0.0, 0.0, 0.0, 1.0, 0.0);/* görüş dönüşümleri */
glTranslatef(0.0, 0.0, 0.0); /* model dönüşümleri */ 
glutWireCube(1.0);
glFlush();
}

öteleme fonksiyonunu x parametresini 1.0 olarak degiştirerek

glTranslatef(1.0, 0.0, 0.0);

öteleme fonksiyonunu y parametresini 1.0 olarak degiştirerek

glTranslatef(0.0,1.0, 0.0);

öteleme fonksiyonunu z parametresini 1.0 olarak degiştirerek

glTranslatef(0.0, 0.0, 1.0);

kup üzerinde etkisini göre bilriz Not:glTranslate*() için argüman olarak (0.0, 0.0, 0.0) kullanmanın nesne veya yerel koordinat sistemine hiçbir etkisi olmadığını unutmayın. DÖNDÜRME(glRotate)

void glRotated(GLdouble angle,GLdouble x,GLdouble y,GLdouble z);
void glRotatef( GLfloat angle,GLfloat x,GLfloat y,GLfloat z);

glRotate xyz parametreleri Gecerli matrixle çarpılarak dönme etkisi yaratmaktadır. Fonksiyonun angle parametresi dönme acısını belirtir. Örnek olarak z ekseninde 45 derecelik bir dönüş

glRotatef(45.0, 0.0, 0.0,1.0);

/* model dönüşümleri */ kısmına ekleyerek deneye bilirsiniz. NOT: Dönüş ekseninden uzakta bulunan bir nesnenin, eksene yakın çizilen bir nesneden daha keskin döndüğüne (daha geniş bir yörüngeye sahip) oldugunu unutmayın. BOYUTLANDIRMA(glScale)

void glScaled( GLdouble x,GLdouble y,GLdouble z);
void glScalef( GLfloat x,GLfloat y,GLfloat z);

Geçerli matris ile nesneyi eksenler boyunca geren, küçülten veya yassıtan bir matrisle çarpar. Nesnedeki her noktanın her bir x-, y- ve z- koordinatı karşılık gelen x, y veya z argümanı ile çarpılır. yerel koordinat sistemi yaklaşımıyla, yerel koordinat eksenleri x-, y- ve z-faktörleri ile gerilir, büzülür veya yassıtılır ve ilişik nesne onlarla beraber dönüştürülür. Örnek olarak kuptranslate.cpp programındaki kupu y ekseninde 2.0 derece modeli ölçekliyoruz.

glScalef(1.0, 2.0, 1.0);

glScale*(), bir nesnenin belirgin büyüklüğünü değiştiren üç modelleme dönüşümünden sadece biridir: 1.0’dan büyük bir değerle boyutlandırmak bir nesneyi uzatır ve 1.0’dan küçük değerler kullanmak onu küçültür. -1.0 değeriyle boyutlandırma bir nesneyi bir eksen üzerinde yansıtır. Ölçekleme için kimlik değerleri, (1.0, 1.0, 1.0)’dır. Genelde glScale*() kullanımınızı gerekli olduğu zamanlarla kısıtlamanız gerekir. glScale*() kullanmak ışıklandırma hesaplamalarının performansını azaltır çünkü yüzey vektörlerinin dönüştürmeden sonra yeniden normallaştirilmesi gerekir. Not: Sıfır değerinde bir ölçek o eksen boyunca tüm nesne koordinatlarını sıfıra çeker. Bunu yapmak genellikle iyi bir fikir değildir, çünkü böyle bir operasyon geriye alınamaz. Matematiksel olarak konuşursak matris geriye çevrilemez ve invers matrisler belli ışıklandırma operasyonları için gereklidir.

izdüşüm dönüşümleri(gluLookAt() Hizmet Rutinini Kullanma) (3)

izdüşüm dönüşümleri(gluLookAt() Hizmet Rutinini Kullanma) (3)

Programcılar bir sahneyi çoğunlukla orijin çevresinde veya bazı başka uygun konumlarda inşa etmek ve daha sonra onun iyi bir görüntüsünü elde etmek için ona keyfi bir noktadan bakmak ister. Adından anlaşılacağı gibi, gluLookAt() hizmet rutini sırf bu amaç için tasarlanmıştır. Görüş-noktasının konumunu belirleyen, kameranın çevrildiği yere doğru bir başvuru noktası tanımlayan ve hangi yönün sırada olduğunu gösteren üç set argüman alır.

gluLookAt
(
GLdouble eyex, GLdouble eyey, GLdouble eyez,
GLdouble centerx, GLdouble centery, GLdouble centerz,
GLdouble upx, GLdouble upy, GLdouble upz
);

gluLookAt Bir görüntüleme matrisi tanımlar . İstenen görüş-noktası eyex, eyey, eyez tanımlanır. centerx, centery, centerz argümanları istenen görüş hattı boyunca herhangi bir noktayı tanımlar ancak tipik olarak bakılan sahnenin merkezinde bir noktayı tanımlar. upx, upy, upz argümanları hangi doğrultunun yukarı olduğunu gösterir (yani görüntü hacminin altından üstüne doğru olan yön).

gluLookAt Sahnenin istenen görüntüsünü verecek görüş-noktası verir. Başvuru noktası genellikle sahnenin ortalarında bir yerlerdedir. (Eğer sahnenizi orijinde inşa ediyorsanız başvuru noktası muhtemelen orijinin kendisidir.)
gluLookAt() rutini örneğin bir arazi boyunca dolanmak istediğinizde özellikle kullanışlıdır. x- ve y- ‘de simetrik olan bir görüntüleme hacmi ile, tanımlanan (eyex, eyey, eyez) noktası daima ekrandaki görüntünün ortasındadır, bu nedenle bu noktayı biraz hareket ettirmek için bir seri komut kullanabilir, dolayısıyla da ekran boyunca dolanabilirsiniz.

İz düşüm Dönüşümleri(Ortografik izdüşüm) (2)

İz düşüm Dönüşümleri(Ortografik izdüşüm) (2)

Ortografik izdüşüm
Ortografik izdüşümün görüntüleme hacmi dikdörtgen bir paralel hatlı veya daha gayri resmi anlamda, bir kutudur.

Perspektif izdüşümün tersine, görüntü hacminin büyüklüğü bir uçtan bir uca değişmez dolayısıyla kameradan uzaklık bir nesnenin ne kadar büyük görüneceğini etkilemez. Bu tip projeksiyon, nesnelerin gerçek boyutları ile aralarındaki açıların planlandıkları gibi sürdürülmelerinin önemli olduğu mimari planlar ve bilgisayar-destekli tasarımlara dair uygulamalar için kullanılır.glOrtho() komutu bir ortografik paralel görüntü hacmi yaratır. glFrustum() ile olduğu gibi yakın kırpıcı düzlemin köşeleri ile uzak kırpıcı düzlemin uzaklığını belirler.Başka hiçbir dönüşüm olmaksızın, izdüşümün doğrultusu z-eksenine paraleldir ve görüş-noktası negatif z-eksenine doğru bakar.
glOrtho()

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

Ortografik paralel görüntü hacmi için bir matris tanımlar ve onu geçerli matris ile çarpar. (left, bottom, -near) ile (right, top, -near), görüş penceresinin sırasıyla sol alt ile üst sağ köşelerine haritalanan yakın kırpma düzlemi üzerindeki noktalardır. (left, bottom, -far) ile (right, top, -fear) görüş penceresinin aynı ilgili köşelerine haritalanan uzak kırpma düzlemi üzerindeki noktalardır. Hem near hem de far pozitif, negatif ve hatta sıfır olabilir. Bununla birlikte near ve far aynı değerlere sahip olmamalıdır.
Üç boyutlu görüntüler için ortografik izdüşüm komutu (glOrtho()) kullanıldıgı gibi openglde iki boyutlu ortografik izdüşüm komutu(gluOrtho2D()) belirlenmiştir.
gluOrtho2D()
Bu rutin, ekrandaki nesneler için tüm z koordinatlarının -1.0 ila 1.0 arasında bulunduğunu varsayması dışında glOrtho() üç boyutlu versiyonuna özdeşidir. Eğer iki-boyutlu nesneleri iki boyutlu köşe komutları kullanarak çiziyorsanız tüm z koordinatları sıfırdır, dolayısıyla hiçbir nesne z-koordinat değeri nedeniyle kırpılmaz.

void gluOrtho2D(GLdouble left, GLdouble right,GLdouble bottom, GLdouble top);

gluOrtho2D İki-boyutlu koordinatları ekran üzerine yansıtmak için bir matris yaratır ve bu matrisi geçerli izdüşüm matrisi ile çarpar. Kırpıcı düzlem sol alt köşesi (left, bottom) ve sağ üst köşesi (right, top) ile belirlenen bir dikdörtgendir.

İz düşüm Dönüşümleri(perspektif izdüşüm) (1)

İz düşüm Dönüşümleri(perspektif izdüşüm) (1)

İz düşüm nedir
Uzaydaki bir cisim, bir düzlem önünde tutulup bu cisme karşıdan bakılacak olursa , cismin düzlem üzerine bir görüntüsü düşer . İşte cisimlerin düzlem üzerine ışık ışınları yolu ile düşürülen bu görüntüsüne İzdüşüm denir.
Openglde izdüşüm
İzdüşüm dönüşümü kamera için lens seçimini belirlemek gibidir.
projection dönüşümleri 
Bu uygulamayı inceleye bilirsiniz.
Görüş alanını göz önünde tutmanın yanında, izdüşüm dönüşümünde nesnelerin nasıl ekran üzerine izdüşümünün yaratıldığına terim olarak görebiliriz. OpenGL izdüşümleri iki temel tipi kullanmaktadır, perspektif izdüşüm, Ortografik izdüşüm.
NOT:Kod yazarken iz düşüm dönüşümlerini uygulamadan önce

glMatrixMode(GL_PROJECTION);
glLoadIdentity();

çağırmayı unutmayın. Böylece komut model-görüntü matrisi yerine iz düşüm matrisini etkiler ve dolayısıyla iz düşüm dönüşümlerini birleştirilmez. Her bir izdüşüm dönüşüm komutu tamamen özel bir dönüşümü tanımladığından, bir izdüşüm dönüşümünü bir diğeri ile birleştirilmesi genellikle tercih edilmez.
izdüşüm dönüşümünün amacı iki şekilde kullanılabilen bir görüntüleme hacmi tanımlamaktır. Görüntüleme hacmi bir nesnenin ekrana nasıl yansıtıldığını belirler ve hangi nesne veya nesne parçasının son görüntüden kırpılacağını tanımlar. Bahsettiğimiz görüş-noktasını görüntü hacminin bir ucunda olduğunu düşünebilirsiniz.

Perspektif izdüşümler
Günlük hayatta nesneleri nasıl gördüğünüzü eşleştiren perspektif izdüşümün bir türüdür.Perspektif Cisimlerin uzaklaştıkça görünüşleri gerçek görünüşlerinden farklılaşarak ufalmasıdır.Openglde bu işlem,görüş noktasına daha yakın olan nesnelerin daha uzaktakilere oranla görüntü hacminin daha büyük bir orantısını kapladığından daha büyük görünmesini saglar ,görüntü noktasına uzak olan nesnelerde daha küçük görünmesini saglamaktadır. Bu projeksiyon metodu animasyon, görsel simülasyon ve bir derece gerçekçilik arayan uygulamalar için yaygın şekilde kullanılır çünkü çalışma şekli göz veya kameraya benzer. Openglnin İki temel perspektif komutu vardır,glFrustum(),gluPerspective()

void glFrustum(GLdouble left, GLdouble right,GLdouble bottom, GLdouble top,GLdouble near, GLdouble far);

glFrustum bir perspektif projeksiyon matrixsi oluşturur bu matrix belirlenen gecerli (glMatrixMode) matrix ile çarpılır ve görüntü hacmi elde edilir,görüntü hacmi şu parametrelerle tanımlanır: (left, bottom, -near) ile (right, top, -near),yakın kırpma düzleminin sırasıyla sol alt ile üst sağ köşelerinin (x, y, z) koordinatlarını belirler; near ve far, görüş-noktasından yakın ve uzak kırpma düzlemlerine olan mesafelerdir.

Görüntü hacmi yukarıdaki resimde gösterildiği gibi altı düzlemle çakışır. Bu düzlemlerin dışında kalan nesne veya nesne parçaları son görüntüde kırpılır. glFrustrum()’un simetrik bir görüntü hacmi tanımlamanızı gerektirmediğine dikkat edin.Fonksiyonun diger özelliklerini incelemek için opengl 2.1 referans sayfalarına bakınız.

gluPerspective()
void gluPerspective(GLdouble fovy,GLdouble aspect,GLdouble zNear, GLdouble zFar);

Simetrik-görüntü elde etmek için bir matris yaratır ve onu geçerli matrisle(glMatrixMode) çarpar. fovy görüntü alanının yz-düzlemi içindeki açısıdır; değeri [0.0, 180.0] aralığında olmak zorundadır. aspect, genişliği yüksekliğine bölünmüş görüntü oranıdır. near ve far değerleri z-ekseni boyunca görüş-noktası ile kırpıcı düzlemler arasındaki mesafelerdir

Tıpkı glFrustrum()’la olduğu gibi, gluPerspective() ile yaratılan görüntü hacminin varsayılan yönelimini değiştirmek için de dönüş ve çeviriler uygulayabilirsiniz. Bu tür dönüşümler olmadan görüş-noktası orijinde kalır ve görüş-çizgisi negatif z-ekseninden aşağı doğru bakar.gluPerspective() ile görüntü alanı için uygun değerler seçmek zorundasınız, aksi halde görüntü çarpık görünebilir. Mükemmel bir görüş alanı elde etmek için gözlerinizin ekrandan normalde ne kadar uzak olduğunu ve pencerenin ne kadar büyük olduğunu belirleyin ve pencerenin büyüklük ve mesafe altında karşılık geldiği açıyı hesaplayın.Kamera analojisi makalesindeki kup örneginde glFrustrum()fonksiyonunu

gluPerspective(60.0, 1.0, 1.5, 20.0);

 ile degiştirip degerleriyle oynayabilirsiniz ,konuyu kavramak açısından,ayrıca opengl 2.1 referans sayfalarından fonksiyonun diger özelliklerini inceleyin.

Kamera Analojisi

Kamera Analojisi

Geometrik nesnelerin çizimini örgendik şimdi bu nesnelerin 3 boyutlu alanda kamera açısı ve bulunacagı yerleri belirlemeyi ögrenicegiz.Örnegin aşşagıdaki resimdede görüldügü gibi her model farklı bir konumdadır bazıları masanın üzerinde bazıları yerde birde kameranın bakış açısı var , Daha önceki makalelerde bu iş biraz ressamlıga benzediginden bahsetmiştim .

Resmin yansıtılması 3 temel kurala dayalıdır.

1. Dönüşüm, Matriks çarpımları ile modelleme, denetleme, ve planlama işlemlerini içerir.Bu gibi işlemler

rotasyon, dönüşüm, ölçeklendirme, yansıtma, ortografik planlama ve perspektif planlamayı içerir. Genellikle,

tabloyu çizmek için bir çok dönüşümün birleşimi kullanılabilir.

2.Kırpma,Pencere oluşturuldugunda pencerenin dışında kalan nesneler ( yada nesnelerin parçaları) kesilmek zorundadır. Bu işleme Üç boyutlu düzlemde kırpma adı verilir.

3.Görüş alanı dönüşümü

Bu kurallar yazılarım içersinde incelenecektir.
3 Boyutlu duzlemde çizim yapabilmek için kamera tekniklerini iyi bilmemiz gerekmektedir bunun için kamera nın nasıl çalıştıgını anlamalıyız.
Kamera Analojisi

Openglde kamera kullanımı genel olarak fotoraf makinası kullanmaya benzer .

Bu kullanım 4 temel kurala dayalıdır.

1.Tripodunuzu kurun ve kameranızı tabloya ye

rleştirin (görüş dönüşümü).

2.İstenen kompozisyonda fotograflanması istenen tabloyu düzenleyin (modelleme dönüşümü).

3.Kamera lensini seçin yada odağı ayarlayın (gösterim dönüşümü).

4.Son fotografın ne kadar büyüklükte olmasını istediğinize karar verin—örneğin, onu büyütebilmek isteyebilirsiniz (görüş alanı dönüşümü).

Bu işlemlerin birde Bilgisayar tabanlı gerçekleştire biliriz.

1.Tripodunuzu kurun ve kameranızı tabloya yerleştirin (görüş dönüşümü).

1.Görüş dönüşümü

2.İstenen kompozisyonda fotograflanması istenen tabloyu düzenleyin (modelleme dönüşümü).

3.Kamera lensini seçin yada odağı ayarlayın (gösterim dönüşümü).

4.Son fotografın ne kadar büyüklükte olmasını istediğinize karar verin—örneğin, onu büyütebilmek isteyebilirsiniz (görüş alanı dönüşümü).

Bu işlemleri uyguladıktan sonra resim çekebilir veya tablonuzu çize bilirsiniz.

Bu şekilde kamera olaylarının temeleri belirlenmektedir.Şuna dikkat edilmelidirki görüş dönüşümleri model dönüşümlerinden önce gelmelidir,ancak izdüşüm ve görüş alanı dönüşümleri çizim oluşmadan önce belirlene bilir.Bu işlemlerin genel oluşum tablosu şu şekildedir.

Örnek Kup

#include<GL/glut.h>



void init(void)

{

glClearColor(0.0, 0.0, 0.0, 0.0);

glShadeModel(GL_FLAT);

}



void display(void)

{

glClear(GL_COLOR_BUFFER_BIT);

glColor3f(1.0, 1.0, 1.0);





glLoadIdentity(); /* Matrixler temizleniyor */

gluLookAt(0.0, 0.0, 5.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0); /* Görüş dönüşümü */

glScalef(1.0, 2.0, 1.0); /* model dönüşümü */

glutWireCube(1.0);

glFlush();

}



void reshape(int w, int h)

{

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

glMatrixMode(GL_PROJECTION);

glLoadIdentity();

glFrustum(-1.0, 1.0, -1.0, 1.0, 1.5, 20.0);

glMatrixMode(GL_MODELVIEW);

}



int main(int argc, char** argv)

{

glutInit(&argc, argv);

glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);

glutInitWindowSize(500, 500);

glutInitWindowPosition(100, 100);

glutCreateWindow("OpenGLTurk");

init();

glutDisplayFunc(display);

glutReshapeFunc(reshape);

glutMainLoop();

return 0;

}

Görüş dönüşümü(viewing transformation)
Kup programında görüş dönüşümü yerleştirilmeden önce glLoadIdentity()ile kimlik matrix i oluşturulmaktadır,glLoadIdentity ,dönüşüm komutlarınının güncel matris ile belirlenen matris tarafından çoğaltıldığından gereklidir.Eğer kimlik(glLoadIdentity) matrisi yükleyerek güncel matrisi temizlemezseniz, önceki dönüşüm matrislerini yeni temin edilenlerden biri ile birleşir bu gibi durumlarda birleştirmeleri uygulamak istemiye bilirsiniz matrisi temizlemeye ihtiyacınız olur.
Kimlik matrixi oluşturulduktan sonra görüş dönüşümü gluLookAt ile belirlenmiştir.gluLookAt Fonksiyonu kameranın yada görüş pozinyonunu nereye yerleştirildiğini, ne amaçlandığını ve hangi yönde olduğunu gösterir. Burada kullanılan argümanlar kamerayı (0, 0, 5) e yerleştirir, (0, 0, 0) a doğru kamera lensini tutar, ve üst vektörü (0, 1, 0) olarak belirler. Üst vektör kamera için bir tek yönlenmeyi tanımlar.
Modelleme Dönüştürümü(The Modeling Transformation)
Modelleme dönüştürümünü modeli yerleştirmek ve yönlendirmek için kullanırsınız. Örneğin, modeli döndürmek, çevirmek, yada ölçeklendirmek -- yada bu işlemlerin bazı birleşimlerini uygulayabilirsiniz. küp programında glScalef() kullanılan modelleme dönüştürücüsüdür. Bu komut için üç eksen boyunca ölçeklendirmenin nasıl belirlenmesi gerektiği gösterilmiştir. Eğer tüm argümanlar 1.0 ise, bu komutun etkisi yoktur. Küp y- ekseninde iki kat daha büyük çizilmiştir. Bunun nedeni y eksenine 2.0 degeri verilmesidir.
glScalef(1.0, 2.0, 1.0);
küpün orjinal degerleri (3.0, 3.0, 3.0) dır, glScalef fonksiyonu ile (3.0, 6.0, 3.0)’a eşitlenmiştir. Bu modelleme dönüştürümünün etkisi kübü dönüştürmektir bu yüzden o küp değildir aslında dikdörtgen kutudur.Bunu glScalef fonksiyonunu etkisiz hale getirerekte anlaya bilirsiniz.