Winapi Mfc Form Listbox

Winapi Mfc Form Listbox.rar

#include <windows.h>

#include "resource.h"

LRESULT CALLBACK WndProc (HWND hWnd, UINT message,WPARAM wParam, LPARAM lParam);



int WINAPI WinMain (HINSTANCE hInstance,

HINSTANCE hPrevInstance,

LPSTR lpCmdLine,

int iCmdShow)

{

WNDCLASS wc;

HWND hWnd;

HDC hDC;

HGLRC hRC;       

MSG msg;

BOOL bQuit = FALSE;

float theta = 0.0f;

wc.style = CS_OWNDC;

wc.lpfnWndProc = WndProc;

wc.cbClsExtra = 0;

wc.cbWndExtra = 0;

wc.hInstance = hInstance;

wc.hIcon = LoadIcon (NULL, IDI_APPLICATION);

wc.hCursor = LoadCursor (NULL, IDC_ARROW);

wc.hbrBackground = (HBRUSH) GetStockObject (WHITE_BRUSH);

wc.lpszMenuName = NULL;

wc.lpszClassName ="OpenGLTurk";

RegisterClass (&wc);

hWnd = CreateWindow ("OpenGLTurk","OpenGLTurk--Yasin Demirci",WS_CAPTION  |  WS_POPUPWINDOW | WS_VISIBLE | WS_OVERLAPPEDWINDOW ,30, 30, 600,400,NULL, NULL, hInstance, NULL);

HWND yavru=yavru=CreateDialog(hInstance, MAKEINTRESOURCE(IDD_DIALOG1), hWnd,DLGPROC(WndProc));

HWND hListBox =GetDlgItem(yavru,IDC_LIST1);

SendMessage( hListBox, LB_ADDSTRING, 0, (LPARAM) ("Test1"));

SendMessage( hListBox, LB_ADDSTRING, 0, (LPARAM) ("Test2"));

SendMessage( hListBox, LB_ADDSTRING, 0, (LPARAM) ("Test3"));

ShowWindow (yavru, iCmdShow) ; // mfc pencerenizin gösterimi

     UpdateWindow (yavru) ; // mfc penceresinin guncellemesi

while (!bQuit)

{

if (PeekMessage (&msg, NULL, 0, 0, PM_REMOVE))

{

/* mesaj dağıtma*/

if (msg.message == WM_QUIT)

{

bQuit = TRUE;

}

else

{

TranslateMessage (&msg);

DispatchMessage (&msg);

}

}

else

{



}

}



DestroyWindow (hWnd);



return msg.wParam;

}

LRESULT CALLBACK WndProc (HWND hWnd, UINT message,WPARAM wParam, LPARAM lParam)

{



switch (message)

{

case WM_CREATE:

return 0;

case WM_CLOSE:

PostQuitMessage (0);

return 0;



case WM_DESTROY:

return 0;



case WM_KEYDOWN:

switch (wParam)

{

case VK_ESCAPE:

PostQuitMessage(0);

return 0;

}

return 0;



default:

return DefWindowProc (hWnd, message, wParam, lParam);

}

}

Gerçek-Dünya ve OpenGL Işıklandırma,Ambiyans, Yayılma, Aynamsı ve Yayınımcı Işık

Gerçek-Dünya ve OpenGL Işıklandırma,Ambiyans, Yayılma, Aynamsı ve Yayınımcı Işık

Fiziksel bir yüzeye baktığınızda gözlerinizin renk algısı, konik hücrelerinize ulaşan ve uyaran foton enerjisinin dağılımına bağlıdır. (Renk Algıs bölümüde bunu inceledik”). Bu fotonlar bir ışık kaynağı ve kaynak kombinasyonundan gelir, bir kısmı soğurulur ve bir kısmı da yüzey tarafından yansıtılır. Ek olarak farklı yüzeylerin farklı özellikleri olabilir – kimisi parlaktır ve ışığı belli yönlerde özellikle yansıtırken diğerleri gelen ışığı her yöne eşit şekilde dağıtır. Çoğu yüzey bu ikisinin arasındadır.

OpenGL ışık ve ışıklandırmaya sanki ışık kırmızı, yeşil ve mavi bileşenlere kırılabilirmiş gibi yaklaşır. Böylece bir ışık kaynağının rengi yaydığı kırmızı, yeşil ve mavi ışıkların miktarı ve bir yüzeyin malzemesi, farklı yönlere dağıtılan gelen kırmızı, yeşil ve mavi ışığın yüzdesi ile karakterize edilir. OpenGL ışıklandırma eşitlikleri sadece yaklaşık tahminlerdir ancak oldukça iyi çalışırlar ve nispeten daha hızlı şekilde hesaplanırlar. Eğer daha kesin (veya sadece farklı) bir ışıklandırma modeli istiyorsanız yazılımda kendi hesaplamalarınız yapmak zorundasınız. Böylesi yazılımlar, birkaç saatlik optik ders kitabı okumasının sizi ikna edeceği gibi, muazzam şekilde karmaşıktırlar.

