İ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.

Öznitelikler(glPushAttrib, glPopAttrib)

Öznitelikler(glPushAttrib, glPopAttrib)

#include<GL/glut.h>

void pencere(void)

{



glClearColor(1.0,1.0,1.0,1.0);

glClear(GL_COLOR_BUFFER_BIT);

glLineWidth(1);//çizgi kalınlıgı

glPushAttrib (GL_LINE_BIT);

/*glPushAttrib fonsiyonundaki parametrede yıgımlarda

saklanacak tipi belirlemektedir şuan LINE glLineWidth parametresinde

belilenen degerden başba bir deger almamıştır,alınan degerler yıgında saklanacaktır

*/

glLineWidth (5);// glLineWidth degeri degiştiriliyor

glLineStipple (3, 0xff);// çizgi kesik kesik hale getiriliyor

glEnable(GL_LINE_STIPPLE);//glLineStipple aktif

glBegin (GL_LINES);//çizgi çiziliyor

glColor3f(1.0,0.0,0.0);// iki çizim arasındaki fark anlaşılsın diye ilk renk kırmızı

glVertex2f (0.4,0.4);

glVertex2f (-0.4,0.4);

glVertex2f (-0.6,-0.1);

glVertex2f (-0.2,-0.4);

glEnd ();

glPopAttrib ();

/*glPushAttrib teki degerler geri cagrılıyor ,glPopAttrib ten

sonraki kodlara yukarıdaki degerler artık etki etmeyecektir çünki,

glPushAttrib ve glPopAttrib arasında belirlenen tipe göre bilgiler

yıgınlarda saklanır ve glPopAttrib ten sonra serbest bırakılır*/

glColor3f(0.0,0.0,1.0);//ikinci çizim belirginligi için mavi renk tanımlanıyor

// glPushAttrib e kadar belirlenen özellikler etkindir.

glBegin (GL_LINES);

glVertex2f (0.3,0.3);

glVertex2f (-0.3,0.3);

glVertex2f (-0.5,-0.2);

glVertex2f (-0.1,-0.3);

glEnd ();

glFlush();

}





int main(int argcp,char **argcv)

{

glutInit(&argcp,argcv);

glutInitDisplayMode(GLUT_SINGLE);

glutInitWindowPosition(100, 200);

glutInitWindowSize(300,200);

glutCreateWindow("OpenGLTurk");

glutDisplayFunc(pencere);

glutMainLoop();

return 0;

}

Poligon detayları(glPolygonStipple)

Poligon detayları(glPolygonStipple)

#include<GL/glut.h>
void kare(void)
{
glColor3f(0.0,0.0,1.0);
glBegin(GL_POLYGON);
glVertex2f(0.4,0.4);
glVertex2f(-0.4,0.4);
glVertex2f(-0.4,-0.4);
glVertex2f(0.4,-0.4);
glEnd();
}
void pencere(void)
{
GLubyte fly[] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x03, 0x80, 0x01, 0xC0, 0x06, 0xC0, 0x03, 0x60,
0x04, 0x60, 0x06, 0x20, 0x04, 0x30, 0x0C, 0x20,
0x04, 0x18, 0x18, 0x20, 0x04, 0x0C, 0x30, 0x20,
0x04, 0x06, 0x60, 0x20, 0x44, 0x03, 0xC0, 0x22,
0x44, 0x01, 0x80, 0x22, 0x44, 0x01, 0x80, 0x22,
0x44, 0x01, 0x80, 0x22, 0x44, 0x01, 0x80, 0x22,
0x44, 0x01, 0x80, 0x22, 0x44, 0x01, 0x80, 0x22,
0x66, 0x01, 0x80, 0x66, 0x33, 0x01, 0x80, 0xCC,
0x19, 0x81, 0x81, 0x98, 0x0C, 0xC1, 0x83, 0x30,
0x07, 0xe1, 0x87, 0xe0, 0x03, 0x3f, 0xfc, 0xc0,
0x03, 0x31, 0x8c, 0xc0, 0x03, 0x33, 0xcc, 0xc0,
0x06, 0x64, 0x26, 0x60, 0x0c, 0xcc, 0x33, 0x30,
0x18, 0xcc, 0x33, 0x18, 0x10, 0xc4, 0x23, 0x08,
0x10, 0x63, 0xC6, 0x08, 0x10, 0x30, 0x0c, 0x08,
0x10, 0x18, 0x18, 0x08, 0x10, 0x00, 0x00, 0x08};
//çizimde kullanılacak fly dizisi tanımlanıyor

