Oyun Programlama ve Oyun Grafikleri

Visual C++ 2008 ve Allegro Kurulumu

2008-09-02T16:40:00.000-07:00

Bilgisayarınızda visual studio yoksa bu yeni sürümleri öneririm. Kotasına güvenen indirsin :)

Önce "Visual c++ 2008 Express ve Allegro kütüphane" download linklerini vereyim:

     *Net Framework 3.5 gerekli
http://www.microsoft.com/downloads/details.aspx?FamilyId=AB99342F-5D1A-413D-8319-81DA479AB0D7&displaylang=en

     *Ve de Windows SDK (Burada altta PSDK-x86.exe i seçbilirsiniz (32bit için))
http://www.microsoft.com/downloads/details.aspx?FamilyId=A55B6B43-E24F-4EA3-A93E-40C0EC4F68E5&displaylang=en#top

     *Visual C++ Express Edition 2008
http://www.microsoft.com/express/download/#webInstall

     *Allegro Kütüphanesi
http://wiki.allegro.cc/Visual_C%2B%2B_Express_2008

Bunları kurduktan sonra isterseniz kendimiz için şablon bir allegro programı yazalım.

Masaüstüne "GameProject" isimli bir klasör açın ve indirdiğiniz allegro (.zip) dosyasını "GameProject" klasörüne çıkartın. Daha sonra;

Visual c++ i açın "Yeni Proje->Empty Project" i seçin. "Project->Options" bölümünden "C++->General" sekmesinden  şu ayarları yapın: 

(değerleri verirken tırnak işaretlerini mutlaka yazın!)

*Additional Include Directory Files = "$(ProjectDir)\include"

"Linker->General" Bölümüne de:

*Additional Library Directories = "$(ProjectDir)\lib"

"Linker->Input" kısmına da:

*Additional Dependencies = alleg.lib

Ayarları yaptık şimdi kodlara geçelim.

Solda Bulunan Solution Explorer a sağ tıkayın Header Files e New Item diyerek
Dialog'tan .h (Header) filesi seçin adını "Game" verin, aşağıdaki kodları ekleyin


#ifndef GAME_H
#define GAME_H

#include 

/* --------------------------- TEMPLATE --------------------------- */
#define $START_MAIN_PROGRAM int main(){
#define $END_MAIN_PROGRAM   return 0;}END_OF_MAIN();
/* --------------------------- TEMPLATE --------------------------- */

class Game
{
public:
 virtual void Initialize(void);
 virtual void DestroyGame(void);
 virtual void Update(void);

 void run(void);

private:
 BITMAP *buffer;
};

#endif


Daha sonra Source Files e tıklayıp (.c Source Files) "Game" seçin ve oluşturulan Game.cpp dosyasına şu kodları ekelyin


#include "Game.h"

void Game::Initialize(void)
{
 allegro_init();
 install_keyboard();
 install_mouse();

 set_window_title("Game");

 set_color_depth(desktop_color_depth());
 set_gfx_mode(GFX_AUTODETECT_WINDOWED, 640, 480, 0, 0);

 buffer = create_bitmap(640, 480);
}

void Game::DestroyGame(void)
{
 destroy_bitmap(buffer);
 allegro_exit();
}

void Game::Update(void)
{
 draw_sprite(screen, buffer, 0, 0);
 /* UPDATE GAME CODE */
}

void Game::run(void)
{
 while(!key[KEY_ESC])
 {
  Update();
 }
}


ve birde main.cpp ekliyoruz. Bunlarda son kodlarımız. Projeyi kaydetmeyi unutmayın. Artık masaüstüne açtığınız "GameProject" isimli klasörü zipleyip her zaman kullanmak için saklayabilirsiniz.

main.cpp:


#include "Game.h"

$START_MAIN_PROGRAM

 Game game;

 game.Initialize();

 game.run();

 game.DestroyGame();

$END_MAIN_PROGRAM

Allegro'da Sprite oluşturalım !

2008-08-18T04:41:00.000-07:00

Önce masaüstünde bir klasör açın ve adını "Allegro Sprite Denemsi" olarak değiştirin.
Sonra DEV C++ editörünü açın, "Yeni Proje" diyerek "Multimedia" bölümünden "Allegro"
yu seçin, masaüstüne açtığınız klasörün içine kaydedin. Son olarak aşığdaki kodları ekleyerek programınızı "Run" komutu ile çalıştırın.

sprite.h dosyası
------------------------------------------------------------------------------------
#ifndef sprite_H_INCLUDED
#define sprite_H_INCLUDED

#include <allegro.h>

enum Yon { _LEFT = 0, _RIGHT = 1, _DOWN = 2, _UP = 3 };

class Sprite
{
      public:
             BITMAP *_image;
             int _x;
             int _y;
             Sprite();
             ~Sprite();
             void Draw(BITMAP*);
             void Move(int,int);
};

#endif

sprite.c dosyası
------------------------------------------------------------------------------------
#include "sprite.h"

Sprite::Sprite()
{
                _image = NULL;
                _x = 0;
                _y = 0;
}

Sprite::~Sprite()
{
                 if(_image != NULL)
                 {
                           destroy_bitmap(_image);
                 }
}

void Sprite::Draw(BITMAP *__buffer)
{
     if(_image != NULL)
     {
         acquire_screen();
         clear_bitmap(__buffer);
         draw_sprite(__buffer, _image, _x, _y);
         release_screen();
     }
}

void Sprite::Move(int yon, int speed)
{
    switch(yon)
    {
        case (int)_LEFT: _x-=speed; break;           
        case (int)_RIGHT: _x+=speed; break;
        case (int)_UP: _y-=speed; break;
        case (int)_DOWN: _y+=speed; break;
    }     
}

main.cpp dosyası
------------------------------------------------------------------------------------
#include <allegro.h>
#include "sprite.h"

BITMAP *buffer;
BITMAP *scr;

void init();
void deinit();

int main() {
 init();

    Sprite *spr;
    spr->_image = scr;
    spr->_x = 100;
    spr->_y = 100;
    
 while (!key[KEY_ESC]) {
  /* put your code here */
  draw_sprite(screen, buffer, 0, 0);
        
  spr->Draw(buffer);
  
  if(key[KEY_LEFT]) spr->Move(0, 2);
  if(key[KEY_RIGHT]) spr->Move(1, 2);
  if(key[KEY_DOWN]) spr->Move(2, 2);
  if(key[KEY_UP]) spr->Move(3, 2);  
 }

 deinit();
 return 0;
}
END_OF_MAIN()

void init() {
 int depth, res;
 allegro_init();
 depth = desktop_color_depth();
 if (depth == 0) depth = 32;
 set_color_depth(depth);
 res = set_gfx_mode(GFX_AUTODETECT_WINDOWED, 640, 480, 0, 0);
 if (res != 0) {
  allegro_message(allegro_error);
  exit(-1);
 }

 install_timer();
 install_keyboard();
 install_mouse();
 /* add other initializations here */
 buffer = create_bitmap(640,480);
 scr = load_bitmap("picture.bmp", 0);
}

void deinit() {
 clear_keybuf();
 /* add other deinitializations here */
}

C++ ile yeni bir Allegro denemesi

2008-08-16T08:49:00.000-07:00

Allegro ve c++ ikilisi oyun programlama da ne kadar yeterli bilemem fakat bana çok zevkli gelmeye başladı. İşte size yeni bir örnek daha:

/* ========================================================================== */
#include <allegro.h>
/* ========================================================================== */
#define BCK_CLR 0
#define MAX_X (SCREEN_W-294)
#define MIN_X 0
/* ========================================================================== */
BITMAP *buffer;
BITMAP *bmp;
BITMAP *crs;
int _x = 0, _y = 80, speed = 2;
/* ========================================================================== */
void ShowGosteri()
{
     textout_ex(buffer, font, "C++ ile Allegro Denemesi",
                 SCREEN_W/2-150, 10, makecol(0,100,255), BCK_CLR);
     draw_sprite(buffer, bmp, _x, _y);
     draw_sprite(buffer, bmp, _x*-1+(SCREEN_W-294), _y+175);
     
     textout_ex(buffer, font, "Cikis icin [ESC] tusuna basin!",
                 SCREEN_W/2-150, SCREEN_H/2+200, makecol(0,100,255), BCK_CLR);
}
/* ========================================================================== */
void main()
{
     allegro_init(); //initialize
     install_keyboard(); //install keyset
     install_mouse(); //mouse install
     
     set_window_title("Allegro"); //window title
     set_color_depth(desktop_color_depth()); //color depth
     set_gfx_mode(GFX_AUTODETECT_FULLSCREEN, 800, 600, 0, 0); //screen mode
     
     buffer = create_bitmap(SCREEN_W, SCREEN_H); //buffer create
     bmp = load_bitmap("./bmp.bmp", 0);
     crs = load_bitmap("./cursor.bmp", 0);

     set_mouse_sprite(crs);
     
     while(!key[KEY_ESC])
     {
         show_mouse(buffer);
         _x+=speed;
         
         if(_x >= MAX_X)
         {
               speed*=-1;
         } else 
         if(_x <= MIN_X)
         {
               speed*=-1;
         }
         
         draw_sprite(screen, buffer, 0, 0);
         clear_to_color(buffer, BCK_CLR);
         ShowGosteri();
     }
     
     allegro_exit();
     
} END_OF_MAIN();
/* ========================================================================== */

Allegroyu biraz kolaylaştıralım !

2008-08-14T10:17:00.000-07:00

C++ ile Allegro programlarken, programa giriş noktası yani main() fonksiyonunun hemen başında, ilk satırlarında basit ama uğraştıran, birtakım kodlar yazmak zorundayız. Gerçi gerek yok ama sadece kolaylık olması için bu işleri yapan bir sınıf oluşturabilirz. Hem c++ için pratik yapmış oluruz. 

Kodlara gelince:

//İşimizi görecek olan sınıf
settings.h dosyası :

/* Allegro yardımcı sınıf (beta) */
#include <allegro.h>

enum __DEPTH { x8, x15, x16, x24, x32 };
enum __GFX { WINDOWED = 0, FULLSCREEN = 1, ISNULL = 2 };

/* interface */
class Settings
{
    BITMAP *buffer;
    public:
        enum __GFX gfx_mode;  
        enum __DEPTH color_depth;
        bool _install_keyboard;
        bool _install_mouse;
        bool _show_mouse;
        bool buffer_install;
        int buffer_w, buffer_h;
        BITMAP *__mouse;
        const char* window_title;
              
        Settings();
        ~Settings();         
        void install();               
};

Settings::Settings()
{
    gfx_mode = WINDOWED;
    color_depth = x16;
    _install_keyboard = true;
    _install_mouse = true;
    buffer_install = true;
    __mouse = NULL;
    _show_mouse = true;
    buffer_w = 800;
    buffer_h = 600;
    window_title = "Allegro Game";
}

Settings::~Settings()
{
    /* dispose */                    
}

void Settings::install()
{
    allegro_init();  
    
    if(buffer_install == true)
    {
         buffer = create_bitmap(buffer_w, buffer_h);
    }
    
    switch(color_depth)
    {
        case x8: set_color_depth(8); break;
        case x15: set_color_depth(15); break;
        case x16: set_color_depth(16); break;
        case x24: set_color_depth(24); break;
        case x32: set_color_depth(32); break;
    }
    
    switch(gfx_mode)
    {
         case WINDOWED: set_gfx_mode(GFX_AUTODETECT_WINDOWED, buffer_w, buffer_h, 0, 0); break;               
         case FULLSCREEN: set_gfx_mode(GFX_AUTODETECT_FULLSCREEN, buffer_w, buffer_h, 0, 0); break;
         case ISNULL: set_gfx_mode(GFX_AUTODETECT, buffer_w, buffer_h, 0, 0); break;
    }
    
        if(_install_keyboard == true)
        {
            install_keyboard();
        }  
            if(_install_mouse == true)
            {
                install_mouse();
            }
                if(_show_mouse == true)
                {
                    show_mouse(__mouse);
                }
        
        set_window_title(window_title);
}

//Ana program kodlarımız
ve main.cs:

#include <stdlib.h>
#include <allegro.h>
#include "settings.h"

Settings gSettings;

void InstallAllegro() {
    gSettings.color_depth = x32;
    gSettings.window_title = "Allegro Denemesi";
    gSettings._show_mouse = false;
    gSettings.buffer_w = 320;
    gSettings.buffer_h = 240;
    gSettings.install();
}

int main()
{
    //Ne kadar kısa demi :)
    InstallAllegro();
    
    while(!key[KEY_ESC]);
    
    allegro_exit();
    return 0;
} END_OF_MAIN();

C++ ve Allegro İle Oyun Programlama

2008-08-12T05:34:00.000-07:00

Şimdilik allegro ile pencere oluşturup beyaz renkte bir çizgi çizmeyi göstereceğim.
Ben öğrendikçe de sizlerle paylaşacağım ...

#include <stdlib.h>
#include <allegro.h> //Allegro kütüphanesi

int main(void)
{    
    allegro_init();        //Allegro Hazırlanıyor ...
    install_keyboard();    //Klavye Yükleniyor ...
    install_mouse();       //Fare Yükleniyor ...
    show_mouse(NULL);      //Fare Aktif Hale getiriliyor ...
    
    //Grafik modeu Ayarlanıyor ...
    //FULLSCREEN yazan kısımı WINDOWED olarak değiştiriseniz
    //program pencerede çalışır.
    int ret = set_gfx_mode(GFX_AUTODETECT_FULLSCREEN, 800, 600, 0, 0); 
    
    //Grafik modu uygulanamıyorsa hata mesajı göster ...
    if(ret != 0)
    {
           allegro_message(allegro_error);
           return 1;
    }
    
    //ESC tuşuna basılmadığı sürece yapılacak işlemler
    while(!key[KEY_ESC])
    {
        //Çizgi çiziliyor x1=0, x2=0, y1=0, y2=0
        //makecol(r, g, b) -> bu kod renk üretir.
        line(screen, 0, 0, 150, 150, makecol(255, 255, 255));
    }
    
    //ESC ye basıldıktan sonra döngü sona erdiğinde allegro dan çık ...
    allegro_exit();
    return 0;
} END_OF_MAIN();

Örnek Flash Oyunum

2008-07-22T09:02:00.000-07:00

Sonunda basit de olsa 2D bir oyun yaptık... Flash sayesinde :)

Flash Çalışmasını indirmek için tıklayın (.fla)



Ne kadar basit bir oyun olsa da geliştirlmeye açık. Mesela siz tahmine göre "yukarı"-
"aşağı" şeklinde animasyonlarla sayıyı buldurmaya çalışabilirsiniz ...

Flash'ta preloading yapımı

2008-07-13T04:01:00.000-07:00

Flash'ta geliştirdiğiniz oyunlarda çok işinize yarayacak bir uygulama yapacağız.
Oyun yüklenmeden önce kullanıcıya ön yükleme ekranı göstermelisiniz ki sıkılıp kapatmasın ve bilgilensin.

1. Şimdi Flash'ta bir proje açın, adını "preloading uygulaması" olarak değiştirin.
2. Sonra "Insert - New Symbol - Movie Clip" yapın ve bir dikdörtgen çizin, kenarlıkları kalın ve iç dolgu rengi olmasın.
3. Sonra "Insert - New Symbol - Graphics" yapın ve oluşturduğunuz movie clip in içine atın. Uzunluğunu sıfırlayın (W:0) ve "Instance Name" ini "lbarPos" olarak değiştirin.
4. Movie clipin içine bir de "Dynamic Text" olarak "LOADING 0%" yazın.
Instance Name ini "loadingText" olarak değiştirin.

Son olarak görüntü aşağıdaki gibi olmalı.



Şimdi Movie Clibi ana sahneye taşıyın ve adını(Instance Name) "loadingBar" olarak değiştirin. Bu birinci kare idi. İkinci kareye de bir kaç resim import ederek yerleştirin.

Sonra birinci kareye tıklayıp Actions kısmına şu kodları ekleyin.

5. Kodlar :

stop(); //Animasyonu durduruyoruz.

onEnterFrame = function()
{
 yuklenen = _root.getBytesLoaded(); //swf dosyamızın yüklenmiş byte miktarı
 toplam = _root.getBytesTotal(); //swf dosyamızın toplam byte miktarı
 max = 226; //önyükleme movie clibimizin içindeki lbarPos isimli graphics
                   //nesnesinin maksimum uzunluğu
 
 oran = yuklenen / toplam * 100; //Yükleme oranı % cinsinden
 oran2 = max * oran / 100; //Yükleme oranının maximum uzunlukla oranı
 
        //ana sahnedeki loadingBar nesnemizin içindeki loadingText isimli dynamic
        //text nesnesine yükleme oranını yazdırıyoruz.
 loadingBar.loadingText.text = "LOADING "+ Math.round(oran)+"%";
        //ve uzunluğu artırarak loading efektini veriyoruz
 loadingBar.lbarPos._width = Math.round(oran2);
 
        //Eğer yükleme tamamlandıysa ikinci kareye (resimlerin bulunduğu yere) geç.
 if(yuklenen == toplam) gotoAndStop(2);
}


Ve son olarak CTRL+Enter yapıp animasyonu test edin ve bu penceredeki menuden simulate download seçin böylece animasyonu internette yükleniyormuş gibi görürsünüz.
preloading, flash loading screen, flash loading scene, flash oyun programlama, flash ön yükleme ekranı, flash progressbar

Flash'ta Oyun programlama - Pdf Dökümanları

2008-06-25T10:46:00.000-07:00



Sanırım 2D Oyunların en iyileri flash'ta geliştiriliyor. Animasyonları ve grafikleri siz hazırlıyorsunuz. Gerisini Action Script tamamlıyor. Tabi bu kadar da kolay değil,
fizik hesaplamaları buradada canımızı sıkabiliyor ...

İşte sizin için internetten araştırıp bulduğum 2 süper pdf dökümanı:

1.Dosya (.pdf)
2.Dosya (.pdf)

XNA ile Healt Bar yapımı

2008-06-05T06:56:00.000-07:00



Genelde aksiyon oyunlarında gördüğümüz bu healt(can,sağlık nyse..) bar yine iki parçalı bir resmin belirli kısımlarının gösterilmesi ile yapılıyor. Bu da source(kaynak) rectangle ile sağlanıyor. Şimdi kodları görelim...

//İlk önce işimizi kolaylaştırmak için bir Sprite sınıfı yazıyoruz.

using System;
using System.Collections.Generic;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Storage;

namespace Deneme1
{
    class Sprite
    {
        public Texture2D spriteTexture;
        public Vector2 spritePosition = new Vector2(0, 0);

        public Sprite() { }

        public void LoadContent(ContentManager theContentManager, string assetName)
        {
            spriteTexture = theContentManager.Load<Texture2D>(assetName);
        }

        public void Draw(SpriteBatch theSpriteBatch)
        {
            theSpriteBatch.Draw(spriteTexture, spritePosition, Color.White);
        }
    }
}


Şimdi Oyun kodlarına geçelim.

using System;
using System.Collections.Generic;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Audio;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.GamerServices;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Net;
using Microsoft.Xna.Framework.Storage;

namespace Deneme1
{
    public class Game1 : Microsoft.Xna.Framework.Game
    {
        GraphicsDeviceManager graphics;
        SpriteBatch spriteBatch;

        private Sprite sprite = null; //kendi yazdığımız sprite sınıfı
        private int currentHealt = 100; //Normaldeki sağlık(:can:) oranı

        public Game1()
        {
            graphics = new GraphicsDeviceManager(this);
            Content.RootDirectory = "Content";
            
            sprite = new Sprite(); 
        }

        protected override void Initialize()
        {
            // TODO: Add your initialization logic here

            base.Initialize();
        }

        protected override void LoadContent()
        {
            // Create a new SpriteBatch, which can be used to draw textures.
            spriteBatch = new SpriteBatch(GraphicsDevice);

            //Sprite texture(resmi) yükleniyor
            sprite.LoadContent(Content, "healt");
        }

        protected override void UnloadContent()
        {
            // TODO: Unload any non ContentManager content here
        }