OpenGL ışıklandırma modelinde bir sahnedeki ışık, münferit olarak açıp-kapatılabilen birkaç ışık kaynağından gelir. Bazı ışıklar belli bir yön veya konumdan gelir ve bazıları ise genel olarak sahneye dağılır. Örneğin bir odada ampulü yaktığınızda ışığın çoğu ampulden gelir ancak kimi ışıklar bir, iki, üç veya daha fazla duvardan sekmekten ileri gelir. Bu seken ışıklar (ambiyans ışıkları denir) orijinal yönlerini söylemenin mümkün olmayacağı şekilde dağıldığı varsayılır ancak ışık kaynağının kapatılması durumunda kaybolurlar.

Son olarak, sahnede  sanki o kadar çok sekmiştir ki orijinal kaynağını belirlemenin imkânsız olduğu belli hiçbir kaynaktan gelmeyen genel bir ambiyans ışığı olabilir.

Open GL modelinde ışık kaynaklarının sadece orada ışığı emecek ve yansıtacak nesneler olması durumunda etkisi vardır. Her bir yüzeyin çeşitli özelliklere sahip bir materyalden yapılığı varsayılır. Bir materyal kendi ışığını (bir otomobilin farları gibi) yayabilir, gelen ışığın bir kısmını tüm yönlerde dağıtabilir ve bir kısmını ise tercih edilen yönde yansıtabilir (bir ayna veya başka bir parlak yüzey gibi).

Ambiyans, Yayılma, Aynamsı ve Yayınımcı Işık

Ambiyans ışıklandırma, çevre tarafından orijinal kaynağını belirlemenin imkânsız olacağı şekilde dağıtılmış olan ışıklardır – tüm yönlerden geliyormuş gibi görünürler. Gözünüze ulaşan ışığın çoğu öncelikle pek çok yüzeyden sektiğinden dolayı bir odadaki arka ışık büyük bir ambiyans bileşenine sahiptir. Bir dış mekân spot ışığının çok küçük bir ambiyansı vardır; ışığın çoğu aynı yönde gider ve siz de dışarıda olduğunuzdan çogu ışık nesnelere çarparak gözünüze ulaşır. Ambiyans ışığı bir yüzeye vurduğunda tüm yönlere eşit şekilde dağılır.

Yayılma bileşeni, bir doğrultudan gelen ışık demektir, bu nedenle yüzeye zorlukla değmek yerine dik olarak geldiğinde çok daha parlaktır. Bununla birlikte bir yüzeye çarptığı anda tüm yönlere eşit şekilde dağılır, böylece gözün nereden baktığı önemli olmaksızın aynı parlaklıkta görünür. Belli bir doğrultu ve ya konumdan gelen her türlü ışığın bir yayılım bileşeni vardır.

Aynamsı ışık belli bir doğrultudan gelir ve tercih edilen bir doğrultuda yüzeyden seker. Yüksek kalitedeki bir aynadan seken iyi bir paralelliğe sahip lazer demeti %100’lük aynamsı yansıma üretir. Parlak metal veya plastiğin yüksek bir aynamsı bileşeni ve tebeşir veya halı gibi nesnelerin hiç aynamsı bileşeni yoktur. Aynamsıliği parlaklık olarak düşünebilirsiniz.

Ambiyans, yayılma ve aynamsı renklere ek olarak materyaller, nesnen kaynaklanan ışığa benzeyen bir yayınım rengine sahip olabilir. OpenGL ışıklandırma modelinde bir yüzeyin yayınım rengi nesneye derinlik katar ancak hiçbir ışık kaynağından etkilenmez. Ayrıca yayınım rengi genel sahneye herhangi ek ışık katkısı yapmaz. 

Materyal Renkleri,Işıklar ve Materyaller için RGB Değerleri

Materyal Renkleri,Işıklar ve Materyaller için RGB Değerleri

Materyal Renkleri    

OpenGL ışıklandırma modeli bir materyalin rengini, gelen ışıktan yansıttığı kırmızı, yeşil ve mavi bileşenlerin yüzdesinden tahmin eder. Örneğin  kırmızı  bir toptan  gelen tüm kırmızı ışıkları yansıtır ve tüm yeşil ve mavi ışıkları soğurur. Eğer böyle bir topu beyaz ışıkta görürseniz (eşit miktarlarda kırmızı, yeşil ve mavi renkten oluşan) tüm kırmızı yansıtılmıştır ve siz bir kırmızı top görürsünüz. Eğer top saf kırmızı ışıkta görülürse yine kırmızı görünecektir. Bununla birlikte eğer saf yeşil ışıkta görülürse siyah (tüm yeşil soğurulur ve gelen kırmızı olmadığından yansıtılacak ışık da yoktur).