GLubyte halftone[] = {
0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55,
0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55,
0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55,
0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55,
0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55,
0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55,
0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55,
0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55,

0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55,
0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55,
0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55,
0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55,
0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55,
0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55,
0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55,
0xAA, 0xAA, 0xAA, 0xAA, 0x55, 0x55, 0x55, 0x55};
//çizimde kullanılacak halftone dizisi tanımlanıyor
glClearColor(1.0,1.0,1.0,1.0);
glClear(GL_COLOR_BUFFER_BIT);

glEnable(GL_POLYGON_STIPPLE);
//glPolygonStipple kullanımı aktif duruma getiriliyor
glPolygonStipple(fly);
/*glPolygonStipple fonksiyonu çizimi fly dizisi ile yapmaktadır
dizi hex sayısistemi içerir*/
glViewport(0,0,180,180);//sol 
kare();
//glPolygonStipple çizimi yapılacak yuzey kare yuzeyi
glPolygonStipple(halftone);
/*glPolygonStipple fonksiyonu çizimi halftone dizisi ile yapmaktadır
dizi hex sayısistemi içerir*/
glViewport(100,0,180,180);// sag 
kare();
//glPolygonStipple çizimi yapılacak yuzey kare yuzeyi
glDisable(GL_POLYGON_STIPPLE);//glPolygonStipple pasifleştiriyor
glFlush();
}


int main(int argcp,char **argcv)
{
glutInit(&argcp,argcv);
glutInitDisplayMode(GLUT_SINGLE);
glutInitWindowPosition(100, 200);
glutInitWindowSize(260,200);
glutCreateWindow("OpenGLTurk");
glutDisplayFunc(pencere);
glutMainLoop();
return 0;
}

Yüzeylerin Secimi(glCullFace)

Yüzeylerin Secimi(glCullFace)

#include<gl/glut.h>
void kare(void)
{
glColor3f(0.0,0.0,1.0);
glBegin(GL_POLYGON);
glVertex2f(0.4,0.4);
glVertex2f(-0.4,0.4);
glVertex2f(-0.4,-0.4);
glVertex2f(0.4,-0.4);       
glEnd();
}

void pencere(void)
{
glClearColor(1.0,1.0,1.0,1.0);
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(0.0,0.0,1.0);
/*
GL_CW   :saat yönünde çizim

GLCCW  :saatin tersi yönünde çizim
*/
glCullFace(GL_BACK);//ters(arka yuz) çizimler pasifleştiriliyor
glEnable(GL_CULL_FACE);
glPolygonMode(GL_FRONT, GL_LINE);
glFrontFace(GL_CW);//GL_LINE saat yönude arka yuzde görünecektir
glViewport(0,0,180,180);//sol alt 
kare();

//çizim glFrontFace(GL_CCW) ön yuzun çizim gercekleştigi için çizimn görünmektedir.
glPolygonMode(GL_FRONT, GL_LINE);
glFrontFace(GL_CCW);//GL_LINE saatin tersi yönünde ön yuzde görünecektir
glViewport(100,0,180,180);// sag alt
kare();


glFlush();
}
int main(int argcp,char **argcv)
{
glutInit(&argcp,argcv);
glutInitDisplayMode(GLUT_SINGLE);
glutInitWindowPosition(100, 200);
glutInitWindowSize(260,200);
glutCreateWindow("OpenGLTurk");
glutDisplayFunc(pencere);
glutMainLoop();
return 0;
}