        protected override void Update(GameTime gameTime)
        {
            // Allows the game to exit
            if (GamePad.GetState(PlayerIndex.One).Buttons.Back ==ButtonState.Pressed)
                this.Exit();

            //Bir KeyboardState (Klavye yöneticisi) ile yukarı ve aşağı
            //yön tuşlarına basıldığında canı azaltıp çaoğaltacağız
            KeyboardState keyState = Keyboard.GetState();

            if (keyState.IsKeyDown(Keys.Up)) currentHealt++;
            if (keyState.IsKeyDown(Keys.Down)) currentHealt--;

            currentHealt = (int)MathHelper.Clamp(currentHealt, 0, 100);

            base.Update(gameTime);
        }

        /// <summary>
        /// This is called when the game should draw itself.
        /// </summary>
        /// <param name="gameTime">Provides a snapshot of timing values.</param>
        protected override void Draw(GameTime gameTime)
        {
            graphics.GraphicsDevice.Clear(Color.CornflowerBlue);

            // TODO: Add your drawing code here
            spriteBatch.Begin();

            //Healt barın gri renkli kısmını render et...
            spriteBatch.Draw(sprite.spriteTexture, new Rectangle(
              this.Window.ClientBounds.Width / 2 - sprite.spriteTexture.Width / 2,
              10, sprite.spriteTexture.Width, 60),
              new Rectangle(0, 0, sprite.spriteTexture.Width-3, 60),
            Color.White);
            //Healt barın kırmızı renkli kısmını render et...
            spriteBatch.Draw(sprite.spriteTexture, new Rectangle(
              (this.Window.ClientBounds.Width / 2 - sprite.spriteTexture.Width / 2)+7,
              16, (int)(sprite.spriteTexture.Width * ((double)currentHealt / 100))-13, 45),
              new Rectangle(0, 70, sprite.spriteTexture.Width-3, 45),
            Color.Red);

            spriteBatch.End();

            base.Draw(gameTime);
        }
    }
}




buradan resmi kopyalayın ve XNA Game Studio'da yeni bir Proje açın Content Manager ile resmi yükleyin ve kodları deneyin. Bu küçük bir uygulama fakat yararlı da...
"KOŞMADAN ÖNCE YÜRÜMEYİ ÖĞRENMEK GEREK" :: (:Tom millerin oyun prog. kitabından:)

yazar: CANER DEMİRCİ ((gerisi de var inşallah...))

XNA'da Texture Yüklemek ve Render Etmek

2008-06-02T12:17:00.000-07:00

Visual Studio açın ve bir XNA Game Studio projesi yaratın. Solution Sekmesindeki
ağaç yapıda "Content" e sağ tıklayıp projenize bir resim dosyası ekleyin.
(Benim tercihim .png formatı) ve daha sonra "Properties" sekmesinde bu dosyanın özelliklerinden "Asset Name" i "deneme" olarak değiştirin. Böylece Xna Game Studio bu 
resim dosyasını .XNB formatına dönüştürecek.

ve sıra kodlarda :

//İlk olarak yükleyeceğimiz resmi ekranda göstermek için
//bir SpriteBatch tanımlıyoruz ...
private SpriteBatch spriteBatch;

//Sonra Texture2D sınıfından texturemizi tanımlıyoruz
private Texture2D myTexture;

//Texturemizin ekrandaki Pozisyonu (Vector2 sınıfı ile)
private Vector2 Position;

//Texturemizin ne kadar Scale edileceği (yani büyültüp küçültme oranı)
// 1 verildiğinde eni ile boyunu 1 ile çarpar yani uzunluğu ve genişliğinde
// bir değişme olmaz
private float Scale; 

//Origin değeri yani merkez noktası
private Vector2 Origin;

//Şimdide Rotation yani döndürme açısı (orjine e göre)
private float Rotation;

//Texturemizin ekstra rengi yani White = Beyaz verilirse renk değişmez
private Color color;

//Texturemizin SourceRectangle değeri yani resmin tam olarak texturenin ne kadar
//bir kısmının gösterileceğini belirle
//Source Rectangle => X, Y, Width, Height değerlerini alır.
//X, Y den başlayark Width ve Height değerleri boyunca devam eder
private Rectangle Source;

//Yüklediğimiz resmin asset name i
private string AssetName = "deneme";


Nesnelerimizi tanımladık şimdi yapacağımız işlemler:
1-Initialize() -> Oyun hazırlanırken ilk değerlerimizi veriyoruz
2-LoadContent() -> bu metod ile texture nesnemizi yükleyeceğiz
3-Draw() -> bu metod ile texture nesnemizi yani resmimizi ekranda göstereceğiz

protected override void Initialize()
{
  this.Scale = 1.0f;
  this.Position = new Vector2(100, 100);
  this.Origin = Vector2.Zero;
  this.color = Color.White;
  this.Rotation = 0f;  

  base.Initialize();
}

protected override void LoadContent()
{
  spriteBatch = new SpriteBatch(GraphicsDevice);
  myTexture = Content.Load(AssetName);
  
  //Bu değeri Initialize metodunda veremedik çünkü texture uzunluk ve yükseklik
  //değerini yüklenen resim den alacağımız için ve resim LoadContent() metodunda
  //yüklendiği için şimdi veriyoruz.
  this.Source = new Rectangle(0, 0, this.myTexture.Width, this.myTexture.Height);
}

protected override void Draw()
{
  graphics.GraphicsDevice.Clear(Color.CornflowerBlue);

  //SpriteBatch nesnemizin render işlemine start veriyoruz
  spriteBatch.Begin();

  //Ve Texture render ediliyor.
  spriteBatch.Draw(myTexture, this.Position, this.Source, this.Color, this.Rotation,
    this.Origin, this.Scale, SpriteEffects.None, 0);

  //SpriteBatch nesnemizin render işlemine son veriyoruz
  spriteBatch.End();
}



kodların hepsini vermedim sadece gerekli blokları yazdım. Çünkü böylesi sizin için daha iyi XNA Game Studio'u açtığınızda karşınıza hazır kodlar gelecektir. Bütün kodu yümüyle kopyalayıp yazmak öğrenme açısından iyi değildir. Kodları yerine kendiniz ilk önceleri bakarak yazın ve "RUn" komutunu verip çalıştırın. Böylece kodu deneyip ne yapabildiğinizi görürsünüz. Zaten sonraları da değiştirmek ve geliştirmek isteyeceksiniz bu arada da belki yüzlerce hata mesajı alacaksınız ama sonunda anlayarak, deneyerek, görerek öğrenmiş olacaksınız.

yazar: Caner DEMİRCİ  (( devamı gelecek ... ))

Visual C++ ile Görsel Programlama

2008-05-06T12:15:00.000-07:00

NEDEN C++ ?

Bu soruya çok basit ve net bir cevap verebiliriz. çünkü Windows C++ ile yazıldı. bu durumda C++ ile yazdığınız uygulamalarda windows bileşenlerine tam erişim imkanınız olacaktır. 

Tabii birileri çıkıp size Visual Basic ile de herşeyi yaparsınız diyebilir yada Visual C++ ile birlikte MFC Application wizard kullanın işiniz kolaylaşacaktır diye nasihat edebilir. sakın dinlemeyin ( siz önce temelini öğrenin) MFC de microsoft tarafından kolay uygulama hazırlamak için geliştirilmiş bir sistemdir. kendi içersinde birçok hazır fonksiyon ile kullanımı kolaylaştırır. ama onunla uğraşmaktansa Visual Basic yada daha iyisi Delphi ile uğraşmayı tercih edebilirsiniz. çünkü MFC ile hazırlanan EXE dosyası windows98de bile tam uyumlu çalışmayacaktır ve sizden mfc40.dll isimli bir dosya isteyecektir. Ama sizin amacınız C++ ile oyun yazmak olduğuna göre hepsini unutun. Bugüne kadar öğrendiğiniz birçok kolaylaştırılmış fonksiyonu unutun. Resim çizer gibi form çizmeyi unutun ( Buna daha sonra değineceğiz, aslında Visual C++ ile de çok basit şekilde form çiziliyor ama MFC ile değil)

Tüm bunların yerine önce işin temelini öğreneceğiz. tabii Visual Basic yada Delphi biliyorsanız onlar sayesinde Form nedir değişken nedir diye sormadığınız için çok daha hızlı öğreneceksiniz.

Ben bu sistemi öğrenmeye çalışırken birileri bana "Amerikayı yeniden keşfetmeye gerek yok ! MFC ile çok kolayca form hazırlarsın" diye nasihat etmişti. ama işin aslı bu değil. Win32 sistemini öğrenmek aslında bisiklet kullanmak gibi diyebiliriz. öğrenmesi zor ama onu kullandıktan sonra diğer araçlar çok daha kolay kullanılır. tabii o Amerikayı keşfetmek istemeyenler de üç tekerlekli MFC sihirbazı ile yollarına devam edebilir.

Uygulamalarınızda güç istiyorsanız zor yolları göze almalısınız. Tüm büyük oyunlar Visual C++ ile yazılmıştır.

API ( Windows´un hazır fonksiyonları )

öncelikle belirteyim ki bu ders sadece Microsoft Win32 bileşenleri kullanılarak anlatılmıştır. Bu açıdan sadece visual C kullanıcıları değil Visual Basic, Delphi, Net veya C# kullanıcıları da bu dersten faydalanabilir. Esas amacımız görsel windows programcılığına genel bir bakış yapıp daha sonra oyun programlamaya yönelmektir. Burada anlatacağım bilgileri internetten uzun arayışlar sonucu öğrenmiş bulunmaktayım. herhangi bir sürç-ü lisan edersem affola.

Microsoft firması ilk Windows´u tasarlarken API adı verilen bir bileşen kullanmıştır. daha sonra hem daha kullanışlı olduğu için hemde geriye doğru destek vermesi gerektiğinden sonraki windows sistemlerinde de API sistemi devam etmiştir. bu açıdan burada öğreneceğiniz uygulama Win-95, Win-NT, Win98, WinME ,WinXP sistemlerinde de çalışacaktır. 

-ilk Mesaj-

Herhangi bir Api´yi kullanabilmek için hazırladığınız exe dosyasının windows içindeki gerekli DLL dosyası yardımı ile hazır bir yapıyı çağırması yeterlidir.

Mesela: Ekrana Mesaj kutusu çıkarmak için C:windowssystem dizinindeki User32.dll içersinden MessageBox isimli fonksiyonun çağrılması yeterlidir. Sizin tekrar pencere tanımlamanız yada düğme çizmeniz gerekmez. Aşağıda Visual C++ ile kullanılacak mesaj komutunu görüyorsunuz. Birçok programda mesaj işlemi daha da kısadır ama esas mesaj penceresi budur. Diğer programlar size göstermeden arkaplanda bu fonksiyonu çağırır. Programda bunu kullandığınızda işletim sisteminin kullandığı yerel lisanı kullanan bir mesaj penceresi gelir. burada MB_OK kelimesi mesaj kutusunda dil Türkçe ise Tamam yazısı çıkarır. dil Rusça ise DA yazısı çıkarır. Mesaj penceresini siz çizmediğiniz gibi düğmedeki yazıyı da siz yazmazsınız, hepsi api sayesinde otomatik olarak meydana çıkar.

MessageBox( NULL,"mesaj metni","mesaj penceresi başlığı",MB_OK);
(Visual C++ ile kullanımı aşağıda ayrıntılı olarak anlatılmıştır.)

Visual C++ giriş ( ilk programımız)

Visual C++ programını açıp File >> New menüsünden ilk programımızı yapacağız. ilk program olduğu için sadece mesaj veren bir program yapıyoruz. Karşımıza gelen pencereden Win32 Application seçiyoruz. ve projemiz için bir isim yazıyoruz. location kısmında ise projenin kaydedileceği dizin bulunuyor.



Dosya adı yazdıktan sonra bize hazır proje isteyip istemediğimiz sorulacaktır. biz en üsttekini seçerek boş bir sayfa istiyoruz



Karşımıza gelen pencereye de OK ve Finish dedikten sonra boş bir proje oluşturduk. Şimdi projenin içini dolduracağız. yukardaki Yeni Yazı Sayfası (New Text File) düğmesine tıklaynca sağ taraftaki boş alana yazı sayfası çıkıyor.



En Basit Program ( Sadece bir mesaj kutusu)



#include 

 int APIENTRY WinMain(HINSTANCE hInstance,HINSTANCE hPrevInstance,LPSTR lpCmdLine,int nCmdShow)
 {

  return MessageBox(NULL,"ilk program","kolay gelsin",MB_OK);

 }


Beyaz sayfayı yazı ile doldurduktan sonra kaydediyoruz. Kayıt sırasında dosya uzantısı olarak ".C" yada ".CPP" yazmanız gerekiyor, böylece program bunun bir kod sayfası olduğunu anlıyor. eğer normal txt dosyası olarak kaydederseniz özel fonksiyonlar renkli görünmeyecektir. örnek isim: proje.cpp



yazdığımız kod sayfasını kaydettikten sonra projeye dahil etmemiz gerekiyor. bunu iki şekilde yapabiliriz. birincisi: kod yazılı olan beyaz sayfada boş biryere sağ tıklayıp insert File into Project >> ProjeAdı seçeneği ile



ikincisi sol alt taraftan FileView kısmını açarak ( bu kısımda projede yer alan tüm dosyalar görünür, kod sayfaları, ikon, menü vb.)



Dosya kontrol kısmını açtıktan sonra Source Files >> Add Files to Folder diyerek az önce kaydettiğimiz proje.cpp isimli dosyayı seçiyoruz.



Böylece ilk projemizi tamamladık. Projeye ilk başlarken bu adımları tekrar yapmanız gerekiyor. 
Projeyi çalıştırmak için F5 tuşunu kullanabilirsiniz. Hataları görmek için ise F7 tuşunu kullanabilirsiniz. F7 projeyi exe dosyası olarak hazırlar. F5 ise hazırlanan exe dosyasını çalıştırır. exe dosyası çalıştığında sadece bir mesaj kutusu ekrana gelecektir. programda form falan yok. mesaj penceresi kapanınca program da biter.



Buradaki amacımız esas döngüyü görmekti. programın içersine yazdığımız WinMain isimli kısım Ana döngüyü oluşturur. Programda çalışacak tüm komutları buradaki iki parantez arasına yazacağız. tabii birçok fonksiyon ve değişken tanımlarını bunun dışında yapıyoruz ama programın çalışması için bu kısım kesinlikle gerekli.

int APIENTRY WinMain(HINSTANCE hInstance,HINSTANCE hPrevInstance,LPSTR lpCmdLine,int nCmdShow)
{

}

şimdi de bir form yapalım. Form yaparken başka bir özellik daha karşımıza çıkıyor. LRESULT CALLBACK isimli fonksiyon. bu fonksiyon form tarafından gönderilen mesajları alan bir sistem içeriyor. bu kısımda gelen mesaja göre işlem yapıyoruz.

LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{ 

}

MESSAGE ( mesaj sistemi)

Windows içersinde her program çalışırken windows ile program arasında mesaj alışverişi olur. Form ilk defa çizilirken program windows´a WM_CREATE isimli mesajı gönderir. form kapatılınca WM_CLOSE isimli bir mesaj gönderir. Form yok edilirken WM_DESTROY isimli bir mesaj gönderir. bunun gibi birçok mesaj bulunmaktadır. henhangi bir düğmeye basılınca WM_COMMAND isimli bir mesaj gönderir. uzun bir listeyi Microsoft´un sitesinde bulabilirsiniz. Biz şimdilik bizim için gerekli olanlara bakacağız.

Switch Fonksiyonu

Bu kısma girmeden önce Standart C kullanımında Switch fonksiyonunu öğrenmelisiniz. Switch yapı olarak IF-ELSE fonksiyonuna benzer ama daha kullanışlıdır. örnekle daha iyi anlatabilirim. case kısmında karşılaştırmalar yapılır. basitçe herbir case için sorgulama yapar diyebiliriz. iki kesme işareti "//" olan satırlar gereksizdir. sadece programcının hatırlatma yazılarını belirtir.

mesaj = 2 ;   // herhangi bir değişken tanımlıyoruz

 switch(mesaj)
  {
      case 1:
              //mesaj değişkeni 1 ise yapılacak işlemler 
      break;

      case 2:
              //mesaj değişkeni 2 ise yapılacak işlemler
      break;

      case 3:
              //mesaj değişkeni 3 ise yapılacak işlemler
      break;

     default:
     // son seçenek
 }

yukardaki işlemde mesaj=2 olduğu için "case 2:" kısmı işlem yapacaktır. program diğer kısımlara uğramadan geçecektir. eğer case kısımlarından hiçbiri doğru değilse default kısmındaki işlem yapılacaktır. Detaylı bilgiyi Standart C ile ilgili kaynaklarda bulabilirsiniz.( ansi-c diye de arayabilirsiniz)

Visual C++ Pencereler (ikinci Program - En Basit Pencere)

Yeni bir proje oluşturup kod olarak aşağıdaki satırları yazıyoruz. her satırda gerekli açıklamaları komut penceresinin altında yaptım. yeni başladıysanız hepsini bir anda anlayamazsınız. Parça parça anlamaya çalışın. aşağıdaki beyaz sayfadaki kodu aynen kopyalayıp kullanabilirsiniz.



#include <windows.h>   
 const char Classismi[] = "pencere"; 
  // gelen mesajları işleyen kısım  
  LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)  
   {      
  switch(msg)      
  {          
  case WM_CLOSE:   
             DestroyWindow(hwnd);  
    break;          
    case WM_DESTROY:              
    PostQuitMessage(0);          
    break;          
    
    default:             
    return DefWindowProc(hwnd, msg, wParam, lParam);      
 }     
 return 0;   
}  
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,      LPSTR lpCmdLine, int nCmdShow)
   {     
   WNDCLASSEX wc; 
   HWND hwnd;      
   MSG Msg;      
   //birinci adım: Pencere özelliklerini belirten bir sınıf değişkeni tanımlanıyor     
    wc.cbSize        = sizeof(WNDCLASSEX);
 wc.style         = 0;     
 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)(COLOR_WINDOW);      
 wc.lpszMenuName  = NULL;      
 wc.lpszClassName = Classismi;      
 wc.hIconSm       = LoadIcon(NULL, IDI_APPLICATION);      
 if(!RegisterClassEx(&wc))     
 {          
 MessageBox(NULL, "Pencere tanımlama hatası!", "Hata!",              MB_ICONEXCLAMATION | MB_OK);
 return 0;      
 }     
 // ikinci adım pencere oluşturma      
 hwnd = CreateWindow(Classismi,"Pencere başlığı",WS_OVERLAPPEDWINDOW,    200, 200, 300, 200,NULL, NULL, hInstance, NULL);
 ShowWindow(hwnd, SW_SHOW);
 UpdateWindow(hwnd);
 // üçüncü adım: mesajların alınması ve ayrılması      
 
 while(GetMessage(&Msg, NULL, 0, 0) > 0)      
 {          
 TranslateMessage(&Msg);          
 DispatchMessage(&Msg);      
 }      
 return Msg.wParam;  
 }  


Basit Parçalar Birleşince Karmaşık Görünebilir

#include <windows.h> ilk satır bu programda windows bileşenleri kullanacağımızı belirtiyor.
const char Classismi[] = "pencere";burada tanımlanan değişken biraz aşağıdaki WNDCLASSEX objesi için isim olacaktır. 
LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)  {
      
switch
(msg)      {
          
case 
WM_CLOSE:              
DestroyWindow(hwnd);
          
break;          

case 
WM_DESTROY:              
PostQuitMessage(0);          
break;          
default:              
return 
DefWindowProc(hwnd, msg, wParam, lParam);      
}      return 0; 
 }          LRESULT CALLBACK isimli fonksiyon içersinde programdan gelen mesajlar(msg) işlenecektir. burada temel iki tane WM_ mesajı yazılmıştır.(WindowsMessage) Eğer programda bir düğme olsaydı WM_COMMAND ile düğmeye basıldığını anlayabilirdik. ( ilgili örnek sonraki sayfada işlenecektir)
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)  { } WinMain isimli fonksiyonun mutlaka olması gerektiğini az önceki örnekte görmüştük. bu bizim ana döngümüz.
WNDCLASSEX wc; // Pencere özelliklerini tanımlayacak olan cisim belirleniyor wc