Işıklar gibi materyallerin de, materyallerin ambiyansını, yayılma ve aynamsı yansımalarını belirleyen farklı ambiyans, yayılma ve aynamsı renkleri vardır. Bir materyalin ambiyans yansıma çarpanı her bir gelen ışık kaynağının ambiyans bileşeni ile birleşmiş, ışığın yayılma bileşeni ile yansıma çarpanı ile karışmıştır ve aynamsı yansıma çarpanı ile aynamsı bileşen için de durum aynıdır. Ambiyans ve yayılma yansıma çarpanları malzemenin rengini tanımlar ve tipik olarak özdeş değilseler bile benzerdirler. Spekular yansıma genellikle beyaz veya gridir, bu nedenle aynamsı spot ışıkları ışık kaynağının aynamsı ışık şiddetinin rengine sahip olur. Beyaz bir ışığın parlak bir kızıl plastik küre üstünde parladığını düşünün, kürenin çoğu kırmızı görünür ana parlak spot beyazdır.

Işıklar ve Materyaller için RGB Değerleri

Işık için belirlenen renk bileşenleri, materyaller için olduğundan daha farklı anlam ifade eder. Bir ışık için sayılar her bir renk için tam şiddetin bir yüzdesine karşılık gelir. Eğer bir ışığın rengi için R, G ve B değerlerinin hepsi 1.0’a eşitse, ışık en parlak olası beyazdır. Eğer değerler 0.5 ise, renk hâlâ beyazdır ancak şiddeti yarıya inmiştir ve bu nedenle gri görünür. Eğer R=G=1 ve B=0 ise (hiç mavi olmaksızın tam kırmızı ve yeşil) ışık sarı görünür.

Materyaller için sayılar, o renklerin yansıyan oranlarına karşılık gelir. Yani, eğer R=2, G=0.5 ve B=0 ise o materyal gelen kırmızı ışığın tümünü ve yeşilin yarısını yansıtır ve gelen hiçbir mavi ışık yoktur. Diğer bir deyişle, eğer bir OpenGL ışığı (LR, LG, LB) bileşenlerine sahipse ve bir materyal karşılık gelen (MR, MG, MB) bileşenlerini içeriyorsa , bu durumda tüm diğer yasıtma etkilerini ihmal ederek, göze gelen ışık (LR.MR, LG.MG, LB.MB) ile verilir.

Benzer olarak, eğer göze (R1, G1, B1) ve (R2, G2, B2) gönderen iki ışığını varsa OpenGL, (R1+R2, G1+G2, B1+B2) vererek bileşen ekler. Herhangi bir toplamın 1’den büyük olamsı durumunda (ekipmanın gösterebileceğinden daha parlak bir renge karşılık gelir) bileşen 1’e kenetlenir.

Basit Bir Örnek: Işıklandırılmış Bir Küreyi Kaplamak

Bunlar, sahnenize ışık eklemek için gerekli adımlar:

1. Her nesnenin her köşesi için normal vektörler tanımlayın. Bu normaller nesnenin ışık kaynağına göre yönelimini belirler.
2. Bir veya daha fazla ışık kaynağı yaratın, seçin ve konumlandırın.
3. Küresel ambiyans ışık seviyesini ve görüş noktasının etkin konumunu belirleyen bir ışıklandırma modeli yaratın ve seçin (ışıklandırma hesapları açısından)
4. Sahnedeki nesneler için malzeme özellikleri tanımlayın.

Örnek   light.c

#include <GL/glut.h>
void init(void)
{
GLfloat mat_specular[] = { 1.0, 1.0, 1.0, 1.0 };
GLfloat mat_shininess[] = { 50.0 };
GLfloat light_position[] = { 1.0, 1.0, 1.0, 0.0 };
GLfloat white_light[] = { 1.0, 1.0, 1.0, 1.0 };
GLfloat lmodel_ambient[] = { 0.1, 0.1, 0.1, 1.0 };
glClearColor(0.0, 0.0, 0.0, 0.0);
glShadeModel(GL_SMOOTH);
glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);
glLightfv(GL_LIGHT0, GL_POSITION, light_position);
glLightfv(GL_LIGHT0, GL_DIFFUSE, white_light);
glLightfv(GL_LIGHT0, GL_SPECULAR, white_light);
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glEnable(GL_DEPTH_TEST);
}
void display(void)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glutSolidSphere(1.0, 20, 16);
glFlush();
}
void reshape(int w, int h)
{
glViewport(0, 0, (GLsizei) w, (GLsizei) h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
if (w <= h)
glOrtho(-1.5, 1.5, -1.5*(GLfloat)h/(GLfloat)w,
1.5*(GLfloat)h/(GLfloat)w, -10.0, 10.0);
else
glOrtho(-1.5*(GLfloat)w/(GLfloat)h,
1.5*(GLfloat)w/(GLfloat)h, -1.5, 1.5, -10.0, 10.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
}
int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB | GLUT_DEPTH);
glutInitWindowSize(500, 500);
glutInitWindowPosition(100, 100);
glutCreateWindow(argv[0]);
init();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutMainLoop();
return 0;
}

 Örnekte ile ilgili olarak düşülecek bir not, RGBA renk modunu kullanıyor olduğudur. OpenGL ışıklandırma hesaplaması iki mod için farklıdır ve aslında ışıklandırma kapasiteleri renk-endeks modunda çok daha sınırlıdır. Böylece RGBA ışıklandırma yaparken tercih edilir . 

