Opengl-Glut İle Oyun Programlama

Opengl-Glut ile oyun programlama
OpenGL nedir?
Icinizde eskiden C ve C++ grafiklerini kullanarak oyun yapmaya calisan yoktur herhalde :D Ama sonucta cogumuz bir husrana ugradik ve istedigimiz destegi alamadik, Ama animasyonlari cok kolay ....... lari cok kolay yapabilecegimiz bir eklenti dir OpenGL
GLut nedir?:
Glut opengl in ozelliklerini tasiyon ama windows un pencere yaratma ..., memory islemlerini kolaylastirmis bir sekilde yapmamiza yarayan bir kit deiyebiliriz;

Ihtiyacimiz olanlar;
DevCpp yada Visual C(Borland C olmuyor, Ama yapanlar duydum :D )
Glut Kit(www.opengl.org da bulabilirsiniz)


glutdlls36.zip i indirdim ben
zip li dosyayi actik icinde .h .lib ve .dll ler var
.h leri Visual Studio nun Include\GL klasorune atariz
.lib leri Visual Studio nun Lib klasorune atariz
.dll leri de windows\system32 ye atariz
Simdi Visual C ile glut kullanarak basit bir ornek;
Visual C yi actik
File->New->Projects->WIn32 Console Application proje adi olarak istediginiz bisi girebilirsiniz 
File->New->Files->C++ source file istedigimiz adi girebiliriz


Proje Ayarlari:
NOT:Simdi yapacagimiz ayarlar her proje icin tekrarlanacak
Project->Settings->Link->Object/Library Modules e opengl32.lib glut32.lib glu32.lib leri ekliyoruz

ve KoD:

#include <GL/glut.h>


void renderScene(void){//cizimleri yapacak fnksyion her zmn void olur
glClear(GL_COLOR_BUFFER_BIT);
/*gl clear bir opengl fonksiyonu ve bu fonksiyon zorunlu bu genelde temizleme yani grafiklerin gorulmesi icin on hazirlik diyebilirz*/

glBegin(GL_TRIANGLES);
/*bir GL_TRIANGLES triangles cizimine basla, GL_TRIANGLES bize bir ucgen cize ve ucgenin 3 kosesi vardir, her kosenin koordinatlarini ayri ayri girecegiz*/

/*glVertex(x,y,z); burda x,y,z float tipinde olmali, z(derinlik) simdilik sifir,Burda simdilik bu degerler en fazla 1.0 olurm bu viewport la ilgili bu onumuzdeki derste anlatacagim */
/*glColor3f(red(max1.0),green(max1.0), blue(max1.0)); bu renklendirmek icin*/
glColor3f(1.0, 0.0, 0.0);//birinci noktanin rengi

glVertex3f(-0.5,-0.5,0.0);//birici nokta

glColor3f(0.0, 1.0, 0.0);//ikinci noktanin rengi

glVertex3f(0.5,0.0,0.0);//2. nokta

glColor3f(0.0, 0.0, 1.0);//3. noktanin rengi

glVertex3f(0.0,0.5,0.0);//3. nokta
glEnd();//cizimi bitir
glFlush();//memory yi temizle...
}//cizim fonksyionu bitisi

void main(int argc, char **argv) {/*bu ana fonksyionun pencere is.vb burda int argc,char **argv openglin gonderecegi komutlari almak icin yani kisacasi bunlar yazilmak zorunda, her zaman ayni kalir bunu anlamak icin kendinizi kasmayin */

glutInit(&argc, argv);//burda GLUT motorunu harekete gecirdik
glutInitDisplayMode(GLUT_DEPTH | GLUT_SINGLE | GLUT_RGBA);

/* burda displaymod u ayarladik GLUT_DEPTH(derinlik olacagini soyluyor ama daha isimize yarimiyor zaten z ekseniyle oynasa niz bile bisey degismez :D), GLUT_SINGLE(program tek katmana sahip olacak, genelde animasyon,kaplama vb, de cift katman yani GLUT_DOUBLE olur), GLUT_RGBA (ise renk sinifi gibi bisi, hani rgb fln varya) | isareti ile hepsini birlikte kullanabiliyoruz*/

glutInitWindowPosition(100,100);
/*pencerenin x ve y si nereye gelecek onu belirler yani pozisyon*/
glutInitWindowSize(320,320);//pencere boyutu
glutCreateWindow("Burak Aydin");//pencere basligi
glutDisplayFunc(renderScene);
/*hng fonksiyonun cizim yapacagini belirttik*/
glutMainLoop();
/*programin surekli tekrarlamasi icin, bu olmassa pencere acilip kapanir*/
}

kaynak: www.programlama.com

C# Opengl Kullanımı

OpenGL Nedir ?

OpenGL, en basit anlamıyla grafik donanımına arayüz olan bir yazılımdır. Bu arayüz yüz elli ayrı fonksiyona sahiptir. Bu fonksiyonları kullanarak etkileşimli üç boyutlu (3B, 3D) uygulamalar üretme ihtiyacını giderebilir, nesne tanımlama ve benzeri işlemleri gerçekleştirebiliriz.