HWND hwnd; // Pencerenin kontrolunda kullanılacak handle ( kulp, sap , kabza) 

MSG Msg; // mesaj için değişken
Bu kısımda önemli bir bilgi için açıklamaya ara veriyorum. HANDLE isimli değişken win32 programcılığında çok önemlidir. herhangi bir nesne ile uğraşırken bu handle numarasını bilmemiz gerekir. Diyelim ki pencereyi gizlemek istiyoruz bu durumda: 

ShowWindow(hwnd, SW_HIDE);

fonksiyonunu kullanabiliriz. Eğer pencereyi tekrar görünür yapmak istersek. ShowWindow(hwnd, SW_SHOW); komutu ile açığa çıkarırız. burada handle numarası hangi pencerenin gizleneceğini belirtir. Diyelim ki Pencere üzerindeki Butonu gizlemek istiyoruz bu durumda ShowWindow(hbuton, SW_HIDE); şeklinde bir komut ile gizleyebiliriz. buradaki hbuton ise buton için tanımlanacak bir handle değişkenidir. ( buton yapmayı ilerde göreceğiz.handle ile ilgili bilgiyi uygulama yaptıkça pekiştirirsiniz ) Açıklamaya geri dönelim:
wc.cbSize = sizeof(WNDCLASSEX); 
wc.style = 0; 
wc.lpfnWndProc = WndProc; //LRESULT CALLBACK fonksiyonun adı, pencere mesajları oraya yollayacak
wc.cbClsExtra = 0; 
wc.cbWndExtra = 0; 
wc.hInstance = hInstance; 
wc.hIcon = LoadIcon(NULL, IDI_APPLICATION); //Pencere için gerekli icon
wc.hCursor = LoadCursor(NULL, IDC_ARROW); // Pencere üzerinde iken fare işaterçisi hangi şekilde olacak
wc.hbrBackground = (HBRUSH)(COLOR_WINDOW); //Pencere rengi
wc.lpszMenuName = NULL;
wc.lpszClassName = Classismi; //Tanımlanan Bu yapıyı çağırmak için kullanılacak isim
wc.hIconSm = LoadIcon(NULL, IDI_APPLICATION); // Pencere için minik icon 

 if(!RegisterClassEx(&wc)) 
{
  MessageBox(NULL, "Pencere tanımlama hatası!", "Hata!", MB_ICONEXCLAMATION | MB_OK); 
  return 0; 
}
Bu kısımda oluşacak pencere için gerekli özellikler bir yapı ile tanımlanıyor. Açıklama yazmadığım özellikler için WNDCLASSEX yapısının açıklamasına microsoft.com sitesinden ulaşabilirsiniz. sıfır yada NULL yazılanlar özel tanımlamalar için gerekli, bizim şimdilik onlarla işimiz olmayacak.
 if(!RegisterClassEx(&wc)) kısmında ise hazırlanan bu yapı windows´a onaylatılıyor. eğer yapıda hata varsa daha pencere açılmadan ekrana Mesaj kutusu çıkacaktır.
hwnd = CreateWindow(Classismi,"Pencere başlığı",WS_OVERLAPPEDWINDOW, 200, 200, 300, 200,NULL, NULL, hInstance, NULL);işte esas fonksiyon bu CreateWindow , ( veya CreateWindowEx ) O kadar yazının tek amacı bu fonksiyona yol verebilmek için bu fonksiyon ile tüm pencere bileşenlerini oluşturacağız. Butonu da aynı fonksiyonla oluşturuyoruz. liste kutusunu da aynı fonksiyon ile. çünkü windows içersinde tüm bileşenler birer pencere olarak varsayılır. bir buton da windows için bir penceredir. sadece şekli farklıdır.

CreateWindow fonksiyonuna ayrıntılı olarak bakmamız gerekiyor, çünkü bu fonksiyonu çok kullanacağız ve bize çok şey öğretebilir. Microsoft´un sitesinde bu fonksiyon şu şekilde tanımlanır.Açıklaması altında.

HWND CreateWindow(
LPCTSTR lpClassName,
LPCTSTR lpWindowName,
DWORD dwStyle,
int x,
int y,
int nWidth,
int nHeight,
HWND hWndParent,
HMENU hMenu,
HINSTANCE hInstance,
LPVOID lpParam
);
HWND CreateWindow( // bu HWND ( yani handle=kulp)oluşan yapının sayı cinsinden karşılığıdır. tüm pencerelerin bir handle numarası vardır. bu numarayı bilirseniz sizin programınızın dışında bir programa da emir verebilirsiniz.

LPCTSTR lpClassName, //oluşacak pencere için belirlenen bir sınıf adı. bu sınıfı biz WNDCLASSEX türünden kendimiz oluşturabileceğimiz gibi. BUTTON LISTVIEW, COMBOBOX gibi hazır sınıfları da kullanabiliriz.

LPCTSTR lpWindowName, // Pencerenin adı Eğer bu bir pencere ise bu title olacaktır ( pencerenin tepesindeki yazı) eğer bu bir buton ise düğme üzerindeki yazı olacaktır.

DWORD dwStyle, // pencere özel tanımlamaları bunun listesi .çok uzundur. bir pencere için birkaç farklı sitil kullanılabilir. aralarına dik çizgi konarak "|". 
Eğer hazırlanan ana pencere(form) ise bunlar 
WS_BORDER(kenar çizgisi olsun)
WS_MINIMIZE(program açılışta simge durumunda olsun)
WS_CHILD ( ana pencere dışındaki buton, liste, yazı vb. cisimler için kullanılır. zorunludur)
vb. pencere özellikleri olacaktır.

Eğer hazırlanan buton ise bunlar 
BS_DEFPUSHBUTTON (enter tuşuna basılınca çalışan buton)
BS_CENTER (düğme içindeki yazı ortalı olur) 
BS_PUSHBUTTON (normal bir düğme için)
BS_CHECKBOX (Buton ; onay kutucuğu gibi olur)

Eğer hazırlanan ComboBox ise bunlar 
CBS_DROPDOWN ( seçilebilir liste)
CBS_SORT (girilen yazıları otomatik listeler)

Eğer hazırlanan Edit (Text-Metin kutusu )ise bunlar 
ES_AUTOHSCROLL (yazı kutusunda sağa doğru kaydırma yapar)
ES_LOWERCASE (girilen tüm yazılar küçük harfe dönüşür)
ES_NUMBER ( sadece rakam girilebilir, harf yazılamaz)

Yukarda saydıklarım uzun bir listeden ufak bir parça, uzun listeyi microsoft.com sitesinde developer bölümünde bulacaksınız.Windows sistemini Microsoft yazdığına göre en iyi açıklamaları da onlar yapacaktır.

int x, // oluşan pencerenin soldan uzaklığı, eğer ana pencere ise ekranın solunda uzaklığı

int y, // pencerenin yukardan uzaklığı

int nWidth, //pencere eni
int nHeight, //pencere yüksekliği

HWND hWndParent, // Eğer oluşturulan Ana pencere ise bu değer Null yani boş girilir. Eğer oluşturulan düğme veya metin kutusu gibi yavru bir pencere ise bu değer ana pencerenin HANDLE değeridir.

HMENU hMenu, // Program içersinde dilerseniz tüm alt pencerelere birer menü numarası verebilirsiniz, ( düğme liste vb.) böylece daha kolay erişim imkanınız olur.

HINSTANCE hInstance, //instance numarası, program içersinde sadece bir instance numarası vardır. bu da ilk oluşturma sırasında ana pencereye atanır. ana pencere veya yavru pencerede bu sayı aynıdır.

LPVOID lpParam //pencere oluşturma bilgisinin işaretçisi. özel durumlarda kullanılır. şimdilik bunu boş geçeceğiz (null) sınırsız sayıda yavru pencere oluşturma gibi özel durumlarda kullanılır.
);

Eğer CreateWindow fonksiyonunu anlayabildiyseniz önemli kısmını bitirdik demektir. bunda sonra gelen kısımda pencereyi ekranda gösteren komut ve mesajı alıp parçalara ayıran iki komut var. bunları zaten herzaman kullanacaksınız.

ShowWindow(hwnd, SW_SHOW); //pencereyi göster
UpdateWindow(hwnd); //pencereyi tazele

// üçüncü adım: mesajların alınması ve ayrılması 
while(GetMessage(&Msg, NULL, 0, 0) > 0) {
TranslateMessage(&Msg);
DispatchMessage(&Msg); 
} 
return Msg.wParam;  //ana döngünün sonu
}

Sonuçta elde ettiğimiz boş pencere böyle olacak.



kaynak: www.tr3d.com (Bu sitede Grafik ve programlama üzerine güzel kaynaklar bulabilirsiniz özellikler 3D Studio Max ile ilgilenenlere tavsiye ederim)

Windows Tetris Oyunu Kaynak kodları

2008-05-06T04:22:00.000-07:00

C# ile GDI (grafik kütüphanesi) kullanılarak yazılmış güzel bir tetris oyunu ve kaynak kodları öğrenciler için sunulmuş, windows ta çalışan 2 boyutlu oyun yapmak isteyenlerin incelemesi gereken iyi bir kaynak olmuş ...




Programcı : Şahin UZUNOK
kaynak: www.csharpnedir.com

DOWNLOAD : http://www.csharpnedir.com/kod/Tetris2007.zip

Euro 2008 Oyunu

2008-04-25T07:43:00.000-07:00

EA Canada tarafından geliştirilen UEFA Euro 2008'de, daha hızlı ve kontrollü bir motor bulunacak. Euro 2007'e katılan tüm takımları ve resmi stadyumları içerecek. 50'nin üzerinde Avrupa milli takımıyla oynama imkanı olacak. Ülke Kaptanı isimli yeni mod sayesinde oyuncular sahaya takımlarının kaptanı olarak çıkacaklar. Ayrıca turnuvanın atmosferini geliştirecek olan interaktif kutlamalar yoluyla sahada başarılarını kutlayabilecekler. Buna ek olarak Ülkeler Savaşı modunda, diğer oyuncularla başarıya ulaştırmak için birlikte mücadele edebilecekler.

Euro 2008'in yapımcısı Simon Humber yapımla ilgili olarak, milli takımlar arasındaki rekabeti oyuna taşııdıklarını ve oyunculara ülke kaptanı veya kahramanlarından biri rolüne bürünme imkânı vererek oyuncuların milli takımları için hissettikleri coşkuyu kucaklayacaklarını söylüyor. Ayrıca oyunun motorunu yeni bir düzeye taşıdıklarını ve gerçek turnuva deneyimini ve yaşanan duyguları yakalayabilecek bir oyun yaratmak için pek çok yenilikçi özellik eklediklerini belirtiyor.

UEFA Euro 2008'in diğer bir özelliği ilk defa tüm Avrupa'da, önde gelen cep telefonu operatörleri vasıtasıyla cep telefonlarına da indirilebilecek. Yeni tek düğme kontrol sistemi sayesinde cep telefonlarında rahatça oynanacak. Oyun 11 Nisan'da Avrupa'da, 20 Mayıs'ta ise Amerika'da piyasaya sürülecek.

Bence en iyi futbol oyunu KONAMI yapar. PES 2008 mesela ... Konami yaptığı futbol oyunlarında yapay zeka olarak daha önde ...

Windows Sayısal Loto Oyunu

2008-04-25T07:26:00.000-07:00

Madem daha directx öğrenemedik o zaman windows ta bişeyler yapayım dedim (can sıkıntısından) ve Sayısal Loto tahmin oyunu yaptım. Oldukça basit bir şey ama c# ile ilgilenenler için Properties(özellik tanımlama) nasıl olur? bunu öğretebilir ...

Download Kaynak kodu : http://www.dosyaupload.net/download.php?file=82505

Yapay Zeka - Arama Algoritması

2008-04-22T14:10:00.000-07:00

Öngörüsel (heuristic) arama işlemlerinden gerçekleştirmesi en kolay olanlardan birisi Best First Search ya da diğer adıyla Hill Climbing Search olarak adlandırılan bu arama stratejisidir. Hill Climbing algoritmasında arama işleminde o anda aktif olan düğüm genişletilir ve çocuk düğümler değerlendirilir. Bunlardan en iyi değerlere sahip olan düğüm bir sonraki genişletme işleminde kullanılmak üzere seçilir.

Arama işlemi çocukların hepsinden daha iyi bir duruma erişildiğinde sona erer. Bu sistemde hatalı öngörüsel (heuristic) değerler sonsuz yollara, dolayısıyla arama işleminin başarısızlıkla sonuçlanmasına neden olur. Bu nedenle bu algoritmanın başarısı için öngörüsel değerlerinin doğru belirlenmesi büyük önem taşır. Algoritmada önceki basamaklarla ilgili bilgi tutulmamaktadır dolayısıyla hata durumu ile karşılaşıldığında eldeki yanlış çözüm üzerinde bir düzeltme yapılabilmesi söz konusu değildir. Algoritma, tüm çocuklardan daha iyi durumdaki bir düğüme erişildiğinde sona erdiğinden yele maksimum noktaları da sorun yaratmaktadır. İyi mutlak açıdan en iyi olmak zorunda değildir. Hill Climbing algoritması yerel ve global maksimum arasındaki ayrımı yapamamaktadır. Algoritmamızda AÇIK olarak adlandıracağımız gidilebilecek durumların tutulduğu bir liste ve KAPALI olarak adlandırdığımız ziyaret ettiğimiz durumların tutulduğu bir liste kullanılmaktadır. Algoritma aşağıdaki gibidir.

Best First Search Algoritmasının Açık Metin Hali:

1. AÇIK listesine Start düğümünü ekle
2. KAPALI listesini boşalt
3. AÇIK listesinde eleman olduğu surece
4. AÇIK listesinin en solundaki elemanı listeden çıkart . Bu elemanı X olarak adlandıralım.
5. X'ın çocuklarını bul
6. X'in tüm çocukları için
6.1. Eğer child AÇIK ve KAPALI listesinde değil ise 
6.1.1. Child'e bir herustik değer ver ve AÇIK listesine ekle.
6.2. Child AÇIK Listesinde ise
6.2.1. Eğer daha kısa bir yol ile ulaşılmış ise AÇIK lisesindeki Child kayıdının Herustik değerini değiştir.
6.2.2. Child'ın ebeveyn bilgisini günceller.
6.3. Eğer child KAPALI listesinde ise
6.3.1. Eğer daha kısa bir yol bulunmuş ise KAPALI listesinden çıkartıp yeni bilgilere göre güncelleyip AÇIK listesine ekle.
7. X nodunu KAPALI listesine ekle
8. AÇIK listesini herustik değerlerine göre yeniden sırala (En iyi seçenek sola gelecek şekilde)

Best First Search Algoritmasının Arakod Hali:

Procedure best_first_search* (Hill Climbing Search)
Begin
  Open := [Start];
  Closed :=[];
  While open <> [] do Begin
    Remove the leftmost state from open, call it X;
    If  X =goal then return the return the path form the Start to X
    Else begin
      Generate children of X;
      For each child of X do
      Case
        The child is not on open or closed: Begin
          Assign the child a herustic value;
          Add the child to open
        End;
        The child is already on open:
          If the child was reached by a shorter path
          Then give the state on open the shorter path
        The child is already on closed:
        If the child was reached by a shorter path then Begin
          Remove the state from closed;
          Add the child to open
        end
      end;
      put X on closed;
      re-order states on open by heuristic merit (best leftmost)
    end;
  return failure
end.


Algoritma her iterasyonda AÇIK listesinden bir elemanı (anlık olarak en iyi -çözüme en yakın- olan elemanı) çıkartır. Eğer algoritma hedef şartlarına erişirse hedefe ulaşılmasını sağlayan yol bilgisini geri döndürür. Burada dikkat edilecek nokta algoritmanın her düğümün kendi (babası) ebeveyni hakkında bilgi içerdiğini kabul ettiğidir.

kaynak: www.yapay-zeka.org

C++ ile 2D Oyun yapıyor ve çok güzel

2008-04-22T14:05:00.000-07:00

Part2

Part3

Manged Directx Örnek Uygulama - 3

2008-04-17T01:54:00.001-07:00

Örnek Uygulama 3

Şimdi de birden çok texture’ü nasıl temel şekilimizin üzerinde görüntüleyeceğimizi görelim.

using System;
using System.Drawing;
using System.Windows.Forms;
using Microsoft.DirectX;
using Microsoft.DirectX.Direct3D;
using Direct3D = Microsoft.DirectX.Direct3D;

namespace Oyun1
{
 public class oyun : Form
 {
  Device device=null;
  VertexBuffer vertbuffer=null;
  Texture[] texture=new Texture[10];
  public oyun()
  {
   this.ClientSize = new Size(450,450);
   this.Text = "Oyun Deneme!";
  }
  public bool grafik_hazirla()
  {
   try
   {
    PresentParameters d3dpp = new PresentParameters();
    d3dpp.Windowed = true;
    d3dpp.SwapEffect = SwapEffect.Discard;
    device = new Device(0,DeviceType.Hardware,this,CreateFlags.SoftwareVertexProcessing,d3dpp);
    vertbuffer = new VertexBuffer(typeof(CustomVertex.TransformedTextured),4,device,Usage.WriteOnly,CustomVertex.TransformedColored.Format,Pool.Default);
    for(int i = 1;i<10;i++)
    {
     texture[i]=TextureLoader.FromFile(device,"c:\\a"+Convert.ToString(i)+".bmp");
    }
    GraphicsStream stm = vertbuffer.Lock(0,0,0);
    CustomVertex.TransformedTextured[] verts = new Microsoft.DirectX.Direct3D.CustomVertex.TransformedTextured[4];
    verts[0].X = 100; verts[0].Y = 100;verts[0].Z = 0;verts[0].Rhw =1;verts[0].Tu=0;verts[0].Tv=0;
    verts[1].X = 300; verts[1].Y = 100;verts[1].Z = 0;verts[1].Rhw = 1;verts[1].Tu=1;verts[1].Tv=0;
    verts[2].X = 100; verts[2].Y = 300;verts[2].Z = 0;verts[2].Rhw = 1;verts[2].Tu=0;verts[2].Tv=1;
    verts[3].X = 300; verts[3].Y = 300;verts[3].Z = 0;verts[3].Rhw = 1;verts[3].Tu=1;verts[3].Tv=1;
    stm.Write(verts);
    vertbuffer.Unlock();
    return true;
   }
   catch(DirectXException hata)
   {
    MessageBox.Show(hata.ToString());
    return false;
   }
  }
  static int x;
  private void render()
  {
   if(device==null)
    return;
   device.Clear(ClearFlags.Target,System.Drawing.Color.BlueViolet,1.0f,0);
   device.BeginScene();
   device.SetTexture(0,texture[x]);
   x+=1;
   if(x==10)
    x=0;
   device.SetStreamSource(0,vertbuffer,0);
   device.VertexFormat = CustomVertex.TransformedTextured.Format;
   device.DrawPrimitives(PrimitiveType.TriangleStrip,0,2);
   device.EndScene();
   device.Present();
  }
  protected override void OnPaint(System.Windows.Forms.PaintEventArgs e)
  {
   this.render();
  }
  protected override void OnKeyPress(System.Windows.Forms.KeyPressEventArgs e)
  {
   if ((int)(byte)e.KeyChar == (int)System.Windows.Forms.Keys.Escape)
    this.Close();
  }

  private void InitializeComponent()
  {
   // 
   // oyun
   // 
   this.AutoScaleBaseSize = new System.Drawing.Size(5, 13);
   this.ClientSize = new System.Drawing.Size(292, 266);
   this.Name = "oyun";

  }
 
  static void Main()
  {
   using(oyun f1=new oyun())
   {
    if(!f1.grafik_hazirla())
    {
     MessageBox.Show("Grafik Hazırlanamıyor!");
     return;
    }
    f1.Show();
    while(f1.Created)
    {
     f1.render();
     Application.DoEvents();
    }
   }
  }
 }
}


kaynak: Öğretim Görevlisi Murat GÜNEŞ

Manged Directx Örnek Uygulama - 2

2008-04-17T01:51:00.000-07:00