Her Nesnenin Her Köşesi İçin Normal Vektörler Tanımlamak

Bir nesnenin normalleri ışık kaynaklarıyla ilgili yönelimlerini belirler. Her bir köşe için OpenGL, bu köşenin her bir ışık kaynağından ne kadar ışık aldığını belirlemek için atanmış normal kullanır. Bu örnekte küre için normaller glutSolidSphere() şablonunun parçası olarak kullanılır.

Uygun ışıklandırma için, yüzey normalleri birim uzunlukta olmalıdır. Aynı zamanda model-görüntü dönüşüm matrisinin yüzey normalini artık birim uzunlukta olmayacak şekilde ölçeklendirmemesine dikkat etmek zorundasınız. Normallerin birim uzunlukta olduğundan emin olmak için  GL_NORMALIZE veya GL_RESCALE_NORMALi parametre olarak içeren glEnable()komutunu çağırmanız gerekebilir.

GL_RESCALE_NORMAL, bir yüzey normalindeki her bir bileşenin, model-görüntü dönüşüm matrisi tarafından belirlenen aynı değerle çarpılmasını sağlar. Bu nedenle sadece normal tekdüze olarak ölçeklenmiş ve başlangıçtan itibaren birim uzunlukta ise doğru şekilde çalışır.GL_NORMALIZE,GL_RESCALE_NORMAL’den çok daha dosdoğru bir operasyondur. GL_NORMALIZE etkinleştirildiğinde normal vektörün uzunluğu hesaplanır ve daha sonra normalin her bir bileşeni hesaplanan uzunluğa bölünür. Bu operasyon sonuç normalin birim uzunlukta olmasını garantiler ancak basit yeniden ölçeklendirme normallerinden daha pahalı olabilir.

Not: Bazı OpenGL uygulamaları, aslında normal vektörleri sadece ölçerek değil normalleştirmek suretiyle  GL_RESCALE_NORMAL komutunu uygulayabilir. Bununla birlikte uygulamanızın bunu yapıp yapmadığını veya genellikle buna güvenmeniz gerekip gerekmediğini belirleyemezsiniz. 

Bir veya Daha Fazla Işık Kaynağı Yaratma, Konumlandırma ve Etkinleştirme

light.c örneginde beyaz ışık veren tek bir ışık kaynağı kullanmaktadır. Konumu glLightfv() komutu ile belirlenir. Bu örnek beyazı, yayılma ve ayna-benzeri yansıma hesaplamaları için sıfır ışığın rengi (GL_LIGHT0) olarak belirler. Eğer farklı renkte bir ışık istiyorsanız glLight*()’ı değiştirin.

Ekranınıza çeşitli renklerde en az sekiz farklı ışık kaynağı da dâhil edebilirsiniz. (Open GL’nin kullandığınız özel uygulaması sekizden fazlasına izin verebilir.) Varsayılan ışık rengi GL_LIGHT0 haricinde siyahtır. Işık kaynaklarını aynı zamanda istediğiniz yere de yerleştirebilirsiniz. Örneğin bir masa lambası kimliğinde ekranın yakınına veya güneş ışığını temsil etmek üzere ekranın uzağına yerleştirebilirsiniz. Ek olarak, ışık kaynağının dar, odaklanmış ışık demeti veya daha geniş bir ışık demeti vermesini de kontrol edebilirsiniz. Her bir ışık kaynağının, ekranı kaplamak için gereken hesaplara önemli şekilde ek getirdiğini, bu nedenle performansın ekrandaki ışık kaynağı sayısından etkilendiğini unutmayın. 

İstediğiniz ışık kaynağının karakteristiklerini tanımladıktan sonra onları glEnable() komutu ile açık hale getirmelisiniz. Aynı zamanda, OpenGL’yi ışıklandırma hesaplamalarını gerçekleştirmek üzere hazırlamak için GL_LIGHTING’i bir parametre olarak içeren glEnable() komutunu çağırmanız gerekir.

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.