OpenGL donanımdan bağımsız birçok farklı donanım düzleminde uygulanabilecek şekilde tasarımlanmıştır. Bu niteliği kazanabilmek için, pencere işlemleri ve kullanıcı girişi işlemlerini yapan komutlar OpenGL’de mevcut değildir. Bunun yerine, pencere işlemleri kullanılan donanımın kontrol edildiği an içerisinde çalıştırılmalıdır. Benzer olarak, OpenGL kütüphanesi üç boyutlu nesneleri modellemede yüksek seviyede fonksiyonlara sahip değildir. Bu tip fonksiyonlarla göreceli olarak karmaşık şekiller, örneğin otomobiller, vücudun bir bölgesi, uçaklar veya moleküller tanımlanabilir. Fakat istenilen model, küçük bir takım geometrik şekillerden hareketle oluşturulabilir-noktalar, çizgiler ve poligonlar gibi-.

OpenGL Komut Dizisi

OpenGL komutları, C#’da, ’gl’ öneki ve baş harfleri büyük olarak yazılan komutu oluşturan diğer kelimelerin birleşiminden oluşmaktadır. Benzer olarak OpenGL’de sabitler ’GL’ ön eki ile başlar ve bütün harfler büyük olacak şekilde kullanılır. Ayrıca ayrı sözcüklerde alt çizgi ile birleştirilir. Aşağıda OpenGL komut örnekleri ve veri tipleri verilmiştir :

Önek Veri Tipi C Dilinde Karşılığı OpenGL Tanımı B 8-bit integer Signed char GLbyte S 8-bit integer Short GLshort İ 32-bit integer Long GLint, GLsize F 32-bit floating-point Float GLfloat, GLclampf D 64-bit dfloating point Double GLdouble, GLclampf Ub 8-bit unsigned integer Unsigned char GLubyte,GL boolean Us 16-bit unsigned integer Unsigned short GLushort Ui 32-bitunsigned integer Unsigned long GLuint, GLenum

OpenGL’de Çizim Yapmak

OpenGL’de çizim yapmak için öncelikle çizim öncesi işlemler gerçekleştirilmelidir. İlk olarak ekran temizlenmeli, ardından çizimin rengi belirlemneli, daha sonra ise geometrik şeklin ne olacağı tanımlanmalıdır.

1. Ekranın Temizlenmesi

’GLClear’ fonksiyonunun parametresi, arka planın hangi işleme göre temizleneceğini belirler. Tipik olarak öncelikle temizleme rengi seçilir, daha sonra temizlenmesi gerekli olan tamponlar temizlenir. ’glclearDepth’ fonksiyonu ise ayarlanacak derinlik tamponundaki her bir pikselin değerini belirler.

Tampon İsmi Renk Tamponu GL_COLOR_BUFFER_BIT Derinlik Tamponu GL_DEPTH_BUFFER_BIT Birikim (Accumulator) Tamponu GL_ACCUM_BUFFER_BIT Kalıp (Stencil) Tamponu GL_STENCIL_BUFFER_BIT

2. Renk Belirleme

Renk belirlemek için ’glColor3f’ isimli fonksiyon kullanılır. Bu komut üç parametre alır, bu parametrelerin hepsi kayan noktalı sayılardır ve 0.0 ve 1.0 aralığındadır. Parametreler, sırasıyla kırmızı, yeşil ve mavi (RGB) renk bileşenlerinden oluşur. Bu üç değeri renkleri karıştırma olarak düşünebiliriz. Örneğin 0.0 değeri o renk bileşeninden hiç kullanılmayacağı, 1.0 değeri ise o renk bileşeninin tamamen baskın kılılacağı anlamına gelmektedir. Örneğin :

glColor3f(1.0f,0.0f,0.0f);

ifadesi en parlak kırmızı renk sistemini çizim rengi olarak atar. Bu ifadede hiç yeşil veya mavi bileşen yoktur. Tüm bileşenleri sıfır atamak siyah renk, 1.0 atamak beyaz renk, 0.5 atamak ise gri renk anlamına gelir. Aşağıda sekiz renk atama ifadesi görülmektedir :

glColor3f(0.0, 0.0, 0.0); //siyah
glColor3f(1.0, 0.0, 0.0); //kırmızı
glColor3f(0.0, 1.0, 0.0); //yeşil
glColor3f(1.0, 1.0, 0.0); //sarı
glColor3f(0.0, 0.0, 1.0); //mavi
glColor3f(1.0, 0.0, 1.0); //magenta
glColor3f(0.0, 1.0, 1.0); //cyan
glColor3f(1.0, 1.0, 1.0); //beyaz

Aşağıda, renk tayfı kartezyen koordinat sisteminde gösterilmiştir :


3. OpenGL’de Geometrik Şeklin Çizimi

Daha önceden de belirttiğimiz gibi OpenGL’de modelleme, basit geometrik şekillerin çizimine dayanır. Şimdi bunun nasıl yapıldığını inceleyelim. Her bir farklı geometrik şekil ya da nesne glBegin() ve glEnd() fonksiyonları arasına yerleştirilir.

- Nokta, Çizgi ve Poligon belirleme :

OpenGL, çizim yapılırken birden çok nokta, çizgi parçası ve çokgen çizdirilebilmesi için kuvvetli ve kullanılması çok basit çizim araçlarına sahiptir. Matemetiksel olarak nokta, çizgi ve poligonun ne anlama geldiğini biliriz, fakat bu tanımlar OpenGL’de tam olarak böyle değildir. Bilgisayar tabanlı hesaplamaların sonlu duyarlı olmaları sebebiyle bir takım yuvarlama hataları oluşur. Çizgiler, noktalar ve poligonların koordinatlarında bu yuvarlama hatalarından kaynaklanan sapmalar olabilir.

- Nokta Belirleme :