Örnek Uygulama 2

Bu uygulamada da ekrana çizdirdiğimiz teel şekilin(dörtgen) üzerine texture kaplayacağız.

using System;
using System.Drawing;
using System.Windows.Forms;
using Microsoft.DirectX;
using Microsoft.DirectX.Direct3D;
using Direct3D = Microsoft.DirectX.Direct3D;

namespace Oyun1
{
 public class oyun : Form
 {
  Device device=null;
  VertexBuffer vertbuffer=null;
  Texture texture=null;
  public oyun()
  {
   this.ClientSize = new Size(450,450);
   this.Text = "Oyun Deneme!";
  }
  public bool grafik_hazirla()
  {
   try
   {
    PresentParameters d3dpp = new PresentParameters();
    d3dpp.Windowed = true;
    d3dpp.SwapEffect = SwapEffect.Discard;
    device = new Device(0,DeviceType.Hardware,this,CreateFlags.SoftwareVertexProcessing,d3dpp);
    vertbuffer = new VertexBuffer(typeof(CustomVertex.TransformedTextured),4,device,Usage.WriteOnly,CustomVertex.TransformedColored.Format,Pool.Default);
    texture=TextureLoader.FromFile(device,"c:\\a1.bmp");
    GraphicsStream stm = vertbuffer.Lock(0,0,0);
    CustomVertex.TransformedTextured[] verts = new Microsoft.DirectX.Direct3D.CustomVertex.TransformedTextured[4];
    verts[0].X = 100; verts[0].Y = 100;verts[0].Z = 0;verts[0].Rhw =1;verts[0].Tu=0;verts[0].Tv=0;
    verts[1].X = 300; verts[1].Y = 100;verts[1].Z = 0;verts[1].Rhw = 1;verts[1].Tu=1;verts[1].Tv=0;
    verts[2].X = 100; verts[2].Y = 300;verts[2].Z = 0;verts[2].Rhw = 1;verts[2].Tu=0;verts[2].Tv=1;
    verts[3].X = 300; verts[3].Y = 300;verts[3].Z = 0;verts[3].Rhw = 1;verts[3].Tu=1;verts[3].Tv=1;
    stm.Write(verts);
    vertbuffer.Unlock();
    return true;
   }
   catch(DirectXException hata)
   {
    MessageBox.Show(hata.ToString());
    return false;
   }
  }
  private void render()
  {
   if(device==null)
    return;
   device.Clear(ClearFlags.Target,System.Drawing.Color.BlueViolet,1.0f,0);
   device.BeginScene();
   device.SetTexture(0,texture);
   device.SetStreamSource(0,vertbuffer,0);
   device.VertexFormat = CustomVertex.TransformedTextured.Format;
   device.DrawPrimitives(PrimitiveType.TriangleStrip,0,2);
   device.EndScene();
   device.Present();
  }
  protected override void OnPaint(System.Windows.Forms.PaintEventArgs e)
  {
   this.render();
  }
  protected override void OnKeyPress(System.Windows.Forms.KeyPressEventArgs e)
  {
   if ((int)(byte)e.KeyChar == (int)System.Windows.Forms.Keys.Escape)
    this.Close();
  }

  private void InitializeComponent()
  {
   // 
   // oyun
   // 
   this.AutoScaleBaseSize = new System.Drawing.Size(5, 13);
   this.ClientSize = new System.Drawing.Size(292, 266);
   this.Name = "oyun";

  }
 
  static void Main()
  {
   using(oyun f1=new oyun())
   {
    if(!f1.grafik_hazirla())
    {
     MessageBox.Show("Grafik Hazırlanamıyor!");
     return;
    }
    f1.Show();
    while(f1.Created)
    {
     f1.render();
     Application.DoEvents();
    }
   }
  }
 }
}


kaynak: Öğretim Görevlisi Murat Güneş

Managed Directx Örnek Uygulama - 1

2008-04-16T03:31:00.001-07:00

Bu uygulamada ekrana temel şekillerin nasıl çizdirildiğini inceleyeceğiz. İlk uygulama olduğu için texture yerine şimdilik vertexleri boyamayı tercih ediyoruz. Yani kullanacağımız vertex tipi “TransformedColored” olacak.

using System;
using System.Drawing;
using System.Windows.Forms;
using Microsoft.DirectX;
using Microsoft.DirectX.Direct3D;
using Direct3D = Microsoft.DirectX.Direct3D;

namespace Oyun1
{
 public class oyun : Form
 {
  Device device=null;
  VertexBuffer vertbuffer=null;
  public oyun()
  {
   this.ClientSize = new Size(450,450);
   this.Text = "Oyun Deneme!";
  }
  public bool grafik_hazirla()
  {
   try
   {
    PresentParameters d3dpp = new PresentParameters();
    d3dpp.Windowed = true;
    d3dpp.SwapEffect = SwapEffect.Discard;
    device = new Device(0,DeviceType.Hardware,this,CreateFlags.SoftwareVertexProcessing,d3dpp);
    vertbuffer = new VertexBuffer(typeof(CustomVertex.TransformedColored),4,device,Usage.WriteOnly,CustomVertex.TransformedColored.Format,Pool.Default);
    GraphicsStream stm = vertbuffer.Lock(0,0,0);
    CustomVertex.TransformedColored[] verts = new Microsoft.DirectX.Direct3D.CustomVertex.TransformedColored[4];
    verts[0].X = 100; verts[0].Y = 100;verts[0].Z = 0;verts[0].Rhw = 1;verts[0].Color = System.Drawing.Color.Blue.ToArgb();
    verts[1].X = 300; verts[1].Y = 100;verts[1].Z = 0;verts[1].Rhw = 1;verts[1].Color = System.Drawing.Color.Black.ToArgb();
    verts[2].X = 100; verts[2].Y = 300;verts[2].Z = 0;verts[2].Rhw = 1;verts[2].Color = System.Drawing.Color.Red.ToArgb();
    verts[3].X = 300; verts[3].Y = 300;verts[3].Z = 0;verts[3].Rhw = 1;verts[3].Color = System.Drawing.Color.Brown.ToArgb();
    stm.Write(verts);
    vertbuffer.Unlock();
    return true;
   }
   catch(DirectXException hata)
   {
    MessageBox.Show(hata.ToString());
    return false;
   }
  }
  private void render()
  {
   if(device==null)
    return;
   device.Clear(ClearFlags.Target,System.Drawing.Color.BlueViolet,1.0f,0);
   device.BeginScene();
   device.SetStreamSource(0,vertbuffer,0);
   device.VertexFormat = CustomVertex.TransformedColored.Format;
   device.DrawPrimitives(PrimitiveType.TriangleStrip,0,2);
   device.EndScene();
   device.Present();
  }
  protected override void OnPaint(System.Windows.Forms.PaintEventArgs e)
  {
   this.render();
  }
  protected override void OnKeyPress(System.Windows.Forms.KeyPressEventArgs e)
  {
   if ((int)(byte)e.KeyChar == (int)System.Windows.Forms.Keys.Escape)
    this.Close();
  }
  static void Main()
  {
   using(oyun f1=new oyun())
   {
    if(!f1.grafik_hazirla())
    {
     MessageBox.Show("Grafik Hazırlanamıyor!");
     return;
    }
    f1.Show();
    while(f1.Created)
    {
     f1.render();
     Application.DoEvents();
    }
   }
  }
 }
}

Managed Directx Bölüm - 7 Temel Şekillerin Çizilmesi ve Texture

2008-04-16T03:16:00.000-07:00

Temel Şekillerin Çizilmesi ve Texture

Artık çalışmaya başlayabiliriz: Adaptörlerin ve Device’ların ne olduğunu biliyoruz, görüntü modlarının ne olduğunu anladık, temel Direct 3D program yapısını biliyoruz ve projeksiyonlar, kameralar ve dönüşümlerle ilgili bilmemiz gerekenleri(şimdilik) biliyoruz. Şimdi tek ihtiyacımız olan şey ortaya koyacağımız sahnelerde rol alacak aktörler: Temel şekilleri çizmek.

Temel şekillerin çizimi, tekil 3D objelerin vertex koleksiyonlarının oluşturulması anlamına gelir. Direct 3D, diğer 3D objeleri oluşturmak için temel olarak poligon – üçgen – kullanır. Çünkü sadece üç nokta ile tanımlanan bir şekil kesinlikle bir düzlemde olacaktır, konveks olacaktır ve bu karakteristikler mümkün olan en hızlı rendering’i sağlayacaktır.

Örneğin ekrana bir kare çizmek istersek, iki tane üçgen kullanmanız gerekir. Bir küp çizmek istersek 12 adet üçgen kullanmalıyız(herbir yüz için iki adet). Şekilde görüldüğü gibi;

Burada bir konudan bahsetmek gerekecek. Birinci bölümde de bahsettiğim gibi 3D objeler ikiye ayrılıyor: Katı modeller ve Meshler. Direct 3D’nin kullandığı objeler, sadece yüzeylerden oluşan meshlerdir. Bu yüzdendir ki eski oyunlarda(yenilerinde bu yavaş yavaş aşılıyor) ekrandaki bir objenin içine giren kamera objenin içerisini ve hatta ötesini gösteriyordu.

Üçgenlerle çalışırken Direct 3D bize, genellikle debug amaçlı kullanımı olan, çizgilerin ve noktaların listesini tanımlamamız için izin verir. Bu sayede içgen kullanırken objemizin wireframe(tel-kafes) görüntüsünü görebilir ve gizli yüzeyleri kontrol edebiliriz.

Direct 3D’de obje oluşturma adımları aşağıdaki gibidir:

1. Verteks tipinini tanımlanması,
2. Bir verteks tamponu(vertex buffer) oluşturulması,
3. Tanımlanmış verteks tipine göre, objenin herbir verteksiyle tamponun doldurulması,
4. Tamponun Device’ta çizilmesi, diğer bir deyişle temel şekil tipinin bildirilmesi.

Şimdilik bütün vertekslerin x,y ve z koordinatlarında tanımlandığını varsayalım(bununla ilgili daha detaylı bilgiyi ileride göreceğiz), bu sayede temel şekil tiplerinin çizimine konsantre olabiliriz.

Verteks tamponu bir kez doldurulduğunda, bunu ekrana çizmek için aşağıdaki kodlar kullanılır:

D3Ddevice.SetStreamSource(0,vb,0);

D3Ddevice.DrawPrimitives(,0,);

Burada vb, VertexBuffer’dan, D3Ddevice da Direct3D.Device’tan türetilmiş birer objedir.

Temel şekil tipi, aşağıdaki PrimitiveType enumeration değerlerinden biri olabilir:

PointList:Herbir verteks diğerlerinden izole edilerek render edilir, bu sayede bir kayan noktalar(floating points) görebiliriz. Çok kullanışlı bir yöntem değil çünkü, DirectX’in 8.0 sürümünden sonra PointSprites isimli yeni bir özelliğe sahibiz. Partikül efektini PointSprites ile vermek daha mantıklı. Aşağıdaki şekil, bir nokta listesi(PointList) olarak renderlenmiş vertekslerin kurulumunu gösteriyor.

LineList:Verteksler, her çifti bir çizgi birleştirmek üzere, çift çift renderlenir. Bu enumeration, eğer vertekslerin sayısına dikkat etmezsek, hata üretir.

LineStrip:Tampondaki(buffer) bütün verteksler tek bir polyline(çoklu çizgi) olarak renderlenir. Bu yöntem özellikle debug amaçlı kullanışlıdır çünkü, bu temel şekil tipi(primitive type) bize, verteks sayısından bağımsız olarak, objemizin wireframe(tel-kafes) görüntüsünü görme imkanı sunar.

TriangleList:Verteksler, izole edilmiş üçgenler gibi, üçerli gruplar halinde renderlenir. Bu bize, kompleks sahneleri(scene) renderlerken en büyük akıcılığı sağlar fakat, eğer bağlantılı üçgenler çizmek istiyorsak ikilenen(üzerinden geçilen) vertekslerin tekrar çizdirilmesi sözkonusudur.

• TriangleStrip:Bu temel şekil tipini, bağlantılı üçgenler çizerken kullanacağız. Bu, karmaşık sahneleri(scene) renderlemek için en çok kullanılan temel şekil tipidir. Çünkü ikilenen verteksleri tekrar çizmek zorunda kalmayız. Çizilen ilk iki verteksten sonra çizilen herbir verteks, bu ilk iki verteksi kullanarak, yeni bir üçgen oluşmasını sağlar.

• TriangleFan:Bu temel şekil tipinde, bütün üçgenler ortak bir verteks kullanır(buffer’daki ilk verteks) ve her yeni verteks, ilk verteksi ve kendinden önce ekleneni kullanarak, yeni bir üçgen oluşturur.

Üçgenleri çizerken, eğer Direct 3D’nin, bir üçgenin sadece ön yüzünü çizmesini (renderlemesini) istiyorsak, üçgenin verteks sıralamasına özel önem göstermeliyiz. Arka yüzeyleri gizleme özelliği “culling” olarak anılır. Bir culling modunu seçtiğimizde, eğer ön yüzün saat yönünde veya saat yönünün tersinde olmasını istiyorsak, bunu belirtmeliyiz; bu sayede aynı verteks düzenini kullanarak bütün üçgenleri çizebiliriz.

Pekala, muhtemelen “bu temel şekil tipleri ilginç ama ekrana tek bir şekil çizmek istersem, bir bitmap ya da diskteki bir dosya gibi. Bunu direkt ekrana çizdiremez miyim?” diye düşünüyorsunuz. Yanıt; hayır. Bir dörtgen oluşturmalısınız(iki üçgenden oluşan) ve resminizi bir texture olarak onun üzerine uygulamalısınız. Yokarıdaki Mesh&Texture başlığı altındaki örneği hatırlayın.

kaynak: Öğretim Görevlisi Murat GÜNEŞ

Managed Directx Bölüm - 6 Kameranın Yerleştirilmesi

2008-04-15T11:27:00.001-07:00

Kameranın Yerleştirilmesi

3D koordinat sistemiyle çalışırken ekstra bir özellik olarak, DirectX, aynı sahneyi farklı noktalardan görebilmemiz için kamerayı yerleştirmemize izin verir.

Kamera pozisyonu, objenin World koordinatlarına uygulanan bazı özel dönüşümlerle(transformations) hesaplanır. Bu dönüşümler için gerekli olan matrisi manuel olarak hesaplayıp .Transform.View özelliğine setleyebiliriz veya yardımcı fonksiyonlar da kullanabiliriz; Matrix.LookAtLH ve Matrix.LookAtRH gibi. Bu yardımcı fonksiyonlar kameranın pozisyonunu ve baktığı yönü üç nokta ile tanımlar:

1. Kameranın 3D pozisyonu,
2. Kameranın baktığı yerin 3D pozisyonu,
3. (Genellikle y ekseni olan) yukarı doğrultusu.

Eğer bir görüntü(kamera) matrisi tanımlamazsak, DirectX bizim için varsayım bir matris tanımlayacaktır ama bu akılda tutulması gereken önemli bir konsepttir. İlk Prince of Persia oyununu hatırlayın. Burada Prens, oyunun bir sahnesinde, bir yere düşüyordu ve ekran yukarı-aşağı doğrultusunda değişiyordu. Bu özelliği tek bir satır kodla oluşturabileceğinizi hayal edin: Kamera matrisini 1800 döndürerek(bir yönlendirme matrisi ile çarparak). Buradan da anlaşılıyor ki; Direct 3D, 2D oyunlarda dahi büyük avantajlar sağlıyor.

kaynak: Öğretim Görevlisi Murat GÜNEŞ

Managed Directx Bölüm - 5 Matrisleri ve 3D Dönüşümleri Anlamak

2008-04-15T11:12:00.000-07:00

Matrisleri ve 3D Dönüşümleri Anlamak

Direct 3D ile çalışırken en önemli nokta, dönüşüm matrislerinin nasıl çalıştığını bilmektir. Matrisleri kullanarak, 3D dünyadaki(veya eğer z bileşenini ihmal edersek, 2D dünyadaki) herhangi bir objenin rotation(yönlendirme), scaling(ölçeklendirme, boyutlandırma) veya translation(çevirimini) yapabiliriz ve bu işlemlerin doğru bir şekilde uygulanması, projeksiyon tipini tanımlamamıza(bir önceki konuda belirttiğimiz gibi) ve hatta aynı sahneyi farklı noktalardan görmek için kamerayı hareket ettirmemize yardımcı olacaktır.

Şimdi basit bir translation yaparak dönüşüm matrislerinin kullanımına bir göz atalım ve sonra bu operasyonu daha kompleks işlemler için dallandıralım. Bir üçgeni y ekseni boyunca yukarıya doğru hareket ettirmek istediğimizi farz edelim. Şekil 1'i inceleyin.

Üçgenimizin aşağıda verilen noktalarla tanımlandığını varsayalım.

y ekseni boyunca 40 birim yukarıya hareket ettirmek için ihtiyacımız olan şey, her y pozisyonunu 40 ile toplamak. Bu durumda vertexler için yeni koordinatlarımız aşağıdaki gibi olacaktır.

Aynı sonuç, her bir verteksi bir satır ve dört sütundan oluşan bir matris gibi göstererek de alınabilirdi. Bu durumda aşağıdaki gibi üç tane matris elde ederdik:

İlk üç sütun vertex koordinatları, 1 de son sütun değeri olacak şekilde sıralanırdı. Ve bu matris özel bir matrisle çarpılarak, ki bu özel matris de vertex matrisinden translation transformation (çevirim dönüşümü) üretmek için oluşturulmuştur, her bir vertexin yeni koordinatları bulunabilirdi.

Sonuç matrisini hesaplamak için, ilk matrisin satırındaki her bir değeri almalı ve ikinci matriste karşılık gelen sütundaki her bir değer ile çarpmalıyız. Daha sonra bütün sonuçların toplamını işletmeliyiz. Bu durumda yukarıdaki örneğin hesaplanması aşağıdaki gibi olur:

Burada fazla detaya girmeden şunu bilmemiz yeterli olacaktır: Transformation(dönüşüm) matrisinin son satırına vereceğimiz değerler, vertex matrisindeki ilgili koordinat değerini(x,y,z) artıracaktır. Ayrıca, dönüşüm matrisindeki 1 değerini değiştirerek scaling(ölçeklendirme, boyutlandırma) yapabiliriz. Bu değerleri diyagonalden kesirliye çevirerek küçültme veya daha büyük değerler vererek objemizi genişletmemiz mümkündür. Veya herhangi bir eksen etrafında şekli döndürmek için sinüs ve kosinüs kombinasyonlarını bu matriste kullanabiliriz.

Şanslıyız ki programımızda dönüşüm kullanmak için bütün bu detaylara kafa yormak zorunda değiliz. Transformation(dönüşüm) yapabilmemiz için bilmemiz gerekenler:

• Dönüşüm matrisleri bilgi kaybetmeden birbirleri ile çarpılabilirler. Bir objeyi aynı anda çevirmek(translate) ve yönlendirmek(rotation) istersek, basit bir şekilde, translation(çevirim) matrisini yönlendirme(rotation) matrisi ile çarparız ve sonucu vertex matris(ler)imiz ile çarptığımızda istenen sonucu elde ederiz.

• Device objesi üç kullanışlı özelliğe sahiptir:

Birincisi projeksiyon matrisini getirmek için kullanılır:

.Transform.Projection ‘önceki konuda açıklanmıştır.

İkincisi 3D dünyamızda istediğimiz dönüşümleri göstermek için kullanılır:

.Transform.World ‘bu konuda açıklanmıştır.

Ve üçüncüsü de kamera pozisyonunu belirtmek için kullanılır:

.Transform.View ‘bu konuda açıklanmıştır.

• D3DX isimli kütüphane bütün dönüşüm(transformation) matrislerini oluşturmak için, matrislerin çarpımları için ve tanımlama(identity) matrisi döndürmek için birtakım fonksiyonlar içerir. (Tanımlama(identity) matrisi, World matrisini güncellemeden önce temizlemek için kullanılan, dönüşmemiş verteksler döndüren özel bir matristir.)

kaynak: Öğretim Görevlisi Murat Güneş