Yüzeylerin Secimi(glFrontFace)

Yüzeylerin Secimi(glFrontFace)

#include<gl/glut.h>
void kare(void)
{
glColor3f(0.0,0.0,1.0);
glBegin(GL_POLYGON);
glVertex2f(0.4,0.4);
glVertex2f(-0.4,0.4);
glVertex2f(-0.4,-0.4);
glVertex2f(0.4,-0.4);       
glEnd();
}

void pencere(void)
{
glClearColor(1.0,1.0,1.0,1.0);
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(0.0,0.0,1.0);
/*
GL_CW   :saat yönünde çizim

GLCCW  :saatin tersi yönünde çizim
*/
glPolygonMode(GL_FRONT, GL_LINE);
glFrontFace(GL_CW);//GL_LINE arka yuzde görünecektir
glViewport(0,0,180,180);//sol alt 
kare();

glPolygonMode(GL_FRONT, GL_LINE);
glFrontFace(GL_CCW);//GL_LINE ön yuzde görünecektir
glViewport(100,0,180,180);// sag alt
kare();


glFlush();
}
int main(int argcp,char **argcv)
{
glutInit(&argcp,argcv);
glutInitDisplayMode(GLUT_SINGLE);
glutInitWindowPosition(100, 200);
glutInitWindowSize(260,200);
glutCreateWindow("OpenGLTurk");
glutDisplayFunc(pencere);
glutMainLoop();
return 0;
}

Polygon detayları(glPolygonMode)

Polygon detayları(glPolygonMode)

#include<gl/glut.h>
void kare(void)
{
glColor3f(0.0,0.0,1.0);
glBegin(GL_POLYGON);
glVertex2f(0.4,0.4);
glVertex2f(-0.4,0.4);
glVertex2f(-0.4,-0.4);
glVertex2f(0.4,-0.4);       
glEnd();
}

void pencere(void)
{
glClearColor(1.0,1.0,1.0,1.0);
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(0.0,0.0,1.0);
glPointSize(3.0);
glPolygonMode(GL_FRONT, GL_LINE);
/*çizimde etkilenecek yuzey ve çizim şekli belirleniyor
fonksiyonda GL_FRONT ön yuz seçilmiş GL_LINE çizim şekli seçilmiş*/
glViewport(0,0,130,100);//sol alt 
kare();

glPolygonMode(GL_FRONT, GL_FILL);
/*çizimde etkilenecek yuzey ve çizim şekli belirleniyor
fonksiyonda GL_FRONT ön yuz seçilmiş GL_FILL çizim şekli seçilmiş
GL_FILL çizim şekli polygonun  içi dolu çizilmesini saglar
*/
glViewport(130,0,130,100);// sag alt
kare();

glPolygonMode(GL_FRONT_AND_BACK , GL_FILL);
/*çizimde etkilenecek yuzey ve çizim şekli belirleniyor
fonksiyonda GL_FRONT_AND_BACK hem ön hem arka yuz seçilmiştir
GL_FILL çizim şekli seçilmiş*/
glViewport(0,100,130,100);//üst sol
kare();

glPolygonMode(GL_FRONT, GL_POINT);
/*çizimde etkilenecek yuzey ve çizim şekli belirleniyor
fonksiyonda GL_FRONT ön yuz seçilmiş GL_POINT çizim şekli seçilmiş
GL_POINT çizim şekli vertex köşe noktalrını belirtir.*/
glViewport(130,100,130,100);//üst sag
kare();
/*çizimler de GL_FRONT ön yuz,GL_FRONT_AND_BACK ön ve arka yuz 
oldugu gibi sadece GL_BACK arka yuzde kullanıla bilir*/
glFlush();
}
int main(int argcp,char **argcv)
{
glutInit(&argcp,argcv);
glutInitDisplayMode(GLUT_SINGLE);
glutInitWindowPosition(100, 200);
glutInitWindowSize(260,200);
glutCreateWindow("OpenGLTurk");
glutDisplayFunc(pencere);
glutMainLoop();
return 0;
}