Cisimlerin, yüzeylerin ve kenarların belirtebilmesi için köşe noktalarına ihtiyaç duyulur. OpenGL ve bilgisayar grafiklerinde noktanın genişliğinden söz edilebilir ve bunun için glPointSize() fonksiyonu kullanılarak farklı büyüklükte noktalar tanımlanabilir.

- Çizgiler :

OpenGL’de çizgi terimi, matematikte her iki doğrultuda sonsuz uzunlukta doğru olarak ifade edilen terimin aksine, yalnızca sonsuz uzunluktaki çizgi parçası anlamına gelmektedir. Birleşmiş, seri halindeki çizgi parçalarını belirtmenin kolay yolları mevcuttur.


- Poligonlar :

Poligonlar tipik olarak iç kısımlarındaki pikseller ile çizilir. Fakat noktalar kümesi olarak da çizilmeleri mümkündür. OpenGL de poligonların kenarları birbirleri ile kesişmezler. Buna matematikte basit poligon adı verilir. Ayrıca OpenGL poligonları konveks yani dışbükey olmalıdır.


- Dörtgenler :

Dörtgenler grafik uygulamalarında yaygın olarak kullanılır. OpenGL kütüphanesinde içi dolu dörtgen çizmek için kullanılan glRect isimli bir fonksiyon bulunmaktadır. Dörtgen bir poligon gibi de çizilebilir.

- Eğriler :

Herhangi bir eğri, çizgi veya yüzey kısa çizgi parçalarından meydana gelen küçük poligonsal alanlar ile oluşturulabilir. Kısa çizgilerin birleşmesi ile elde edilen şekil eğri gibi görünür.


- Köşe Nktalarının Belirlenmesi :

OpenGL’de tüm geometrik nesneler, köşe noktalarından oluşan bir dizi koordinat ile tanımlanır. Bir köşe noktasının belirlenmesi için ’glVertex’ isimli fonksiyon kullanılır. Bu fonksiyon ’glBegin’ ile ’glEnd’ fonksiyon çağrıları arasında kalan bloğa yerleştirilir.

//fonksiyonun kullanımı : Void glVertex{boyut}{s,i,f,d}[v](koordinatlar); //boyut 2,3,4 olabilir //s : short, i : int, f : float, d : double //v : vektör glVertex2s(2,3); //2 boyutta kullanımı glVertex(0.0,0.0,3.1415) //3 boyutlu kullanımı glVertex3dv(dvect); glVertex3d(doublex,doubley,doublez) glVertex3dv(double[] ) glVertex3f(floatx,floaty,floatz) glVertex3fv(float[]v) glVertex3i(intx,inty,intz) glVertex3iv(int[]v) glVertex3s(shortx,shorty,shortz) glVertex3sv(short[] v)
’glBegin’ fonksiyonun çağrılmasından sonra gelen ifadeler, ne tip geometrik şeklin çizileceğini belirler. Aşağıdaki tabloda ’glBegin’ fonksiyonunda kullanılan on adet veri tipi gösterilmiştir :

Veri Tipi Anlamı GL_POINTS Bağımsız noktalar GL_LINES Bağımsız çizgi parçaları GL_POLYGON Dışbükey poligon GL_TRIANGLES Üçgen GL_QUADS Dört-yüzlü poligonlar GL_LINE_STRIP Çizgi parçaları serisi GL_LINE_LOOP İlk ve son köşeleri ile birbirine bağlı kapalı çizgi parçaları serisi GL_TRIANGLE_STRIP Üçgen serisi GL_TRIANGLE_FAN Üçgen yelpazeleri GL_QUAD_STRIP Dörtgen serisi

Uygulama : OpenGL’de Basit Bir Ev Modeli

Şimdi uygulamaya geçelim. İlk olarak C#’ta oluşturulmuş bir Windows uygulamasının içinde bir form tanımlıyoruz. Görüntümüzü bu form üzerinde göstereceğiz.

OpenGL fonksiyonlarını kullanabilmek için OpenGL kütüphanesini referanslara eklememiz gerekmektedir. ’csgl.dll’ dosyasını referans olarak seçmek için önce Visual Studio .NET penceremizdeki proje penceresindeki referans ekle kısmından csgl.dll dosyasını bilgisayarımızdaki sabit diskte kayıtlı olduğu yerden ekliyoruz ve ’using CsGL.OpenGL’ ifadesini kaynak kod dosyamızın başıne ekleyerek bu kütüphaneyi kullanacağımızı önceden derleyiciye bildiriyoruz. Ayrıca ’csgl.native.dll’ dosyasını C:\WINDOWS\system32 dosyasına kopyalıyoruz. ’csgl.dll’ ve ’csgl.native.dll’ dosyalarını http://csgl.sourceforge.net/ sayfasından indirebilirsiniz.