Managed Directx Bölüm - 4 3D Koordinat Sistemleri ve Projeksiyonlar

2008-04-15T10:54:00.000-07:00

3D Koordinat Sistemleri ve Projeksiyonlar

Üç boyutlu oyun yazmakla hiçbir ilişkimiz olmasa dahi 3D koordinat sisteminin temel konseptlerini anlamalıyız çünkü Direct 3D'de yaptığımız her şey 3D bir dünya içindeki noktalar ve şekillerle tanımlanmıştır. Elbette z değerini ihmal edebiliriz ve 2D bir dünyada olduğumuzu farz edebiliriz ama sıfır dahi olsa z değeri hala orada duruyor olacak.

Üç kartezyen boyutla çalıştığımız zaman iki tip koordinat sistemi kullanabiliriz: sol-el(left-handed) ve sağ-el(right-handed). Bu isimler, x ve y eksenine göre değişen z eksenini referans alır. bu pozisyonu tanımlamak için, bir elinizin parmaklarıyla x ekseninin pozitif yönüne işaret edin ve y ekseninin pozitif yönüne doğru, saat yönünün tersine hareket ettirin; z ekseni baş parmağınızın işaret ettiği doğrultu olacaktır. Baş parmağınızın işaret ettiği yön ise z ekseninin pozitif bileşenlerine işaret edecektir.

Farklı bir açıdan bakacak olursak, sol-el koordinat sisteminde, ekrandan uzaklaştıkça, z değeri pozitif yönde büyüyecektir(x ve y ekseninin ekranda kaldığını varsayarsak). Sağ-el koordinat sistemi de tam tersi şekilde; ekrandan izleyiciye doğru geldikçe z değeri pozitif yönde küçülecektir.

Direct 3D, sol-el koordinat sistemini kullanır, bu da z'nin pozitif değerinin göründüğü anlamına gelir ve negatif değerler görünmez(ta ki biz kamera pozisyonunu değiştirene kadar ki Direct 3D ile bu da mümkün).

3D koordinat sistemlerini anladıktan sonra sıradaki adım; bu sistemlerin 3D objeleri 2D ekranımızda nasıl gösterdiğini anlamaktır.

Şanslıyız ki bütün zor matematiksel işlemler DirectX tarafından yapılmakta ama projeksiyonların konseptini ve ekranda objelerin nasıl görüneceği ile ilgili temel bilgiyi DirectX'e nasıl adapte ettiklerini bilmeliyiz.

Direct 3D iki farklı projeksiyon tipini destekler;

• Perspektif Projeksiyonu:En yaygın kullanılan projeksiyon tipidir, z farkını hesaplayıp objeleri buna göre ayarlar. Bu projeksiyon tipi, ekrandan uzaklaşan objelerin daha küçük görünmesini sağlar -yani objeler gerçekte olduğu gibi deforme olurlar-. Düz bir yol üzerindeki kesikli şeritlerin ufukta birleşmiş gibi görüneceğini hatırlayın. Şekil 2 perspektif projeksiyonunu grafiksel olarak göstermektedir.

• Orthogonal Projeksiyon:Bu projeksiyon tipinde, z bileşeni ihmal edilmiştir ve ekrandan uzaklaştıkça, objeler küçülmez ya da yakınlaştıkça büyümez. Bu projeksiyon genellikle 2D oyunlarda veya basit 3D oyunlarda kullanılır.

Projeksiyon tipini tanımlarken, koordinat sitemi tipini seçmeli ve projeksiyonun tipine bağlı olarak birtakım parametreleri belirtmeliyiz. Direct 3D altı adet ana fonksiyon sunar(bunlardan dördü özel koordinat sistemleri oluşturmak içindir) ve bu fonksiyonlarla oyunumuz için seçtiğimiz projeksiyonu açıkça belirtmemizi sağlar. Bu fonksiyonlar, Direct 3D tarafından, 3D koordinatlardan ekran koordinatlarına yapılacak dönüşümü hesaplamak için kullanılmak üzere matrisler döndürür.

• Matrix.OrthoRH, Matrix.OrthoLH:Bir orthogonal projeksiyon tanımlamak için obje koordinatlarına uygulanması gereken dönüşümleri(transformations) içeren bir matris döndürür(RH =>Right-Handed,LH=>Left-Handed). Her iki fonksiyon da, ekranın genişlik ve yükseklik değerini ve gösterilecek olan z ekseni menzilini parametre olarak alır (ilk z değerinden önceki ve son z değerinden sonraki noktalar gösterilmeyecektir).
• Matrix.PerspectiveRH, Matrix.PerspectiveLH:Sağ ve sol-el koordinat sistemlerinde, belirtilen ekran genişlik ve yükseklik değerleri ile birlikte z ekseni menzilini(ilk ve son noktalar) parametre olarak alır ve perspektif projeksiyonu için dönüşüm(transformation) matrisi döndürür.
Matrix.PerspectiveFovRH, Matrix.PerspectiveFovLH:Sağ ve sol-el koordinat sistemlerinde, Fov'un(Field of view-görüntü alanı) radyan cinsinden açı değerini ve z ekseni menzilini parametre olarak alır ve perspektif projeksiyonu için transformation(dönüşüm) matrisi döndürür.

Managed Directx Bölüm - 3 Mesh ve Texture Yükleme

2008-04-15T10:50:00.000-07:00

Mesh ve Texture Yükleme

Bir C#.NET/Windows Application açtıktan sonra DirectX, Direct3D ve Direct3DX referanslarını projemize ekliyoruz. Ardından Editörde General Declerations kısmında using anahtar sözcüğü ile “Microsoft.DirectX” ve “Microsoft.DirectX.Direct3D” classlarına erişiyoruz. Öncelikle bir device hazırlamamız gerekiyor. Kodların hepsi aşağıdaki örnekte açıklanmıştır. Ayrıca kodlarda kameraguncelle isimli bir method var ve yön tuşları aracılığıyla kamerayı hareket ettirmenizi sağlayan birtakım matrix işlemlerini denetliyor. Onunla ilgili ayrıntılı bilgiyi de bir sonraki konu başlığında işleyeceğiz. Bu arada bir Class içerisinde bir device tanımlayıp onu farklı methodlarda kullanabilmek için device’ı “new” keywordu ile deklare ettiğimiz methodu, device’ı kullanacağımız diğer methodda handle etmemiz gerekiyor(Add Handler ile) tabi bu bir yöntem ve bu iş için başka yöntemler de var. Yazdığım örnek uygulamada bu yöntemi kullandım. 
Son olarak mesh ve texture yüklemek için;

Mesh mesh;
Texture texture;
mesh = mesh.FromFile("dosya.x", MeshFlags.SystemMemory, d3ddevice, materials);
texture = TextureLoader.FromFile(d3ddevice, "dosya.bmp");

Kaynak: Öğretim Görevlisi Murat Güneş

Managed Directx Bölüm - 2

2008-04-15T06:35:00.000-07:00

Bu bölümde Direct3D üzerine yoğunlaşacağız. Ve Direct3DX'in bazı yardımcı fonksiyonlarını göreceğiz.

Adapters

DirectX'te, sistemimizde kullandığımız adaptör ya da birden fazla ise adaptörler(örneğin ekstradan bir 3D Accelerator kartımız varsa) hakkında bilgi veren birtakım fonksiyonlar var. Hemen şunu da belirtelim managed DirectX ile unmanaged kullanım arasındaki en temel fark; .NET öncesi programlama dillerinde DirectX kullanmaya kalktığımızda yapmamız gereken ilk iş "DirectXn"(n=DirectX sürümü) tipinde bir master obje tanımlayıp diğer bileşenleri, vs. bundan türetmemiz gerekiyordu. Managed kullanımda ise yukarıda da belirttiğimiz alt nesneleri direkt olarak türetebiliyoruz. Her neyse... DirectX'te adaptörümüz hakkında bilgi edinmemizi sağlayan hazır bir fonksiyon var adı da "AdapterDetail". Kullanımı aşağıdaki gibi;

AdapterDetail adaptor_bilgisi;
int i;

For(int i = 0;i< Manager.Adapters.Count – 1,i++)
{
adaptor_bilgisi = Manager.Adapters(i).Information
MessageBox.Show (adaptor_bilgisi.Description)
}

Yukarıdaki kodda adaptörler hakkında bilgiyi getiren fonksiyonun yanında bir de Manager isimli, Direct3D ile ilgili temel işlemleri yerine getiren bir obje var.

Device

DirectX'in sunduğu özel bir nesne tipi "Device" 3D hızlandırıcı katmana erişmemizi sağlar. Her bir adaptör için üç Device tipinden birini seçmeliyiz. Bunlar;

- Hardware(Hardware Abstraction Layer):HAL(Donanım Soyutlama Katmanı) device türettiğimizde direkt donanım özelliklerine ve dolayısıyla da yüksek bir hıza erişiriz. Bu tip bir aygıtı türetirken sistemimizde 3D hızlandırıcı kartımız yoksa(ki yeni ekran kartlarının hepsi bu özellikte) DirectX hata verecektir.

- Reference(Reference Resterizer):Bu tip bir device türettiğimizde her şey software tarafından yapılacak ve türettiğimiz device donanım bağımsız olacaktır. Ancak bu tip bir Device ile oyun yazmayı aklınızdan bile geçirmeyin çünkü inanılmaz yavaş olacaktır( işlem hızı yaklaşık 1-5 fps arasında).

Device classından bir instance aldığımızda classın Constructor'ına girmemiz gereken parametreler sırasıyla aşağıdaki gibidir;

- Adapter:Burada Default adaptörümüzü kullanacağımızı belirtmek için Manager objesini kullanacağız.
- DeiceType:Amacımız bir oyun yazmaksa tabii ki Hardware seçilecek.
- WinHandle:Aygıtın sunum yapacağı pencerenin Handle'ı(Intptr.)
- Create Flags:Bir enumeration'dır. Seçilebilecek Flaglar aşağıdaki gibidir;
-SoftwareVertexProcessing:En ideal seçenek, DirectX'e bütün vertex hesaplamalarının Software tarafından yapılacağını bildirir. Bu seçenek en yavaş çalışan seçenektir ama her durumda kullanılabilir.
-HardwareVertexProcessing:Bu seçenek DirectX'in yazılım katmanında kullanılan Shading(gölgeleme) ve Lighting(ışıklandırma) işlemleri hariç tüm vertex işlemleri için donanımı kullanmasını sağlar.
-MixedVertexProcessing:İsminden de anlaşılacağı üzere en iyi performans için iki prosesin karışımını kullanır.
- PresentationParameters:Adından da anlaşılacağı gibi programcının device’ın sunumu için kullanabileceği birtakım ince ayarlar sunar. Sunduğu özellikler aşağıda açıklanmıştır;

- EnableAutoDepthStencil:Depth Buffer tabir edilen derinlik tamponu, Direct3D tarafından kullanılmak üzere derinlik bilgilerini saklayan bir Device özelliğidir. Bu konunun kavranması için derinlik algısı örneği geldi aklıma. Tek gözünüzü kapattığınızda, bakış açınıza göre, x ve y eksenleri aynı, z eksenleri farklı olan iki noktadan hangisinin size daha yakın olduğunu ayırt edemezsiniz. İşte size depth buffer’in yaptığı iş. Render edilen yüzeye yakın olan cisimler ile uzak olan cisimlerin ayırt edilebilmesi için gerekli z ekseni(derinlik) bilgilerini tutar. EnableAutoDepthStencil ise True ya da False değerlerini alır.
- AutoDepthStencilFormat:Depth Buffer’da kullanılan format. Bu format değeri geçerli bir depth buffer formatına setlenmelidir. Mesela “DepthFormat.D16” 16
bitlik bir depth buffer belirtir.
- BackBufferCount:1 ile 3 arasında değişen Back Bufferların numarası.
- BackBufferFormat: Format enumeration’u ile belirtilmiş her bir buffer’in formatı. Örneğimizde mevcut görüntü formatını kullanıyoruz. Burada girilen format stencil’de olduğu gibi geçerli bir format olmalıdır. Direct3D’nin CheckDeviceType methodu ile geçerli formatlar kontrol edilebilir. Windowed modda çalışılacaksa bu değere Unknown setlenerek mevcut görüntü ayarlarıyla çalışılabilir.
- BackBufferWidth ve Height:BackBuffer’in pixel cinsinden genişliği ve yüksekliği. Eğer windowed modda çalışılmıyorsa, bu değerler, CheckDeviceType methodu ile alınan görüntü formatlarından birisine uymalıdır.
- SwapEffect:Oyunun render edilme aşamasında back buffer’dan ekrana gönderilen her bir karenin(front buffer) oluşturduğu bir akış söz konusudur. Render methodumuz çağırıldığında ekrandaki görüntü bir önceki ile değiştirilir(swap). İşte bu değişim esnasında kullanılan SwapEffectleri; Dicard, Flip ve Copy efektleridir. Bunlar sırasıyla aşağıda açıklanmıştır;

o Discard:Bu efekt titpinde değiştirme işlemi(swap) sırasında back buffer’ın içeriği korunmaz. Bu yüzden her kare (frame) için içerik yenilenmelidir.
o Flip:Bu efektte bufferların ekrana aktarılması swap chain denilen bir değiştirme zinciri ile yapılır. Front bufferları(ekran) içeren döngüsel bir sıra gibi düşünülebilir. Bu sıra içerisinde back bufferlar sıfırdan n-1’e kadar numaralanırlar(n = back buffer sayısı). Bu sıralamada 0 numaralı back buffer en son gösterilendir. Döngü devam ederken front buffer(n-1) back buffer, back buffer(0) da front buffera dönüşür ve bu şekilde devam eder.
o Copy:Bu efektte ise back buffer’ın içeriği korunur. Back buffer’ın içeriği front buffer’ın üzerine kopyalanır.

- Windowed:True değerini aldığında pencere, false değerini aldığında da tam ekran modunda çalışılacağını belirtir. Pencere modunda çalışıldığında back buffer formatı arka plan çözünürlüğü ile aynı olmalıdır. Ben bunun için aşağıdaki yöntemi kullanıyorum;

gmodu = Manager.Adapters [Manager.Adapters.Default.Adapter].CurrentDisplayMode;
PresentParameters d3dpp = New PresentParameters();
d3dpp.BackBufferFormat = gmodu.Format;

Pencere modunda çalışırken BackBufferWidth ve Height parametreleri verilmek zorunda değildir. Tam ekran modunda ise width ve height parametreleri kullanılabilir bir ekran çözünürlüğü ile örtüşmelidir.
- DeviceWindowHandle:DirectX tarafından kullanılacak pencerenin handle’ı(Intptr).

Yukarıdaki hikaye kısmını anlattığımıza göre asıl işimize, yani .X dosyalarımızın ve texturelerimizin yuklenmesine gelelim. Burada amacım device, presentation parameters gibi bileşenleri ayarladıktan sonra .X dosyasını yüklemenin ne kadar kolay olduğunu göstermek. Bu amaçla directX’te kullanılan iki nesneden bahsedeceğim; “mesh” ve “texture”.

“mesh” ve “texture” nedir, nasıl kullanılır?

Mesh, DirectX’te ingilizcedeki anlamına yakın bir anlamda kullanılıyor. 3D animasyon yapanlar bilirler ki, yapılan çizimler ikiye ayrılır; katı modeller ve sadece yüzeylerden oluşan meshler. İşte kullanacağımız 3D modellerimiz bu, sadece yüzeylerden oluşan meshler yani .X dosyaları. Texture ise bu yüzeylere kaplanacak bitmap dosyaları.

Kaynak: Öğretim Görevlisi Murat Güneş

Managed Directx Bölüm - 1

2008-04-15T06:27:00.000-07:00

DirectX SDK

DirectX bilindiği üzere, Microsoft tarafından oyun geliştiricilerin hizmetine sunulmuş ileri düzey bir grafik API’sidir(Application Programming Interface). Bu API tamamen ücretsizdir ve Microsoft’un sitesinden indirilebilir. Piyasada kullanılan tek API DirectX değildir tabii ki. Onun en büyük rakibi yine ücretsiz olarak dağıtılan ve açık kodlu bir API olan OpenGL’dir (Open Graphics Language). OpenGL Silicon Graphics firmasının geliştirdiği bir API’dir. OpenGL ile yazılan oyunlara en güzel örnek olarak Quake serisi verilebilir.

DirectX iki farklı şekilde kullanılabilir. Birinci kullanım, DirectX ile yazılmış bir oyunu oynayabilmek için makineye DirectX Runtime(Debug veya Retail seçenekleri ile) kurulmasıdır. İkinci kullanım ise, ki bizi ilgilendiren kısım da budur zaten, Oyun geliştirirken DirectX API’sinden yararlanabilmek için DirectX SDK’nın makineye kurulmasıdır. DirectX 9.0 sürümü ile birlikte .NET ile kullanımının kolaylaşması için Managed Code sistemine geçti. Yani DirectX SDK’yı makinenize kurduktan sonra .NET içerisinden dll’leri(DirectX, Direct3D, Direct3DX vs.) projenize referans olarak göstermeniz yeterli.

İşe ilk olarak DirectX’in bileşenlerini tanıtmakla başlayalım.

Direct X Bileşenleri

-Direct3D(D3D):3D hızlandırıcı katmanına erişmek için kullanılır.
-Direct3DX(D3DX):Direct3D Extensions, Matrix Multiplications(matrix çarpımları) gibi kod yazma işlemini kolaylaştıran birtakım yardımcı fonksiyonlar sunar.
-DirectDraw:Aslında DirectDraw şu anda kullanılmayan bir teknoloji fakat eski oyunların da yeni DirectX sürümleriyle çalışabilmesi için hala barındırılıyor ve yenileştirme içermiyor. 2D oyunların geliştirilmesinde kullanılıyor.
-Direct Input:Input aygıtlarını denetlemede kullanılan bir directX bileşeni, Force Feedback özellikli joystickleri de destekliyor.
-DirectPlay:MultiPlayer oyunlar geliştirmek için kullanılıyor. Bilgisayarlar arasında hızlı ve güvenilir data transferi sağlıyor. Bilgisayarlar arası bağlantı P to P(Peer To Peer) olabileceği gibi Client Server mimarisi ile de yapılabiliyor. İşlem temeli TCP soketlerine dayanıyor.
-DirectAudio:Eski sürümlerinden gelen DirectMusic ve DirectSound isimli iki interface’i var. Aslında DirectAudio yeni bir arayüz değil sadece bu iki arayüzün birlikte kullanımını sağlıyor. Bununla beraber DirectX9.0’ın Managed kullanımı (.NET ile kullanımı) sadece DirectAudio'yu sunuyor.
-DirectShow:Ses ve videoları yakalama ve oynatma için kullanılan bir DirectX bileşeni. Ancak managed kullanımda sadece belli başlı özelliklerine erişebiliyoruz. Daha fazla detaya girebilmek için directX’i unmanaged kullanmalıyız.
-DirectSetup:DirectX içeren uygulamalarımızı paketlerken yardımcı olan bir bileşen.

Kaynak : Öğretim Görevlisi Murat Güneş

Xna da Mesh Yükleme

2008-03-25T06:48:00.000-07:00



XNA da ilk adımlar...

Mesh (3 Boyutlu nesne) xna ortamına nasıl eklenir, ekranda nasıl gösterilir, transformasyon işlemleri nasıl yapılır ?

Aşağıdaki linkte bu soruların cevaplarını bulabilirsiniz.

www.directxnedir.com

3ds max ' ta patlama sahnesi

2008-03-02T14:37:00.000-08:00

ALINTIDIR!!!

Not : ofisimde 3Dmax 3.1 var onunla yaptım. menülerde farklılıklar olabilir...
3dmaxte patlama sahnesi anlatmaya çalışacağım arkadaşlar...sahneye küre ekledim..tercih sizin..
Particles menüsünden "PArray Particle System" seçin..sahneye ekleyin. sonra sağ taraftan "pick object"
seçip patlatmak istediğiniz objeyi seçin..

ayarlarını yapıyorum... "Viewport display" menüsünde "mesh" seçili olmalı böylece nesnemiz kendi
parçalarına ayrılacaktır..yani noktalara ayrılmayacak...Particle Timing menüsünde "Emit Start" yazan yer patlamanın başlayacağı yeri gösterir. "Emit Stop" ise bitişini.. "Life" parçacıkların ekranda ne kadar süre kalacağını gösterir. Ben ayarlarımı şekildeki gibi yaptım. 10.frame de patlama başlicak...

Partical type menüsünden Object fragment seçtim ki nesne kendi parçalarına ayrılsın yani noktacıklar atmasın...

Object Fragment Controls menüsünde Thickness (Kalınlık) değerini biraz artırdım. Number of chunks işaretleyerek kendim bir değer girdim daha inandırıcı bir patlama olması için. parçalar daha da azaldı...Picked emitter altında get material from işaretledim. parçalar objeyle aynı dokuyu aldı...

şimdi geldik patlayan nesneyi patlamanın gerçekleştiği frame den sonra görünmez yapmaya...buraya kadar geldiyseniz farketmişsinizdir ki patlamanın olduğu 10. frameden sonra asıl nesne "Shape 1" hala ekranda... 0. frame e gelin "animate" butonunu tıklayın ve zaman cursorunu 10. frame kadar getirin.. sonra (animate butonu hala basılı) yapmamız gereken nesnemizin özelliklerine girerek görünmez yapmak. şu anda obje ile "parray obje" üst üste olduğu için seçmekte zorluk yaşayabilirsiniz. bu yüzden "select by name" tool ile nesneyi seçebilirsiniz. özelliklere girdikten sonra "visibility" değerini "0" yapın. okleyin ve animate butonunu kapatın. bu frameden sonra nesnemiz görünmeyecek...

işimiz henüz bitmedi...10.frameden sonra nesnemiz görünmeyecek ama şu an ilk framede de görünmüyor. bu yüzden az önce animate butonunu kullanarak oluşturuğumuz iki anahtar kareye müdahale edeceğiz. 0.framede oluşan keyframe sağ tıklayıp "Sphare 1 visibility" e tıklıyoruz ve şekildeki gibi değişikliği yapıyoruz. artık tamam. patlamamızı gerçekleştirdik.

şimdide sahnemize patlama efekti ekleyeceğiz. bunun için sahneye "sphere gizmo" ekledim ilk olarak patlayan objenin tam üstüne gelecek şekilde..rendering menüsünün altında "environments" işaretledim. açılan menüden add yazan yere tıklayarak "combustion" seçtim. "pick gizmo" yazan yere tıklayıp sahnedeki sphere gizmoyu seçtim. daha sonra environments menüsünün altındaki "explosion" yazan yeri işaretledim. karşınıza gelen kutucuk patlamanın hangi frame de başlayacağıdır. ben 12 seçtim..10.framede nesne patlamaya başlayacak 12. frameden itibaren ise alev başlayacak...en alttaki resimde render yaparken aldığım bi görüntü mevcut..seçenekleri değiştirerek farklı etkiler alabilirsiniz. kolay gelsin...

CRYSIS de MOD yapmak ...

2008-03-01T13:21:00.000-08:00

Artık sizde kısmen de olsa bir oyun tasarımcısı olabilirsiniz. :)
Yani bununla mümkün olmasada fikir kazanmış olursunuz :)

Crysis de ek mod yapın sizin tasarladığınız bölümler de oynansın ...
Oyun geliştirici olmak istiyorsanız böyle olanakları takip etmekte fayda var.
Mesela ben size mod yapımı için sunulan araçların oyunun yapımından önce kendilerine kolaylık sağlaması açısından oyun ekibi tarafından geliştirilip kullanıldığına inanıyorum.. Neyse fazla söze gerek yok SDK Paketini ve yeterli dökümanı bu siteden edinebilirsiniz. http://www.crymod.com

Bir kaç hazır Game Editor ...

2008-03-01T13:13:00.000-08:00

Crysis Game Play AMAZING GRAFICS

Bu editörün 2d ve 3d seçenekleri var...
Bu editör de 2d oyunlar için

Türk Oyun Projeleri - Hükümran Senfoni

2008-02-29T03:30:00.000-08:00

Hükümran Senfoni Oyun ekibi ve firma sahibi ile yapılan röportajlar...

Oyun Firmasının sitesi: http://www.ceidot.com/

Managed Directx de Create Device (Sürücüyü hazırlamak)

2008-02-28T14:00:00.000-08:00

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using Microsoft.DirectX;
using Microsoft.DirectX.Direct3D;

namespace Deneme
{
    public partial class Form1 : Form
    {
        Device device = null;

public Form1()
        {
            this.Text="Directx Create Device";
        }

public bool InitializeGraphics()
        {
            try
            {
                PresentParameters prs = new PresentParameters();
                prs.Windowed = true;
                prs.SwapEffect = SwapEffect.Discard;

device = new Device(0, DeviceType.Hardware, this, CreateFlags.SoftwareVertexProcessing,
                    prs);
                return true;
            }
            catch (DirectXException ex)
            {
                return false;
            }
        }

private void Render()
        {
            if (device == null) return;

device.Clear(ClearFlags.Target, Color.Blue, 1.0f, 0);

device.BeginScene();

device.EndScene();
            device.Present();
        }

static void Main()
        {
            using (Form1 f1 = new Form1())
            {
                if (!f1.InitializeGraphics())
                {
                    MessageBox.Show("Hata Oluştu!");
                    return;
                }
                f1.Show();

while (f1.Created)
                {
                    f1.Render();
                    Application.DoEvents();
                }
            }
        }
    }
}

XNA Örnek Projeleri

2008-02-28T02:22:00.000-08:00

Xna Console Uygulaması

DOWNLOAD-İNDİR

Path Finding in 2D

DOWNLOAD-İNDİR

Model Based Collision Detection

KAYNAK KODLARI

Deformable Levels

KAYNAK KODLARI

KEŞKE BU SİTE TÜRKÇE OLSAYDI www.ziggyware.com/

Microsoft XNA Game Studio Express 1.0 Refresh

2008-02-28T02:16:00.000-08:00

XBOX ve Windows ta Oyun geliştirmek için Microsoft firmasının acemi programcılara sunduğu güzel bir olanak... 

Fakat ben C++ ve DirectX ikilisini XNA dan daha performanslı buluyorum, XNA nın avantajı ise kolaylık sağlaması, yani biyerden başlamak lazım...

XNA yı indirdikten sonra şunlarda lazım olacak;

>Visual Studio 2005 veya Express Edition
>Net Framework 2.0

DOWNLOAD İÇİN TIKLAYIN

Delphix Oyun Örnekleri - 1 (ingilizce)

2008-02-28T01:52:00.000-08:00

Bu Döküman malesef ingilizce ama Delphi bilen arkadaşlar anlamakta zorlanmayacaktır..

Hello again! It has been a while but now I'm back! The last time we looked at how to create the isometrically tiled world. This time we will look at how to determine the position of the cursor and units. We will also go through basic animation of tiles. For this purpose a new set of graphics have been produced. You can get the whole package with source, graphics and the new converter at CodeCentral. If you don't have the source from my old article then you can download it here. This source is needed since we will be building on it this article. Ok, enough about that! Let's get to the topic.

THEORETICAL OVERVIEW
ANIMATION
Animating an image in DelphiX is a really simple task. The images supplied for this article have a little different look than the old ones. First of all I've expanded the number of tiles to 16. This makes the world more diverse, which is probably needed since the old ones were quite boring. Well anyway, three of these tiles are animated. If you open the bitmaps you will notice that the frames are placed side by side. Like this:



Of course it doesn't have the red borders and the numbers. When you load the bitmap into the DXImageList component, there are two properties called PatternHeight and PatternWidth. These are set to the height and width of a single frame. We can now, with the Pattern Number part of the Draw Method, decide which frame to show The first frame is number 0, the second frame number 1, and so on. By changing a variable every time the map is redrawn, we can get the frames to be shown one after the other and thus get an animated tile. Like this:



That is the basics of animation! Of course it gets more complicated when you animate units since they have different animations for different actions. But this is really all there is to it!

WORLD POSITIONING
Now this is the tricky part. On a screen the coordinate system is quite easy, it looks like this:


But this coordinate system doesn't work very well with the isometric tile. By rotating and skewing the coordinate system we get a more suitable coordinate system. Like this: 


In Delphi all positions are given according to the screen coordinate system. But the tiles use the isometric coordinate system or the world coordinate system which is the one in the second image. The hard part is converting between these two coordinate systems.

This is where those math classes you took come in handy. Finally, functions are really useful. (And, I don't mean functions as in programming.) A row of tiles is placed along, or follows, the function f(X)=0.46875X or f(X)=0.46875X depending on which axis. (Why all the decimals? Remember in the last article we used the tile height of 30, which divided by 64 is 0.46875. If we use 0.5 instead, which doesn't seem to be too much different, we will get a slight deviation in the positioning system. The cursor will start selecting tiles beside it, in some cases as many as three tiles in the wrong direction.) The X in these function refers to the screen coordinate system. These two functions look like this:



The shaded area is a value above and below the function that the tile is within. Where two shaded areas cross each other we have the shape of a tile. What we have to do in order to figure out which tile the cursor is in is to determine when the tile is inside the shaded area. So, if the Y value of the cursor is between -0.46875X+14 and -0.46875X-14 then the cursor is on the same WorldY as the tile. If the Y value is between 0.46875X+14 and 0.46875X-14 then the cursor is on the same WorldX as the tile. If both these happen at the same time then the cursor is on the tile (where the shaded areas cross). This is just for one tile. What about 100x100 tiles? This picture might give you an idea of how to solve this. 



First of all, every row is offset one tile height (30 pixels) from the one above. So, what we do is enumerate through all WorldX rows until we strike the right one. Then we take the number of that row and place it in the TileX Integer. Next, we enumerate through all the WorldY rows and place the right number in the TileY Integer. Finally, we return the two values to the main program. Now, the main program can use these values to get tile info, draw the marker, etc. Ok? Let's implement it in our tiling engine.

PRACTICAL IMPLEMENTATION
ANIMATION
First of all, delete all the old images from the image list and add the new ones. Do not add "Marker.bmp" at this point. For each image change these properties:

PatternHeight = 32
PatternWidth = 64


Place a new DXImageList on your form and call it Markers. Add "Marker.bmp" to this list. Then put this in the global declarations:

Frame: Integer;
TileX, TileY: Integer;


In the OnCreate event for the form add this:

Frame = 0;


And in the OnTimer event of the DXTimer add this:

if (Frame = 5) then
  Frame=0
else
  Frame = Frame + 1;
end;


And in the DrawTiles procedure we replace 0 with Frame in the calls to the Draw procedure. Like this:

TileMaps.Items[TileImage].Draw(DXDraw.Surface, 
  StartX + PosX + LoopX * 64, StartY + LoopY * 16, Frame);


Remember that this statement occurs twice in the DrawTiles procedure. Remember to change both, or you will have half your map not animating. Now save and test your program. You cannot use the old editor because of changes to the file structure. But you can download a converter from CodeCentral. This converter converts four-bit bmps to .map files. This way you can create a 50x50 pixel map in an image editor and save it as a 4bit (16 color) bitmap. And then convert it for use with the tiling engine. If your frame rate is too high then the animation may look bad. Just set Interval of the Timer to 33 to fix this. This will give you a frame rate of 30 fps. Well, that's all for animation! Now let's get to the hard part!

WORLD POSITIONING
First of all we need to make some declarations. Add this to the type declaration of TTile:

Marked: Boolean;


Also declare this procedure:

procedure CheckTiles(X, Y: Integer; var XTile, YTile: Integer);


Next create the procedure with this code in it:

procedure TMainForm.CheckTiles(X, Y: Integer; var XTile, YTile: Integer);
var LoopX, LoopY: Integer;
begin
  for LoopY := 1 to 50 do
  begin
    if (Y - ((0.46875) * (X - StartX) + StartY + (LoopY * 30)) < 15) and (Y - ((0.46875) * (X - StartX) + StartY + (LoopY * 30)) > (-15)) then
    YTile := LoopY;
  end;
  for LoopX := 1 to 50 do
  begin
    if (-(0.46875) * (X - StartX) + StartY + (LoopX * 30) - Y < 15) and ((-0.46875) * (X - StartX) + StartY + (LoopX * 30)- Y > (-15)) then
    XTile := LoopX;
  end;
end;


Then in the OnMouse move event of the DXDraw component add this:

Map.Map[TileX, TileY].Marked := False;
CheckTiles(X - 96, Y, TileX, TileY);
Map.Map[TileX, TileY].Marked := True;


This unmarks the old tile and marks the new one. Then add this line under the Draw function in the DrawTiles procedure. Be sure to add it under both function calls, as each one is just for half the map.

if Map.Map[XTile, YTile].Marked then
  begin
    Markers.Items[0].Draw(DXDraw.Surface, StartX + PosX + LoopX * 64, StartY + PosY + LoopY * 15 - 2, 0);
  end;


This draws a marker on the marked tile making it easier to see what tile is marked. Change this line in the OnTimer event:

Panel.Caption := 'FPS: ' + IntToStr(DXTimer.FrameRate);


to:

Panel.Caption := 'FPS: ' + IntToStr(DXTimer.FrameRate) + ' TileX: ' + IntToStr(TileX) + 'TileY: ' + IntToStr

DirectX Nedir?

2008-02-27T15:26:00.000-08:00

DirectX nedir?Windows, bilgisayarınızın çoklu ortam özelliklerini artıran DirectX 8.0'ı destekler. DirectX, görüntü ve ses kartlarınızın yeteneklerine erişim olanağı vererek, programların gerçekçi üç boyutlu (3B) grafikler ve derinlikli müzik ve ses efektleri oluşturmasına olanak sağlar. DirectX, Windows programlarına donanımla hızlandırılmış yüksek performanslı çoklu ortam desteği sunan bir dizi alt düzey Uygulama Programlama Arabirimi'nden (API) oluşur.

DirectX, programın bilgisayarınızın donanım yeteneklerini kolayca belirlemesine olanak verir, ardından da karşılık düşen program parametrelerini ayarlar. Bu, çoklu ortam uygulamalarının, DirectX uyumlu donanıma ve sürücülere sahip olan Windows tabanlı herhangi bir bilgisayarda çalışmasını sağlar ve çoklu ortam programlarının yüksek performanslı donanımdan sonuna kadar yararlanmasını güvence altına alır.

DirectX, 3B grafik hızlandırıcı yongaları ve ses kartları gibi yüksek performanslı donanımın gelişmiş özelliklerine erişim sağlayan bir API kümesi içerir. Bu API'ler, iki boyutlu (2B) grafik hızlandırma dahil alt düzey işlevleri denetler, oyun çubukları, klavyeler ve fareler gibi giriş aygıtlarını destekler ve ses karıştırma işlemini ve ses çıkışını denetler. Alt düzeyli işlevler, DirectX'i oluşturan şu bileşenler tarafından desteklenir:

Microsoft DirectDraw

Microsoft DirectDraw API, bilgisayarın video bağdaştırıcısının, hızlandırılmış donanım özelliklerine çok hızlı erişimini destekler. Tüm görüntü bağdaştırıcılar üzerindeki grafikleri görüntülemenin standart yöntemlerini ve hızlandırılmış sürücülerin kullanılması sırasında daha hızlı, daha doğrudan bir erişimi destekler. DirectDraw, belirli görüntüleme aygıtlarına, bunların yetenekleri hakkında kullanıcıdan ek bilgi alma gereği kalmadan, oyunlar ve 2B grafik paketleri gibi, programlar için aygıttan bağımsız bir yol ve dijital görüntü codec bileşenleri gibi Windows sistem bileşenleri sağlar.

Microsoft Direct3D

Microsoft Direct3D API (Direct3D), yeni görüntü kartlarının çoğunda yerleşik olan 3B oluşturma işlevlerine bir arabirim sağlar. Direct3D, hızlandırıcı donanımı ile verimli ve güçlü bir iletişim sağlamak için yazılım programlarına aygıttan bağımsız bir yol sağlayan alt düzey bir 3B API'dir. Direct3D, özel CPU yönerge kümeleri için destek içerdiğinden, görece yeni bilgisayarlarda daha büyük hızlanma sağlar.

Microsoft DirectSound

Microsoft DirectSound API, programlar ile ses bağdaştırıcısının ses karıştırma, ses çalma ve ses yakalama yetenekleri arasında bir bağlantı sağlar. DirectSound, çoklu ortam yazılım programlarına düşük gecikme süreli karıştırma, donanım hızlandırması ve ses aygıtına erişim sağlar. Bu özelliği, var olan aygıt sürücüleri ile uyumu sürdürerek sağlar.

Microsoft DirectMusic

Microsoft DirectMusic API, DirectX'in etkileşimli ses bileşenidir. DirectMusic, dijital ses örneklerini yakalayan ve çalan DirectSound API'sinden farklı olarak, hem dijital sesle, hem de ses kartınız veya kendi yerleşik yazılım birleştiricisi aracılığıyla dijital sese dönüştürülen ileti tabanlı müzik verileri ile çalışır. DirectMusic API, MIDI (Müzik Aleti Dijital Arabirimi) biçimine giriş desteği sağlar ve hem sıkıştırılmış hem de sıkıştırılmamış dijital ses biçimlerini destekler. DirectMusic, yazılım geliştiricilerine, derinlikli, yazılım ortamındaki çeşitli değişikliklere (şüphesiz bunların başında kullanıcı girdileri gelir) yanıt veren dinamik parçalar oluşturma olanağı sunar.

Microsoft DirectInput

Microsoft DirectInput API, oyunlar için gelişmiş giriş sağlar ve gerek oyun çubuklarından gerekse fare, klavye ve güç yansımalı oyun denetleyicileri gibi başka ilgili aygıtlardan gelen girdileri işler.

Microsoft DirectPlay

Microsoft DirectPlay API, modem, Internet veya Yerel Ağ üzerinden oyun bağlantılarını destekler. DirectPlay, iletişim hizmetlerine erişimi basitleştirir ve iletişim kuralından bağımsız olarak oyunların birbirleriyle iletişim kurmalarına veya çevrimiçi hizmete bir yol sağlar. DirectPlay, çok oyunculu oyunların başlatılmasını kolaylaştıran lobi hizmetleri sunar ve önemli oyun verilerinin ağda kaybolmamasını güvence altına almak için güvenilir iletişim kurallarını destekler. DirectPlay 8.0'deki yeni özellikler, çok oyunculu takım oyunlarının oynanabilirliğini önemli ölçüde artıracak olan, ağ üzerinden sesli iletişim desteğidir; böylece, oyunu oynayan öteki kişilerle konuşma olanağı sağlayarak, sosyal oyunlara yeni bir boyut getirmiştir.

Microsoft DirectShow

Microsoft DirectShow API, bilgisayarınızda ve Internet sunucularında yer alan çoklu ortam dosyaları için yüksek kalitede yakalama ve oynatma olanağı sağlar. DirectShow, ASF (Advanced Streaming Format), AVI (Audio-Video Interleaved), DV (Digital Video), MPEG (Motion Picture Experts Group), MP3 (MPEG Audio Layer-3), Windows WMA/WMV (Media Audio/Video) ve WAV dosyaları dahil olmak üzere çok çeşitli ses ve video biçimlerini destekler. DirectShow, video yakalama, DVD oynatma, video düzenlemeye ve karıştırmaya, donanımla hızlandırılmış video kod çözmeye ve analog ve dijital televizyon sinyallerinin alınmasına olanak sağlar.

Bir Oyunun Kısımları

2008-02-27T15:12:00.000-08:00

Bir video oyunu ,gerçekte, değişik eylemleri gerçekleştiren döngülerden meydana gelir. Programcılar, oyun programlamanın dünyasına girdiklerinde, nadiren; basit bir Pong veya Asteroid oyunu için bile gerekli olan tüm unsurları düşünür ve kolayca etkisi altına girebilirler. Bu muhtemelen olay-güdümlü yaklaşıma alışık olmadığnız anlamına gelir.

Şimdi başlığımıza, bir oyunun 7 aşamasına dönelim ve baştan sona bir dizi halinde yazıp bu evreleri açıklayalım.

Aşama I : Programı İlk Kullanıma Hazırlamak