Önce bir küp sınıfı tanımlıyoruz. Tüm OpenGL komutlarını, OpenGLControl sınıfından türettiğimiz Ourview isimli sınıfın içinde yapıyoruz ve her OpenGL uygulamamızda olması gereken InitGLContext() fonksiyonumuzu, bu türetilmiş sınıfta ezerek (override ederek) içindeki üye fonksiyonların parametrelerini değiştirerek istenen başlangıç koşullandırmalarını yerine getiriyoruz. Çizim işlemleri ise glDraw() fonksiyonu içerisinde tanımlanır. Burada yine glDraw() fonksiyonumuzu, türetilmiş Ourview isimli sınıfımızda ezerek fonksiyona yeni özellikler kazandırıyoruz. Çizime başlamadan önce ekran tamponunu temizliyoruz ve şeklimizi koordinat sisteminde, bize görünebilir olması için glTranslatef() fonksiyonumuz ile z ekseninde -8 birim derine öteliyoruz. Bu fonksiyonun özelliği, bir çizim başlangıç noktası oluşturmasıdır. glRotatef() ile de şeklimizi kendini sürekli yineleyen fonksiyonumuzda (ki biz bu yineleme rutinini form içindeki Main() in içinde belirteceğiz - buna daha sonra değineceğim - ) döndürerek şeklin her bir yinelemede farklı bir tarafını görme şansına sahip oluyoruz. Bu fonksiyonun tam olarak ne işe yaradığını öğrenmek için farklı parametre değerleri girerek deneyip görmek en güzel yöntemdir.

Bildiğimiz gibi, şeklimizi glBegin() ve glEnd() fonksiyonları arasında tanımlıyoruz. Eğer bir dörtgen dizisi belirleyecek isek, bunu bu fonksiyonlar arasında yapmamız gereklidir. Biz uygulamamızda parametre olarak GL_QUADS girerek dörtgen çizeceğimizi belirtiyoruz. Çizeceğimiz geometrik şeklin koordinatlarını belirtmeden önce hangi renkte olması gerektiğini bildirmemiz gereklidir. Renk belirtiminin nasıl olduğuna daha önce değinmiştik.

Modelimiz ev olduğu için, bir küp oluşturmalıyız. Evin çatısı için 4 farklı üçgen belirtmeliyiz. Her bir üçgenin sadece tek bir ortak Vertex’i vardır. Diğer köşe noktalarını evin duvarlarının üst köşelerine konumlandırıyoruz.

Öncelikle ’Küp’ isim uzayımızın kodlarını inceleyelim. Daha sonra form sınıfının kodlarına değineceğiz. Gerekli açıklamaları kodların arasında bulabilirsiniz. Daha detaylı bilgi için, OpenGL kırmızı ve mavi kitaba başvurmanızı öneririm.