Burası gösteriye başladığınız yerdir. Oyununuz için bir pencere oluşturur; kullanmak için DirectX kurulumunu gerçekletirir; grafikler, modeller ve diğer medyaları yükler, bellek tahsisi vs. birsürü eylemi gerçekleştirirsiniz.

Aşama II : Oyuna Başlamak

Bu aşama esasında oyununuzu oynanabilir kıldığınız kısımdır. Bu bir harita seçmek; oyuncunuzun konumunu belirlemek (ve herkesin) veya rasgele değerler atamak (mesela rasgele bir arazi) olabilir ki bunlar oyunun başlangıcına karar verirler.

Aşama III : Kullanıcıdan Girdi Almak

Bu aşamada klavye,mouse,joystick gibi; oyuncunun kullandığı kontrollerden tüm bilgileri alırsınız. Bu evre genel olarak DirectInput dersinde ele alınacaktır.

Aşama IV : Oyun Mantığı; Yapay Zeka ve Fizik

Bu aşamada dünyanızda neler olup bittiği önemlidir. Oyuncu tam olarak ne yapıyor? Hangi yöne gidiyor? Ne kadar mermisi kaldı? Gelen veya giden düşman var mı? Kendi ittifakları neler yapıyor? Bir düşmanla karşılaştığında her ikisinin tepkisi ne oluyor? Vs.vs… Tüm bunlar ve çok daha fazla olay bu aşamada ele alınır.

Aşama V : Grafik İşlemek (Render)

Bu aşama, DirectX ‘in en çok kullanıldığı aşamadır. Tüm 2D ve 3D grafikler ekrana işlenir. Bu kısım da Direct3D derslerinde ele alınacaktır.

Aşama VI : Tekrar (Restart)

Basitçe; 3.aşamaya döner ve herşey baştan,tekrardan yapılır.

Aşama VII : Temizlik (Cleanup)

Hafızayı (mem) mı çağırmıştınız? Bu sizin bellekteki herşeyi temizlemek için son şansınız; çünkü programınız sona ermek üzere J. Çeşitli arayüzler için gerçekleştirilen DX çağrıları da kapatılmış veya ‘bırakılmış (released)’ olmalı. İşte tüm bu temizlik bu aşamada gerçekleşir!

Peki, tüm bunlar nasıl bir araya gelirler? Belki farketmişsinizdir, yukarıdaki tüm aşamalar, ‘çıkış’ talep edilene kadar bir döngü içerisinde devam eder. Ayrıca yukarıdaki şemada tüm parçaların nasıl bir araya geldiğini gördünüz

Hiç kuşkusuz bu aşamaları, sadeleştirilmiş bir biçimde sizlere sadece hızlı bir ‘gözden geçirme’ olarak sunduk.Ağ, açılış ekranları (splash), animasyonlu bir menü,ses müzik ve dahasını sizler bunların üzerine ekleyebilirsiniz (ve ileride ekleyeceksiniz de). Bunların bir kısmı oldukça kolay.Örneğin bir açılış ekranını, bir dilim kek olarak düşünebilirsiniz; çünkü yapmanız gereken sadece programın başlangıcına bir pencere eklemektir!

Bazıları kolay olduğu gibi, bazıları da gerçekten çok daha fazla karmaşık bir hal alabiliyor. Network (ağ) gibi çoklu bilgisayar (oyuncu) olanağı sağlayan sistemleri örnek olarak verebiliriz.

Bu bölümü bu kadar uzattığımız yeter… Gelecek derste, bir Windows programının nasıl çalıştığını, basit bir pencere oluşturmayı ve basit oyun döngüsü planlamayı göreceğiz.

Buraya kadar henüz programlamaya elimizi sürmüş değiliz, ama artık nereden başlayacağımızı biliyoruz! Bu nedenle, artık dalışa geçebiliriz!

kaynak: pcreferans.com

Directx Vector Functions (Length, Degree)

2008-02-27T15:04:00.000-08:00

Bu Örnekte, C++ kodu yazarken sıkça kullanacağınız bir float -> char * convertion fonksiyonu

ile directX sınıflarında vector hesaplamaları yapmakta kullanacağınız:

Vector Uzunluk Hesabı için D3DXVec3Length

Vectorler arası açı hesabı için D3dXVec3Dot

Fonksiyonlarını örneklendirdim.

Oguz Bastemur 2007

#include "stdio.h"//sprintf fonksiyonu için

#include "windows.h"

#include "d3dx9.h"

char* Texts[5];

char *ToChar(char* q, float n)//float -> char* convertion

{

char *myc=(char*)malloc(20); 
sprintf(myc,"%s=%f",q,n);// sabit metin ve noktalı sayıyı tek bir satırda birleştiriyoruz

return myc; //Bu örneği dilediğiniz gibi şekillendirerek istediğiniz

} //biçim çevrimlerini yapabilirsiniz

void Load() 
{

Texts[0]="VECTOR 1: ( 10.0f, 5.0f, 5.0f)";

Texts[1]="VECTOR 1: ( 3.0f, 1.0f, 7.0f)";

D3DXVECTOR3 Vec1(10.0f,5.0f,5.0f);//Birinci Vector

D3DXVECTOR3 Vec2( 3.0f,1.0f,7.0f);//İkinci Vector

float Vec1Length=D3DXVec3Length(&Vec1);//Vector Uzunluğu hesabı

Texts[2]=ToChar("Vector1 Lenght is : ",Vec1Length);

float Vec2Length=D3DXVec3Length(&Vec2);//Vector Uzunluğu hesabı

Texts[3]=ToChar("Vector2 Lenght is : ",Vec2Length);

float dot=D3DXVec3Dot(&Vec1,&Vec2);// İki vector arası açı değerlendirmesi

if(dot==0)//0 ise 90 derece

Texts[4]="Degree Between 2 Vector is = 90";

else if(dot>0)//0'dan küçük ise 90 dereceden küçük

Texts[4]="Degree Between 2 Vector is < 90";

else if(dot<0)//0'dan küçük ise 90 derecen büyük

Texts[4]="Degree Between 2 Vector is > 90";

}

LRESULT CALLBACK WindowProc(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam)

{

switch(msg) 
{

case WM_DESTROY: 
PostQuitMessage(0);

break;case WM_PAINT: 
HDC hdc=GetDC(hWnd);

SetBkMode(hdc,TRANSPARENT);

for(int i=0;i<5;i++) 
TextOut(hdc,100,100+(i*20),Texts[i],strlen(Texts[i]));

}

return DefWindowProc(hWnd,msg, wParam,lParam); 
}

int WINAPI WinMain(HINSTANCE hInstance,HINSTANCE,LPSTR,int cmdShow) 
{

WNDCLASSEX wc;

ZeroMemory(&wc,sizeof(WNDCLASSEX));wc.cbSize=sizeof(WNDCLASSEX); 
wc.hbrBackground=(HBRUSH)COLOR_WINDOW;

wc.hCursor=LoadCursor(hInstance,IDC_ARROW);

wc.hInstance=hInstance;

wc.lpfnWndProc=WindowProc;

wc.lpszClassName="Pencere";

wc.style=CS_CLASSDC;

RegisterClassEx(&wc);

HWND hWnd=CreateWindowEx(NULL,"Pencere","D3DXVECTOR3",WS_OVERLAPPEDWINDOW,100,100,400,400,NULL,NULL,hInstance,NULL);

Load();

ShowWindow(hWnd,cmdShow);

UpdateWindow(hWnd);

MSG msg;

ZeroMemory(&msg,sizeof(MSG));while(msg.message!=WM_QUIT) 
{

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

TranslateMessage(&msg);

DispatchMessage(&msg);

}

UnregisterClass("Pencere",hInstance);

}

kaynak: directx.blog.com - Oguz Bastemur

Ogre3D Oyun Motoru

2008-02-27T14:10:00.000-08:00

Visual C++ ile çalışır.
SDK Paketi DOWNLOAD

C++ Puanlı Sayı Tahmin Oyunu

2008-02-27T14:01:00.000-08:00

#include<iostream.h>
#include<stdio.h>
#include<stdlib.h>
#include<windows.h>

int rasgele_sayiuret(int aralik)
{
srand(GetTickCount());
    int sayi=rand()%aralik;
    return sayi;
}

int puan_hesapla(int sayac)
{
int sonuc=(sayac+1)*20;
return sonuc;
}

void main()
{
int girilen_sayi;
int uretilen_sayi=rasgele_sayiuret(100);
cout<<"urt:"<<uretilen_sayi<<endl;
bool buldu=true;
int sayac=5;
int puan;

cout<<"Bir sayi giriniz :"<<endl;
cin>>girilen_sayi;
sayac--;

do
{
if((girilen_sayi>0)&&(girilen_sayi<=100))
{
if(sayac>=0)
{

if(girilen_sayi==uretilen_sayi)
{ 
char karar;
cout<<"Tebrikler, sayiyi buldunuz..."<<endl;
puan=puan_hesapla(sayac);
cout<<"***************"<<endl;
cout<<"* Puaniniz:"<<puan<<"*"<<endl;
cout<<"***************"<<endl;
cout<<"Tekrar oynamak istermisiniz? --> E / H"<<endl;
cin>>karar;
if(karar=='H'|| karar=='h')
{
buldu=false;
}
else if(karar=='E'|| karar=='e')
{
sayac=5;
uretilen_sayi=rasgele_sayiuret(100);
cout<<"urt:"<<uretilen_sayi<<endl;
cout<<"Bir sayi giriniz..."<<endl;
cin>>girilen_sayi;
}
else
{
cout<<"Gecersiz bir karakter"<<endl;
}
sayac--;
}
else if(girilen_sayi<uretilen_sayi)
{

if(sayac!=0)
{
cout<<"Buyuk bir sayi giriniz..."<<endl;
cin>>girilen_sayi;
}
sayac--;
}
else
{

if(sayac!=0)
{
cout<<"Kucuk bir sayi giriniz..."<<endl;
cin>>girilen_sayi;
}
sayac--;
}
}
else
{ 
char karar;
cout<<"Hakkiniz bitti..."<<endl;
cout<<"Tekrar oynamak istermisiniz? --> E / H"<<endl;
cin>>karar;
if(karar=='H'|| karar=='h')
{
buldu=false;
}
else if(karar=='E'|| karar=='e')
{
sayac=5;
uretilen_sayi=rasgele_sayiuret(100);
cout<<"urt:"<<uretilen_sayi<<endl;
cout<<"Bir sayi giriniz..."<<endl;
cin>>girilen_sayi;
sayac--;
}
else
{
cout<<"Gecersiz bir karakter"<<endl;
}
}
}
else
{
cout<<"Lutfen 1-100 arasinda bir sayi giriniz..."<<endl;
}
}
while(buldu==true);

cout<<"Devam etmek icin bir tusa basiniz."<<endl;
getchar();
}

Opengl-Glut İle Oyun Programlama

2008-02-27T13:51:00.000-08:00

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 de Yılan Oyunu

2008-02-27T13:47:00.000-08:00

#include<stdio.h>
#include<dos.h>
#include<conio.h>
#include<graphics.h>
#include<stdlib.h>
#include<bios.h>
#define X_LENGTH1 60
#define X_LENGTH2 580
#define Y_LENGTH1 70
#define Y_LENGTH2 400
#define RIGHT 19712
#define LEFT 19200
#define UP 18432
#define DOWN 20480
#define QUIT 283
void youlost(int);
struct SnakePart{
int fx;
int fy;
};
typedef struct SnakePart snakePart;
void drawPart(int x,int y,int color){
int i;
setcolor(color);
for(i=0;i<10;i++){
line(x,y,x+10,y);
y++;
}
}
void initialize(){
   int gdriver = 0, gmode = 0, errorcode;
   int bkcol;
   initgraph(&gdriver, &gmode, "..");
   errorcode = graphresult();
   if (errorcode != grOk){
      printf("Graphics error: %s
Press any key to halt:", grapherrormsg(errorcode));
      getch();
      exit(1);
   }
   cleardevice();
   setbkcolor(15);
   setcolor(4);
}
void printArea(){
char buf[80];
int y=40,i,j;
int x=57;
settextstyle(4, 0, 1);
sprintf(buf,"      S n a k e   1.0   b y    T a r i k    C ö r ü t");
outtextxy(x,y,buf);
setcolor(1);
for(j=Y_LENGTH1;j<Y_LENGTH2;j++)
line(X_LENGTH1,j,X_LENGTH2,j);
setcolor(4);
sprintf(buf,"P u a n:");
outtextxy(300,400,buf);
gotoxy(30,24);
while(!kbhit()){
gotoxy(30,24);
printf("Press any key to begin...");
delay(500);
gotoxy(30,24);
printf("                         ");
delay(500);
}
setcolor(1);
for(j=365;j<385;j++)
line(232,j,432,j);
setcolor(4);
}
void play(){
int x=100,puan=0;
int y=150;
int len=10;
int i,j,k=1,t;
int speed=200;
char buf[10];
snakePart yem;
int yon=RIGHT;
snakePart sp[50];
for(i=1;i<=len;i++){
drawPart(x,y,4);
sp[i].fx=x;
sp[i].fy=y;
x+=10;
}
drawPart(100,100,4);
yem.fx=100;
yem.fy=100;
while(1){
drawPart(sp[1].fx,sp[1].fy,1);//delete the first part of snake
for(i=1;i<len;i++){
sp[i].fx=sp[i+1].fx;
sp[i].fy=sp[i+1].fy;
}
if(yon==RIGHT){
sp[len].fx=sp[len-1].fx+10;
sp[len].fy=sp[len-1].fy;
}
else if(yon==LEFT){
sp[len].fx=sp[len-1].fx-10;
sp[len].fy=sp[len-1].fy;
}
else if(yon==UP){
sp[len].fx=sp[len-1].fx;
sp[len].fy=sp[len-1].fy-10;
}
else if(yon==DOWN){
sp[len].fx=sp[len-1].fx;
sp[len].fy=sp[len-1].fy+10;
}
else if(yon==QUIT)
exit(1);
else{
sp[len].fx=sp[len-1].fx+10;
sp[len-1].fy=sp[len-1].fy;
}
if(yem.fx==sp[len].fx&&yem.fy==sp[len].fy){
int a=rand()%52+6;
int b=rand()%33+7;
a*=10;
b*=10;
drawPart(a,b,4);
yem.fx=a;
yem.fy=b;
len++;
sp[len].fx=sp[len-1].fx;
sp[len].fy=sp[len-1].fy;
puan+=k;
k++;
sprintf(buf,"%d",puan);
setcolor(15);
for(j=400;j<420;j++)
line(400,j,500,j);
setcolor(4);
outtextxy(400,400,buf);
speed-=4;
}
if(sp[len].fx<X_LENGTH1||sp[len].fx>X_LENGTH2-10||sp[len].fy<Y_LENGTH1||sp[len].fy>Y_LENGTH2-10)
youlost(puan);
for(i=1;i<len-1;i++)
if(sp[len].fx==sp[i].fx&&sp[len].fy==sp[i].fy)
youlost(puan);
drawPart(sp[len].fx,sp[len].fy,4);
delay(speed);
if(kbhit()){
t=bioskey(0);
if(!(t==RIGHT&&yon==LEFT)&&!(t==LEFT&&yon==RIGHT)&&!(t==UP&&yon==DOWN)&&!(t==DOWN&&yon==UP))
if(t==QUIT||t==RIGHT||t==LEFT||t==UP||t==DOWN)
yon=t;
}
}//while
}
void youlost(int p){
char c=0;
closegraph();
while(1){
printf("Kaybettiniz.
Puaniniz %d
Tekrar oynamak ister misiniz? (y/n) :",p);
c=getch();
if(c=='y'){
initialize();
printArea();
play();
}
else if(c=='n')
exit(1);
}
}

void main(){
srand(time(NULL));
initialize();
printArea();
play();
}

kaynak: www.programlama.com

C# Opengl Kullanımı

2008-02-27T07:42:00.000-08:00

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 :

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.

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.

’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 :

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

2008-02-27T07:30:00.000-08:00

#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

2008-02-27T07:28:00.000-08:00

#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

2008-02-27T07:25:00.000-08:00

#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;

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

2008-02-27T07:07:00.000-08:00

#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();
}

Kontrol ifadeleri - if

2008-02-27T05:31:00.000-08:00

c# ta koşul ifadesini kullanarak programın bir parçasını seçerek çalıştırabilirsiniz...

if(kosul) ifade;

Burada kosul boolean (true=dogru, false=yanlis) deyimidir...

if (10 <>.WriteLine("10 büyüktür 9 dan"); }

Burada 10, 9'dan büyük ise ekrana "10 büyüktür 9 dan" yazdırır. Yani 10, 9'dan büyük olmasa ekrana yazdırma işlemi gerçekleşmezdi...

if Operatörleri ve Anlamları

Operatör Anlamı
--------- ---------
<>
<= Küçük veya eşittir
> Büyüktür
>= Büyüktür veya eşittir
== Eşittir
!= Eşit değildir

Örnek program:

using System;
class IfDemo {
public static void Main()
{
int a,b,c;

a=2; b=3;

if ( a < color="#009900">Console.WriteLine
("a küçüktür b den");
}

if ( a == b ) {
Console.WriteLine("a ile b eşit"); //bu ekranda
bişey göstermez çünkü a ile b eşit değil
}

c = a - b; // c -1 olur.

if ( c >= 0) { Console.WriteLine("c sıfırdan büyük veya eşit değil"); }
if ( c <>.WriteLine("c sıfırdan küçük değil"); }

c = b - a; // c 1 olur.

if ( c >= 0) { Console.WriteLine("c 1 dir. sıfırdan büyüktür"); }
if ( c <>.WriteLine("c sıfırdan küçük değil bu
yazı gözükmez"); }
}
}

İkinci Basit Programımız

2008-02-27T05:11:00.000-08:00

Aşağıdaki program x ve y adında iki değişken oluşturur:

using System;

class Ornek2 {
public static void Main() {
int x; //integer (Tamsayı) tipinde x ve y
değişkenleri int y;

x = 100; //x'e 100 değeri atandı.

Console.WriteLine("y değişkeninin değeri: "
+ x);
y = x / 2;

Console.WriteLine("y değişkeninin değeri (x in yarısı): " + y);

}
}

Vektör Hesaplamaları

2008-02-27T03:19:00.000-08:00

Bütün yazı ve diğer yazılar boyunca kulanılacak işaretler ve anlamları: Sqrt ->karekök alma Sqr -> karesini alma vektör -> vektörün boyu * ->çarpma . ->skaler carpım / ->bölme + ->toplama - ->çıkarma sayi ->mutlağını alma genelde vektör verirken A B diye adlandıracağım. Noktaları ise x1,y1,z1 x2,y2,z2 ....... olacak.

VEKTÖRLER

2 boyutlu duzlemde bir noktanın kordinatı x y eksenine göre belirlenirdi .3 boyut da da x y z eksenleri ile belirlenir. Nasıl ağırlık kg a göre değer buluyosa nasıl hiz m/s ile değer buluyosa 3d dede bi nokta xyz eksenine göre değer bulur örn) A noktasının yeri (3 birim x ekseninde 4 birim y ekseninde 5 birim z ekseninde gibi). Vektör sayının yanında doğrultusu (d doğrusu) ve yönü belli (kırmızı ile cizdiğim ok) bir büyüklüktür. örn)hiz, kuvvet vs. Vektörün konumunu örneklerimizde genellikle A vektörü A(x1,y1,z1) B vektörü B(x2,y2,z2) ile gösterilecek.

İKİ VEKTÖRÜN TOPLAMI

TOPLAMA ÇIKARMA İki vektörün toplamını veya farkını alırken ucuca ekleme metodu kulanabilriz. Şekildede görüldüğü üzere A vektörüne B vektörünü ekliyelim (toplayalım) A nın bitim noktasına B vektörünün başlangıcını getirip A vektörünün baslangıç noktasından B vektörünün bitim noktasına bir vektör çizersek bu vektör bize A+B vektörünü verir. Matematiksel eşiti ise Toplama A+B =R=((x1+x2),(y1+y2),(z1+z2)) Görüldüğü üzere A vektörü ile B vektörünün toplamı olan R vektörü bulunurken A vektörünün x konumu ile B vektörünün x konumu y ..y ,z…z toplanarak yapılıyor . Çıkarma A vektöründen B vektörünü çıkardığımızı düşünelim A vektörünü aynen alıyoruz çıkarılacak olan B vektörünün ise tersini alıp yukardaki uç uca ekleme metodunu kulanıyoruz. Bir vektörün tersi ise Aşağıdaki şekilde de görüldüğü gibi A vektörünün tersi A vektörünün x,y,z konumlarının ters işaretlisinin alınması ile elde edilir (yani -1 ile çarpma) A(x,y,z) ise A nın tersi A’(-x,-y,-z) dir örn( A(4,-4,-5) ise A’(-4,4,5) dir ) Cıkarma A-B=((x1-x2),(y1-y2),(z1-z2)) Bir vektörle aynı yöndeki k kat daha büyük bi vektörü ise =((x1*k),(y1*k),(z1*k)) olarak buluruz. Peki iki nokta arasındaki vektör nasıl bulunur Şimdi A noktasından B noktasına doğru bir AB vektörü düşünün (Aşağıdaki şekildeki gibi bu vektörün doğrultusu A dan B ye doğru ve boyu A noktası ile B noktası arasındaki mesafe kadardır. Şimdi önemli bir nokta var A noktasından B noktasına doğru ve B ye kadar bir vektör tanımlarken şu yolu izliyoruz orjinden A noktasına kadar bir A vektörü ve orjinden B noktasına kadar olan başka bir B vektörü düşünün şimdi bu iki vektör aşağıda görüldüğü gibi B vektöründen A vektörünü çıkarırsak AB vektörünü elde ederiz. Yani AB(x2-x1,y2-y1,z2-z1) (bu nun böyle olduğu zaten şekillerde gözükmekte) demekki herhangi bir A noktasından B noktasına doğru tanımlı vektör =B-A dır. Bir vektörün boyu ise x,y,z konumlarının karelerinin kare kökü dür. AB=B-A=sqrt(sqr(x2-x1)+sqr(y2-y1)+sqr(z2-z1)) Bunun isbatı da aşağıda gösterilmiştir. Örnek: Şimdi A noktasının kordinatlarına (1,2,2) diyelim B ninkilere ise (2,4,6) AB vektörü ise=B-A= ((2-1),(4-2),(6-2)) AB(1,2,4) bulunur. Bakın nokta ile vektörü birbirine karıştırmayın Nokta ile Vektör ayrı seylerdir mesela A(1,2,2) dedik bu A nın x ekseninde 1 konumunda Y ekseninde 2 Z eksenindede 2 konumunda bulunduğunu bildirir. AB vektörünü AB(1,2,4) bulduk peki bu ne anlama geliyo bir konummu tabiyki hayır bu AB vektörünün X ekseninde 1 birim Y ekseninde 2 Z ekseninde ise 4 birim lik şiddetinde olduğu anlamını taşır.

BİRİM VEKTÖR

Birim vektör boyu 1 birim olan vektördür. Birim vektörümüzü B(x0,y0,z0) diye adlandıralım. B=1 olmalı şimdi aşağıdaki şekle bakalım bir rastgele kordinatlarda alınmış bir A vektörü var ve bu A vektörü ile aynı yönde bir B birim vektörü (mavi ile çizdiğim) A vektörümüz A(5,-3,2) olsun. Peki B vektörünü nasıl buluruz. B birim vektörümüz A vektörünün x,y,z konumlarının A vektörünün boyuna bölünmesi ile bulunur. A=sqrt(sqr(5)+sqr(-3)+sqr(2))=6,164.. x0=Ax/A= x0=5/6.164=0.81 y0=Ay/A= 3/6.164=0.48 z0=Az/A= 2/6.164=0.32 B vektörünün boyunu hesaplattığımızda B=sqrt(sqr(x0)+sqr(y0)+sqr(z0)) =1 olduğunu görürüz. Peki bu birim vektör neye yarar? Birim vektör işlem kolaylığı sağlar. İlerdede göreceğimiz üzere bir çok işlemde vektörün boyu lazım olcak buda karekök ve karesi gibi uzun zaman alan işlemleri gerektiricek ama birim vektör kulandığımız zaman boy belli olduğu için (1) koddan ve zamandan kazanmış olcağız. A vektörü ile aynı yönlü herhangi bi vektör bulmak istiyoruz bunu nasıl yaparız? A(x1,y1,z1) vektörü ile aynı yönlü vektörümüz B(x2,y2,z2) olsun. B=k*A dir x2=k*x1 y2=k*y1 z2=k*z1 (B vektörü A vektörünün k katı) Örneğin A vektörümüz (2,4-2) olsun bunun anlamı A vektörü x=2 y=4 ,z=-2 yönünde demek B vetörümüz de bu A vektörü ile aynı yönlü k katı kadar bir vektör olsun. B=(2*k,4*k,2*k) olur k ya istenilen değer verilir. Cross Product Şimdi ise herhangi 2 vektöre dik olan başka bi vektörü bulalım. C (x3,y3,z3) dür A(x1,y1,z1) B(x2,y2,z2) dir. x3= y1* z2 - z1 * y2 y3 = z1* x2 -x1* z2 z3 =x1* x2- y1* x2 böylece C vektörümüzü bulduk. Nasılki 2d dede birim cember nekadar önemliyse ve kulanılıyorsa 3d dede okadar önemlidir. birim vektör = boyu bir birim olan vektördür. Vektör yönündeki birim vektör nasıl bulunur? vektörümüz A vektörü B de birim vektör olsun A(x1,y1,z1) B(x2,y2,z2) B=A/A dir. Yani x2=x1/A y2=y1/A z2=z1/A dir. Birim vektörün önemini ilerki derslerde daha iyi anlaycaksınız. İki vektörün skaler (sayısal) çarkılması A.B=x1*x2+y1*y2+z1*z2 Dot Product İki vektör arasındaki açının bulunması. A ve B vektörleri arasındaki açıya Q dersek Cos(Q)=A ile B vektörünün skaler çarpımı bölü A vektörünün boyu carpı B vektörünün boyu cos(Q)=A.B/A*B dir. arccos gibi bi fonkisiyonlada Q değeri bulunur (programlama diline göre değişir tabi ) Bir noktanın doğruya uzaklığı Elimizde yönü V vektörü ile belirttiğimiz ve üzerindeki herhangi bi noktası P olan d doğrumuz var. Birde bu doğruya olan uzaklığı bulunucak olan A noktamız. Doğru üzerinde bulunan P noktasından A noktasına kadar olan bir vektör düşünelim bu vektöre PA vektörü diyelim. A noktasının d doğrusuna uzaklığı A noktasının d doğrusuna olan dik uzaklığı demektir. Çünkü en kısa uzaklık(L uzaklığı) dik uzaklıktır. A noktasından d doğrusuna dik çıkarsak O noktasını buluruz. Şekil 1 Şekil 2 dede gördüğümüz üzere APO dik üçkeni oluşu bu üçgenin yardımı ile L uzaklığını bulcağız. Öncelikle Q açısını bulmamız lazım. Q açısı PA vektörü ve V vektörleri arasındaki açıdır. 2 vektör arasındaki açıyı bulmayı yukarda öğrenmiştik şimdi burada uygularsak Cos(Q)=PA.V/PA* V olcaktır. [}bNOT:[/b] Yukarda verilen formülde PA ve V birim vektör olarak verilseydi boyları 1 birim olacaktı yani PA=1 V=1 cos(Q) da= PA.V olcaktı görüldüğü gibi birim vektör olması işlem kolaylığı sağlar. Trigonometry den Sin(Q)=sqrt(1-sqr(cos(Q)) olur. Q acısının hem cosinusunu hemde sinusunu bulduk. Şimdi sin(Q) neye eşit APO üçgeninde Sin(Q)=karşı / hipotenüsten =L/PA dır. L=sin(Q)*PA olur Cos(Q)= komşu / hipotenüsten =K/PA dır. Şekil 2 K=cos(Q)*PA olur. İlere görceğiniz üzere K uzunluğu L uzunluğundan daha önemlidir. Çünkü birçok problemde O noktasını bulmamız gerekecek O noktasının yeri P noktasından V vektörü yönünde K uzunluğu kadar gitmekle elde edilir. L kullanmak istersek ayrrıca OA vektörününde yönünü bilmemiz gerekir. Şekil 3 Örneğin (Şekil 4) birim vektör kulanmanın faydalarından biraz daha bahsedelim. Örneğimizde P noktasının yeri P noktası=P(2,4,1), doğrunun yön vektörü olan V vektörü =V(2,1,2) olsun. O noktasınında P noktasına olan uzaklığı olan K noktasını da 5 bulduk diyelim. Bizden istenen O noktasının kordinatları O yu bulmak için ne yapıcaz? P noktasından V vektörü yönünde 5 birim gideceğiz. O=P+V*K diyelim şöyle bi bakınca formül doğru gibi gözüküyor. Doğru ama ufak bir püf nokta var. Yukardaki formül şöyle O noktası eşittir P noktasının yeri artı V vektörünün 5 katı. V nin 5 katını alalım. V nin 5 katı=V’(10,5,10) olan bi vektör elde ederiz. P dende bu vektör kadar gidersek O noktasının yeri O’x=2+10 O’y=4+5 O’z=1+10. Görüldüğü gibi O noktasının gerçek yerini bulamadık. Neden böyle oldu? Çünkü V vektörümüzün boyu 3 birim 5 katını alırsak boyu 15 birimlik bir vektör(10,5,10) elde ederiz. P dende 15 birim gitmiş oluruz. Biz ise 5 birim gitmek istiyoruz. Bunun içinse V vektörünün birim vektörünü bulmamız gerekir. V nin birim vektörünün boyu 1 olduğu için P+Birim(V)*5. Bizim gerçek O noktamızın yerini verir. P den V vektörü yönünde 5 birim gitmiş oluruz. Şekil 4 ÖNEMLİ Eğer PA.V sonucu + çıkıyorsa yani PA vektörünün izdüşümü(şekilde BP) V vektörü ile aynı yöndedir (1.durum) – ise ters yönlü(2.durum) 0 ise vektörler birbirine diktir. Vektörlerin döndürülmesi (XYZ Eksenine göre) Döndürülecek vektör A(x1,y1,z1) İlk durumda A vektörümüz x1,y1,z1 kordinatlarında bulunurken m ilk acıya sahip. Vektörümüzü Z ekseni etrafında Q kadar döndöndürdüğümüzü düşünelim. Dikkat edilirse z1 konumumuz her zaman sabit kalır, y ve z değerleri R yari caplı bir çember çizmektedir. ( tabi Q kadar döndürülünce çizmez. z ekseninde 360 derece döndürseydik çember çizerdi şimdiki (m+Q)/360 kadar bi cember) x1 in dönmeden önceki ilk değeri x1=R*cos(m). y1 ilk değeri y1=R*sin(m) dir. Şimdi Q kadar döndürünceki konumlara x2 ve y2 dersek (zaten z1 sabitti) x2=R*cos(Q+m) ve y2=R*sin(Q+m). Şimdi burda dikkat edilmesi gereken şu lisedeki trigonometri derslerinden hatırlayacağımız cos(a+b) ve sin(a+b) nin açılımıdır. Bu formülleri yukarıda uygularsak. x2=R*(cos(m)*cos(Q)-sin(m)*sin(Q)) x1=R*cos(m) ve y1=R*sin(m) demistik hatırlayın bunlarıda formulde yerine korsak x2=x1*cos(Q)-y1*sin(Q) olur. y2=R*(sin(m)*cos(Q)+cos(m)*sin(Q)) y2=y1*cos(Q)+x1*sin(Q) olur. Evet Z eksenine göre döndermeyi bulduk bu mantığını kavramanız içindi tabi diğer eksenlerin sonuclarını vereceğim. X ekseninde döndürme x2=x1 (çünkü X ekseninde çeviriyoruz) y2= y1*cos(Q)-z1*sin(Q) z2= z1*cos(Q)+y1*sin(Q) Y ekseninde döndürme y2=y1 (çünkü Y ekseninde çeviriyoruz) x2= x1*cos(Q)+z1*sin(Q) z2= z1*cos(Q)-x1*sin(Q)

kaynak: http://www.oyungelistir.org/

TÜRKİYE'DE DİJİTAL OYUN SEKTÖRÜ VE OYUN GELİŞTİRİCİLERİ PANELİ

2008-02-27T03:10:00.001-08:00

"TÜBİTAK-SOBAG 107K039 no'lu ve TÜBİTAK 2007/1 tarafından desteklenen "DİJİTAL OYUN KÜLTÜRÜ ve TÜRKİYE'DE GENÇLİĞİN INTERNET CAFE KULLANIM PRATİKLERİ" proje kapsamında 4 Mart 2008 tarihinde Türkiye'de Dijital Oyun Sektörü ve Oyun Geliştiricileri konulu toplantı Başkent Üniversitesi Avni Akyol Konferans Salonunda saat 15:00-17:30 arasında gerçekleşecektir. Ceidot-Ceiron Stüdyoları ekip olarak etkinliğe katılacaktır. Ceidot-Ceiron Stüdyoları ana projeleri Hükümran Senfoni Online üzerine sunum yapacak, Türkiye'de dijital oyun sektörünün mevcut durumunu ve geleceğini de tartışmaya açacaktır.

4 Mart 2008 tarihinde yapılacak etkinlik, Türkiye'de dijital oyun geliştiricilerin bir araya gelmesi ve endüstrinin durumunun değerlendirilmesi açısından oldukça önemlidir. Ayrıca çalışma grubu ve paneller kayıtlanarak, daha sonra konuyla ilgili akademik yayında değerlendirilmek üzere kullanılacaktır."

Başkent Üniversitesi basın bülteninden alıntıdır

YAPAY ZEKA NEDİR?

2008-02-27T03:05:00.001-08:00

“Yapay Zeka nedir ?” sorusunun cevabını ancak zekanın ne olduğunu tanımlayabilirsek verebiliriz.Zeka; öğrenme, anlama ve düşünme yeteneğidir. Yapay Zeka; kısaca tanımlarsak, bilgisayarların öğrenme, anlama ve düşünme yeteneğine sahip olmasıdır diyebiliriz.Yani bizdeki zekanın yapay hali.”Yapay Zeka” kuramı ilk kez bilgisayar bilimlerinde ortaya konulmuştur.Bunu derken şunu kastediyorum: öncelikle Y.Z., “yapay zeka” kuramı olarak ilk kez bilgisayar bilimlerinde ortaya çıktı.Fi tarihinde birileri Y.Z. fonksiyonunu gerçekleştirecek bir oluşumu düşünmüş ve hayal etmiş olabilir 1 .Y.Z.'nın küçük bir işlevini gerçekleştirmiş olabilir.Ama bu “yapay zeka” kavramının o zamanlarda ortaya çıktığını göstermez. Yapay Zeka kuramını her bilim adamı kendi araştırmaları neticesinde farklı bir kefeye koyabilmektedirler.Y.Z. için somut bir kılıf biçilemezken,Y.Z. kendini aşmaya çalışan bir alan haline gelmiştir.Bu alan, öyleki, bilgisayar bilimi doğduktan çok uzun süre geçmediği halde kendine çok ilgi toplayan ve geliştirilmesi için çok çaba sarfedilen bir alan olmuştur.Y.Z.' ye uygun bir kılıf biçilememesinin nedeni üretildiği zekanın da somut bir kefeye konulamamasındandır.”Peki niye bilimadamları, bu tam olarak saptanamayan ve anlaşılamayan insan zekasını bilgisiyarlarda simule etmek istiyorlar? “ sorusunun cevabı, bu bilim adamlarının bilgisayarın gerçekleştirmiş olduğu işlevin insanın gerçekleştirmiş olduğu işlev ile paralel veya aynı olduğunu zannetmelerindendir.Bunu açmak gerkirse;bu bilim adamları insanı bilgisayar gibi hesap yapıp bu hesaba göre hareket eden bir makine olarak görmektedirler.Kısacası bir “bilgi işleme sistemi” 2 olarak gördükleri insanı bilgisayarlara uyarlayabileceklerini düşünmüşlerdir.Bu düşüncenin yanlış olup olmadığı konusuna biraz değinmek istiyorum.öncelikle insan zekası tek bir nicelik ile ölçülemez.Eğer gerçekten zekayı öğrenme,anlama ve düşünme yeteneğinden ibaret diyorsak ki öyle diyoruz,o zaman insan zekası gruplandırılabilir diyebiliriz.Bu gruplandırma safhaları olarak size, ilgi ve kimilerinde doğuştan (kalıtımsal),kimilerinde sonradan kazanılan yetenek ve kabiliyet alanlarını örnek gösterebilirim.Her kişinin matematik zekası ile sosyal veya kültürel zekası bir olmaz.Aslında bunu iki kısımla sınrlandıramayız ama burda başlangıçta sayısal ve sözel olarak ikiye ayırmayı uygun görüyorum.Zaten bunu ilerde genişleteceğim. Her insanın sayısal ve sözel alanlara ilgisi,bu alanlardaki beceri ve kapasitesi farklıdır.Eğer aynı olsaydı ya herkes üstün zeki bir Einstein ya da herkes gerizekalı bir Bus-s-s-h olurdu.Sonuçta bizim yaradılıştan gelen ve sonradan çevre etkisiyle kazandığımız;belki doğuştan olup ama keşfedemediğimiz,ya da kullanmayıp körelttiğimiz;veya sonradan geliştirerek elde ettiğimiz bir özel yeteneğe sahip olabiliriz.Bu yetenek içerisinde tabiki zekamız en büyük etki alanı.Zeka bir yetenektir,diğer yeteneklerin de kazanılmasında büyük rol oynayan bir yetenek.Dolayısıyla bir zincir gibi düşünebiliriz.Zinicirin en büyük halkasını zeka oluşturmaktadır. kaynak:www.ceturk.com

Need For Speed Pro Speed

2008-02-27T03:04:00.001-08:00

2D Oyun Yapmak

2008-02-27T03:01:00.001-08:00

Artık Oyun Yapmak için bir "design+kodlayıcı " motorunuz var; RPG MAKER XP.

DOWNLOAD-İNDİR

GTA IV Nisan'da piyasalarda

2008-02-27T02:56:00.001-08:00

Oyun daha önce 16 Ekim 2007'de piyasaya sürülecekken takvim ileriye alınmıştı. Nintendo Wii oyun konsolu için de piyasaya sürülmesi beklenen oyunun PC sürümü ne yazık ki beklenmiyor.Rus aksanlı bir göçmen'in Amerika'ya gelmesi ile başlayan hikaye, etrafta dönen fragmanlarından anlaşılacağı üzere New York'un polisin bile girmeye korktuğu sokaklarında yine olabildiğine yasadışı işlere bata çıka mafya babası olmaya doğru giden çetrefilli yolda ayakta kalma üzerine dönecek.

Crysis lisansmanı Cevat Yerli ile Röportaj

2008-02-27T02:50:00.000-08:00

İlk c# programımız

2008-02-26T14:57:00.000-08:00

// İsim uzayları, yani kütüphaneler using System; using System.Collections.Generic; using System.Text; namespace ConsoleApplication1 { class Program { static void Main(string[] args) { Console.WriteLine("Merhaba C# !!!"); } } } Burada "//" işaretleri arasına yazılanlar derleyici tarafından dikkate alınmaz ve programın işleyişini etkilemez. Çünkü bunlar yorum satırlarıdır. örnekler: //Bu bir yorum satırı /* Bu birkaç * yarum * satırı */ Bu örnek bir console (msdos) uygulamasıdır ve Ekrana "Merhaba c# !!!" yazdırır. Önce her programda olduğu gibi gerekli isim uzayları "using" ile eklenir, daha sonra programımızın isim uzayı adı olan "ConsoleApplication1" ve ana sınıf "class"(Program) eklenir... Her yazdığımız c# programının bir ana fonksiyonu "Main" içine de programımızın ne iş yapacağını belirten kodlar yazarız... Kısa açıklama: Console.Writeline("string"); ekrana yazdırmak için kullanılır. // yorum satırıdır. static void Main() programın ana fonksiyonu