using System; using System.Drawing; using CsGL.OpenGL; using System.Windows.Forms; namespace Küp { public class Ourview : OpenGLControl { public bool finished = false; public Ourview() : base() //Kurucu fonksiyonumuz { this.KeyDown += new KeyEventHandler(Ourview_OnKeyDown); } protected void Ourview_OnKeyDown(object Sender, KeyEventArgs kea) { //eğer escape basılırsa uygulama sona erer if(kea.KeyCode==Keys.Q&&kea.Modifiers == Keys.Shift) { Application.Exit(); } } //Köşe noktalarını bir değişkenle ifade ettik çünkü buradan değişitrerek şeklin ne kadar büyük olacağını belirleyebiliriz. private float fEksi = -1.0f; private float fArti = +1.0f; private float fDondur = 0.0f; public override void glDraw() { GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);//Ekranı ve derinlik tamponunu siler GL.glLoadIdentity(); //O anki model matrisini sıfırlar GL.glTranslatef( 0.0f,0.0f,-8.0f );// viewport = 0 0 0 ve böylece derinlik 8 dır. GL.glRotatef( fDondur, 1.0f, 1.0f, 1.0f );//modelimizi fDondur açısıyla yerleştirdiğimiz koordinat etrafında döndürürür GL.glBegin(GL.GL_QUADS); // Geometrik şeklimizin ne olacağı. Burada dörtgen belirttik. //üst yüz GL.glColor3f(1.0f,1.0f,0.0f);//sarı renk GL.glVertex3f( fArti, fArti, fArti); GL.glVertex3f( fArti, fArti, fEksi); GL.glVertex3f( fEksi, fArti, fEksi); GL.glVertex3f( fEksi, fArti, fArti); //alt yüz GL.glColor3f(0.0f,1.0f,1.0f);//cyan renk GL.glVertex3f( fArti, fEksi, fArti); GL.glVertex3f( fArti, fEksi, fEksi); GL.glVertex3f( fEksi, fEksi, fEksi); GL.glVertex3f( fEksi, fEksi, fArti); //arka yüz GL.glColor3f(1.0f,0.0f,0.0f);//kırmızı renk GL.glVertex3f(fArti,fArti,fEksi); GL.glVertex3f(fArti,fEksi,fEksi); GL.glVertex3f(fEksi,fEksi,fEksi); GL.glVertex3f(fEksi,fArti,fEksi); //ön yüz GL.glColor3f(0.0f,0.0f,1.0f);//mavi renk GL.glVertex3f(fArti,fArti,fArti); GL.glVertex3f(fArti,fEksi,fArti); GL.glVertex3f(fEksi,fEksi,fArti); GL.glVertex3f(fEksi,fArti,fArti); //Sağ yüz GL.glColor3f(0.0f,1.0f,0.0f);//yeşil renk GL.glVertex3f(fArti,fArti,fArti); GL.glVertex3f(fArti,fEksi,fArti); GL.glVertex3f(fArti,fEksi,fEksi); GL.glVertex3f(fArti,fArti,fEksi); //sol yüz GL.glColor3f(0.5f,1.0f,0.5f); GL.glVertex3f(fEksi,fEksi,fEksi); GL.glVertex3f(fEksi,fArti,fEksi); GL.glVertex3f(fEksi,fArti,fArti); GL.glVertex3f(fEksi,fEksi,fArti); GL.glEnd(); GL.glBegin(GL.GL_TRIANGLES); //ön yüz için GL.glColor3f(1.0f,0.5f,0.2f); GL.glVertex3f(fArti,fArti,fArti); GL.glVertex3f(fEksi,fArti,fArti); GL.glVertex3f(0.0f,2*fArti,0.0f); //sol yüz için GL.glColor3f(1.0f,0.2f,0.5f); GL.glVertex3f(fEksi,fArti,fArti); GL.glVertex3f(fEksi,fArti,fEksi); GL.glVertex3f(0.0f,2*fArti,0.0f); //sağ yüz için üçgen GL.glColor3f(1.0f,0.25f,0.75f); GL.glVertex3f(fArti,fArti,fEksi); GL.glVertex3f(fArti,fArti,fArti); GL.glVertex3f(0.0f,2*fArti,0.0f); //arka yüz için üçgen GL.glColor3f(1.0f,0.75f,0.75f); GL.glVertex3f(fEksi,fArti,fEksi); GL.glVertex3f(fArti,fArti,fEksi); GL.glVertex3f(0.0f,2*fArti,0.0f); GL.glEnd(); fDondur += 1.25f; // Döndürme açımız } protected override void InitGLContext() { GL.glShadeModel(GL.GL_SMOOTH); // Yumuşak bir gölgelendirme sağlar GL.glClearColor(1.0f, 1.0f, 1.0f, 0.5f); // arka plan rengi GL.glClearDepth(1.0f); // Derinlik Tamponu kurmak için GL.glEnable(GL.GL_DEPTH_TEST); // Derinlik testini etkin kılar GL.glDepthFunc(GL.GL_LEQUAL); // Yapılcak derinlik testinin tipi GL.glHint(GL.GL_PERSPECTIVE_CORRECTION_HINT, GL.GL_NICEST); // Çok iyi perspektif Hesaplamaları için } //Form boyutu değiştiğinde neler yapmamız gerektiği burada verilmiştir. protected override void OnSizeChanged(EventArgs e) { base.OnSizeChanged(e); Size s = Size; GL.glMatrixMode(GL.GL_PROJECTION);//izdüşüm matrisini seçer GL.glLoadIdentity();//model matrisini sıfırlar GL.gluPerspective(45.0f, (double)s.Width /(double) s.Height, 0.1f, 100.0f);//Çerçevenin en boy oranı hesaplanarak GL.glMatrixMode(GL.GL_MODELVIEW);//model matrisini seçer GL.glLoadIdentity();//ve daha sonra model matrisi tekrar sıfırlanır } } }
Windows uygulaması oluşturduğumuz için, çizimimizi ana formumuz içerisinde göstermemiz gerekmektedir. O halde form için bazı koşullamaları gerçeklememiz gerekmektedir. Oluşturduğumuz ’küp’ isim uzayının ’Ourview’ sınıfını form sınıfımızın private değişkeni olarak tanımlamalıyız. Formumuzun kurucu fonksiyonunda da bazı belirtimler yapmalıyız. Örneğin formun tamamında çizimimizi görmek için. Main fonksiyonununda ise yeni bir referans form tanımlıyoruz ve bu formun finished ve IsDisposed değişkenleri ’false’ oldukça devam etmesini sağlıyoruz. Asıl çizim olayını glDraw() fonksiyonunu çağırarak gerçekleştiriyoruz. Ve formun kendisini sürekli tazelemesini istiyoruz. Böylece süreç içinde değişen olayları her yeni tazelemede görebilmekteyiz.

using System; using System.Drawing; using System.Collections; using System.ComponentModel; using System.Windows.Forms; using System.Data; /*Bu çalışma Kocaeli Üniversitesi Elektronik ve Haberleşme Mühendisliğinde İşaret ve Görüntü İşleme Laboratuvarında (KULİS) *OpenGL’de 3-B nesne tanımlama projesi kapsamında Yılmaz Ürgün tarafından yapılmıştır. */ namespace Küp { public class Form1 : System.Windows.Forms.Form { private Küp.Ourview view; private System.ComponentModel.Container components = null; public Form1() { InitializeComponent(); this.view = new Küp.Ourview(); // view sınıfı this.view.Parent = this; this.view.Dock = DockStyle.Fill; // Tüm formu doldurmasını sağlar this.Show(); } protected override void Dispose( bool disposing ) { if( disposing ) { if (components != null) { components.Dispose(); } } base.Dispose( disposing ); } #region Windows Form Designer generated code private void InitializeComponent() { this.AutoScaleBaseSize = new System.Drawing.Size(5, 13); this.ClientSize = new System.Drawing.Size(552, 454); this.Name = "Form1"; this.Text = "OpenGL - KOÜ KULİS 2006"; } #endregion [STAThread] static void Main() { Form1 form = new Form1();// yeni bir form oluşturuyoruz. while((!form.view.finished) && (!form.IsDisposed)) // sonlandırma false ve Dispose false ise devam et. { form.view.glDraw();//Çizimi yapan fonksiyon form.Refresh();//Formu tazele Application.DoEvents(); } form.Dispose(); } } }
Projemizi çalıştırdıktan sonra aşağıdaki ekran çıktısını elde ettik.

kaynak: http://www.csharpnedir.com/makalegoster.asp?MId=661

Opengl Samples - Depth

#include <stdio.h> #include <string.h> #include <stdlib.h> #include <GL/glut.h> #define CI_OFFSET_1 16 #define CI_OFFSET_2 32 GLenum rgb, doubleBuffer; GLenum antiAlias, stipple; GLubyte stippleBits[32*4] = { 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, }; static void Init(void) { GLint i; if (!rgb) { for (i = 0; i < 16; i++) { glutSetColor(i+CI_OFFSET_1, 0.0, 0.0, i/15.0); glutSetColor(i+CI_OFFSET_2, 0.0, i/15.0, 0.0); } } glClearColor(0.0, 0.0, 0.0, 0.0); glClearIndex(0.0); glPolygonStipple(stippleBits); antiAlias = GL_FALSE; stipple = GL_FALSE; } static void Reshape(int width, int height) { glViewport(0, 0, width, height); glMatrixMode(GL_PROJECTION); glLoadIdentity(); glOrtho(-1.0, 1.0, -1.0, 1.0, -0.5, 1000.0); glMatrixMode(GL_MODELVIEW); } static void Key(unsigned char key, int x, int y) { switch (key) { case '1': antiAlias = !antiAlias; glutPostRedisplay(); break; case '2': stipple = !stipple; glutPostRedisplay(); break; case 27: exit(0); } } static void Draw(void) { GLint ci1, ci2; glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); if (antiAlias) { ci1 = CI_OFFSET_1; ci2 = CI_OFFSET_2; glBlendFunc(GL_SRC_ALPHA, GL_ONE); glEnable(GL_BLEND); glEnable(GL_POLYGON_SMOOTH); glDisable(GL_DEPTH_TEST); } else { ci1 = 4; ci2 = 2; glDisable(GL_BLEND); glDisable(GL_POLYGON_SMOOTH); glEnable(GL_DEPTH_TEST); } if (stipple) { glEnable(GL_POLYGON_STIPPLE); } else { glDisable(GL_POLYGON_STIPPLE); } glBegin(GL_TRIANGLES); (rgb) ? glColor3f(0.0, 0.0, 1.0) : glIndexi(ci1); glVertex3f( 0.9, -0.9, -30.0); glVertex3f( 0.9, 0.9, -30.0); glVertex3f(-0.9, 0.0, -30.0); (rgb) ? glColor3f(0.0, 1.0, 0.0) : glIndexi(ci2); glVertex3f(-0.9, -0.9, -40.0); glVertex3f(-0.9, 0.9, -40.0); glVertex3f( 0.9, 0.0, -25.0); glEnd(); if (doubleBuffer) { glutSwapBuffers(); } else { glFlush(); } } static void Args(int argc, char **argv) { GLint i; rgb = GL_TRUE; doubleBuffer = GL_FALSE; for (i = 1; i < argc; i++) { if (strcmp(argv[i], "-ci") == 0) { rgb = GL_FALSE; } else if (strcmp(argv[i], "-rgb") == 0) { rgb = GL_TRUE; } else if (strcmp(argv[i], "-sb") == 0) { doubleBuffer = GL_FALSE; } else if (strcmp(argv[i], "-db") == 0) { doubleBuffer = GL_TRUE; } } } int main(int argc, char **argv) { GLenum type; glutInit(&argc, argv); Args(argc, argv); type = GLUT_DEPTH; type |= (rgb) ? GLUT_RGB : GLUT_INDEX; type |= (doubleBuffer) ? GLUT_DOUBLE : GLUT_SINGLE; glutInitDisplayMode(type); glutInitWindowSize(300, 300); glutCreateWindow("Depth Test"); Init(); glutReshapeFunc(Reshape); glutKeyboardFunc(Key); glutDisplayFunc(Draw); glutMainLoop(); }

Opengl Samples - Copy

#include <stdio.h> #include <string.h> #include <stdlib.h> #include <GL/glut.h> #include "rgb.h" GLenum doubleBuffer; GLint windW = 300, windH = 300; RGBImageRec *image = NULL; float point[3]; float zoom; GLint x, y; static void Init(void) { glClearColor(0.0, 0.0, 0.0, 0.0); x = 0; y = windH; zoom = 1.8; } static void Reshape(int width, int height) { windW = width; windH = height; glViewport(0, 0, windW, windH); glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluOrtho2D(0, windW, 0, windH); glMatrixMode(GL_MODELVIEW); } static void Key(unsigned char key, int x, int y) { switch (key) { case 27: exit(0); } } static void SpecialKey(int key, int x, int y) { switch (key) { case GLUT_KEY_UP: zoom += 0.2; glutPostRedisplay(); break; case GLUT_KEY_DOWN: zoom -= 0.2; if (zoom < 0.2) { zoom = 0.2; } glutPostRedisplay(); break; } } static void Mouse(int button, int state, int mouseX, int mouseY) { if (state == GLUT_DOWN) { x = mouseX; y = mouseY; glutPostRedisplay(); } } static void Draw(void) { glClear(GL_COLOR_BUFFER_BIT); point[0] = (windW / 2) - (image->sizeX / 2); point[1] = (windH / 2) - (image->sizeY / 2); point[2] = 0; glRasterPos3fv(point); glPixelStorei(GL_UNPACK_ALIGNMENT, 1); glPixelZoom(1.0, 1.0); glDrawPixels(image->sizeX, image->sizeY, GL_RGB, GL_UNSIGNED_BYTE, image->data); point[0] = (float)x; point[1] = windH - (float)y; point[2] = 0.0; glRasterPos3fv(point); glPixelZoom(zoom, zoom); glCopyPixels((windW/2)-(image->sizeX/2), (windH/2)-(image->sizeY/2), image->sizeX, image->sizeY, GL_COLOR); if (doubleBuffer) { glutSwapBuffers(); } else { glFlush(); } } static void Args(int argc, char **argv) { GLint i; doubleBuffer = GL_FALSE; for (i = 1; i < argc; i++) { if (strcmp(argv[i], "-sb") == 0) { doubleBuffer = GL_FALSE; } else if (strcmp(argv[i], "-db") == 0) { doubleBuffer = GL_TRUE; } else if (strcmp(argv[i], "-f") == 0) { if (i+1 >= argc || argv[i+1][0] == '-') { printf("-f (No file name).\n"); exit(1); } else { image = rgbImageLoad(argv[++i]); if (image == NULL) { printf("-f (bad file name).\n"); exit(1); } } } } } int main(int argc, char **argv) { GLenum type; glutInit(&argc, argv); Args(argc, argv); if (image == NULL) { printf("No texture file.\n"); exit(1); } type = GLUT_RGB; type |= (doubleBuffer) ? GLUT_DOUBLE : GLUT_SINGLE; glutInitDisplayMode(type); glutInitWindowSize(windW, windH); glutCreateWindow("Copy Test"); Init(); glutReshapeFunc(Reshape); glutKeyboardFunc(Key); glutSpecialFunc(SpecialKey); glutMouseFunc(Mouse); glutDisplayFunc(Draw); glutMainLoop(); }

Opengl Samples - Bitmap

#include <stdio.h> #include <string.h> #include <stdlib.h> #include <GL/glut.h> #define OPENGL_WIDTH 24 #define OPENGL_HEIGHT 13 GLenum rgb, doubleBuffer; float boxA[3] = { 0, 0, 0 }; float boxB[3] = { -100, 0, 0 }; float boxC[3] = { 100, 0, 0 }; float boxD[3] = { 0, 95, 0 }; float boxE[3] = { 0, -105, 0 }; GLubyte OpenGL_bits1[] = { 0x00, 0x03, 0x00, 0x7f, 0xfb, 0xff, 0x7f, 0xfb, 0xff, 0x00, 0x03, 0x00, 0x3e, 0x8f, 0xb7, 0x63, 0xdb, 0xb0, 0x63, 0xdb, 0xb7, 0x63, 0xdb, 0xb6, 0x63, 0x8f, 0xf3, 0x63, 0x00, 0x00, 0x63, 0x00, 0x00, 0x63, 0x00, 0x00, 0x3e, 0x00, 0x00, }; GLubyte OpenGL_bits2[] = { 0x00, 0x00, 0x00, 0xff, 0xff, 0x01, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0xf9, 0xfc, 0x01, 0x8d, 0x0d, 0x00, 0x8d, 0x0d, 0x00, 0x8d, 0x0d, 0x00, 0xcc, 0x0d, 0x00, 0x0c, 0x4c, 0x0a, 0x0c, 0x4c, 0x0e, 0x8c, 0xed, 0x0e, 0xf8, 0x0c, 0x00, }; GLubyte logo_bits[] = { 0x00, 0x66, 0x66, 0xff, 0x66, 0x66, 0x00, 0x00, 0x00, 0xff, 0x3c, 0x3c, 0x00, 0x42, 0x40, 0xff, 0x42, 0x40, 0x00, 0x41, 0x40, 0xff, 0x21, 0x20, 0x00, 0x2f, 0x20, 0xff, 0x20, 0x20, 0x00, 0x10, 0x90, 0xff, 0x10, 0x90, 0x00, 0x0f, 0x10, 0xff, 0x00, 0x00, 0x00, 0x66, 0x66, 0xff, 0x66, 0x66, }; static void Init(void) { if (!rgb) { glutSetColor(0, 0.0, 0.0, 0.0); glutSetColor(1, 1.0, 0.0, 0.0); glutSetColor(2, 0.0, 1.0, 0.0); glutSetColor(3, 1.0, 1.0, 0.0); glutSetColor(4, 0.0, 0.0, 1.0); glutSetColor(5, 1.0, 0.0, 1.0); glutSetColor(6, 0.0, 1.0, 1.0); glutSetColor(7, 1.0, 1.0, 1.0); } glClearColor(0.0, 0.0, 0.0, 0.0); glClearIndex(0.0); } static void Reshape(int width, int height) { glViewport(0, 0, width, height); glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluOrtho2D(-175, 175, -175, 175); glMatrixMode(GL_MODELVIEW); } static void Key(unsigned char key, int x, int y) { switch (key) { case 27: exit(0); } } static void Draw(void) { glClear(GL_COLOR_BUFFER_BIT); glRasterPos3fv(boxA); glPixelStorei(GL_UNPACK_ROW_LENGTH, 24); glPixelStorei(GL_UNPACK_SKIP_PIXELS, 8); glPixelStorei(GL_UNPACK_SKIP_ROWS, 2); glPixelStorei(GL_UNPACK_LSB_FIRST, GL_FALSE); glPixelStorei(GL_UNPACK_ALIGNMENT, 1); glBitmap(16, 12, 8.0, 0.0, 0.0, 0.0, logo_bits); glPixelStorei(GL_UNPACK_ROW_LENGTH, 0); glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0); glPixelStorei(GL_UNPACK_SKIP_ROWS, 0); glPixelStorei(GL_UNPACK_LSB_FIRST, GL_TRUE); glPixelStorei(GL_UNPACK_ALIGNMENT, 1); (rgb) ? glColor3f(1.0, 1.0, 1.0) : glIndexi(7); glRasterPos3fv(boxB); glBitmap(OPENGL_WIDTH, OPENGL_HEIGHT, OPENGL_WIDTH, 0.0, OPENGL_WIDTH, 0.0, OpenGL_bits1); glBitmap(OPENGL_WIDTH, OPENGL_HEIGHT, OPENGL_WIDTH, 0.0, OPENGL_WIDTH, 0.0, OpenGL_bits2); (rgb) ? glColor3f(0.0, 1.0, 1.0) : glIndexi(6); glRasterPos3fv(boxC); glBitmap(OPENGL_WIDTH, OPENGL_HEIGHT, OPENGL_WIDTH, 0.0, OPENGL_WIDTH, 0.0, OpenGL_bits1); glBitmap(OPENGL_WIDTH, OPENGL_HEIGHT, OPENGL_WIDTH, 0.0, OPENGL_WIDTH, 0.0, OpenGL_bits2); (rgb) ? glColor3f(1.0, 0.0, 1.0) : glIndexi(5); glRasterPos3fv(boxD); glBitmap(OPENGL_WIDTH, OPENGL_HEIGHT, OPENGL_WIDTH, 0.0, OPENGL_WIDTH, 0.0, OpenGL_bits1); glBitmap(OPENGL_WIDTH, OPENGL_HEIGHT, OPENGL_WIDTH, 0.0, OPENGL_WIDTH, 0.0, OpenGL_bits2); (rgb) ? glColor3f(1.0, 1.0, 0.0) : glIndexi(3); glRasterPos3fv(boxE); glBitmap(OPENGL_WIDTH, OPENGL_HEIGHT, OPENGL_WIDTH, 0.0, OPENGL_WIDTH, 0.0, OpenGL_bits1); glBitmap(OPENGL_WIDTH, OPENGL_HEIGHT, OPENGL_WIDTH, 0.0, OPENGL_WIDTH, 0.0, OpenGL_bits2); if (doubleBuffer) { glutSwapBuffers(); } else { glFlush(); } } static void Args(int argc, char **argv) { GLint i; rgb = GL_TRUE; doubleBuffer = GL_FALSE; for (i = 1; i < argc; i++) { if (strcmp(argv[i], "-ci") == 0) { rgb = GL_FALSE; } else if (strcmp(argv[i], "-rgb") == 0) { rgb = GL_TRUE; } else if (strcmp(argv[i], "-sb") == 0) { doubleBuffer = GL_FALSE; } else if (strcmp(argv[i], "-db") == 0) { doubleBuffer = GL_TRUE; } } } int main(int argc, char **argv) { GLenum type; glutInit(&argc, argv); Args(argc, argv); type = (rgb) ? GLUT_RGB : GLUT_INDEX; type |= (doubleBuffer) ? GLUT_DOUBLE : GLUT_SINGLE; glutInitDisplayMode(type); glutInitWindowSize(300, 300); glutCreateWindow("Bitmap Test"); Init(); glutReshapeFunc(Reshape); glutKeyboardFunc(Key); glutDisplayFunc(Draw); glutMainLoop(); }

Opengl Samples - Accum

#include <stdio.h> #include <stdlib.h> #include <string.h> #include <GL/glut.h> GLenum doubleBuffer; GLint thing1, thing2; static void Init(void) { glClearColor(0.0, 0.0, 0.0, 0.0); glClearAccum(0.0, 0.0, 0.0, 0.0); thing1 = glGenLists(1); glNewList(thing1, GL_COMPILE); glColor3f(1.0, 0.0, 0.0); glRectf(-1.0, -1.0, 1.0, 0.0); glEndList(); thing2 = glGenLists(1); glNewList(thing2, GL_COMPILE); glColor3f(0.0, 1.0, 0.0); glRectf(0.0, -1.0, 1.0, 1.0); glEndList(); } static void Reshape(int width, int height) { glViewport(0, 0, width, height); glMatrixMode(GL_PROJECTION); glLoadIdentity(); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); } static void Key(unsigned char key, int x, int y) { switch (key) { case '1': glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); glutPostRedisplay(); break; case '2': glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); glutPostRedisplay(); break; case 27: exit(0); } } static void Draw(void) { glPushMatrix(); glScalef(0.8, 0.8, 1.0); glClear(GL_COLOR_BUFFER_BIT); glCallList(thing1); glAccum(GL_LOAD, 0.5); glClear(GL_COLOR_BUFFER_BIT); glCallList(thing2); glAccum(GL_ACCUM, 0.5); glAccum(GL_RETURN, 1.0); glPopMatrix(); if (doubleBuffer) { glutSwapBuffers(); } else { glFlush(); } } static void Args(int argc, char **argv) { GLint i; doubleBuffer = GL_FALSE; for (i = 1; i < argc; i++) { if (strcmp(argv[i], "-sb") == 0) { doubleBuffer = GL_FALSE; } else if (strcmp(argv[i], "-db") == 0) { doubleBuffer = GL_TRUE; } } } int main(int argc, char **argv) { GLenum type; glutInit(&argc, argv); Args(argc, argv); type = GLUT_RGB | GLUT_ACCUM; type |= (doubleBuffer) ? GLUT_DOUBLE : GLUT_SINGLE; glutInitDisplayMode(type); glutInitWindowSize(300, 300); glutCreateWindow("Accum Test"); Init(); glutReshapeFunc(Reshape); glutKeyboardFunc(Key); glutDisplayFunc(Draw); glutMainLoop(); }