Oyun Programlama Seminerleri (5. Oturum)

About this playlist

9 videos
Total length: 1 hour, 26 minutes

Description: Sakarya Üniversitesi Bilgisayar Mühendisliği 3 Boyutlu Oyun Motoru Programlama Seminerleri 5. Oturumu
Oturum Konusu: OpenGL
Toplam Uzunluk: 01:30:30

Oyun Programlama Seminerleri (4. Oturum)

About this playlist

9 videos
Total length: 1 hour, 31 minutes

Description:
Sakarya Üniversitesi Bilgisayar Mühendisliği 3 Boyutlu Oyun Motoru Programlama Seminerleri 4. Oturumu
Oturum Konusu: Sayısal Sistemler ve Sistem Programlama
Toplam Uzunluk: 01:31:46

Drawing a Text on Screen in an OpenGL Application

Drawing a text on screen is a very general problem when you first start OpenGL. Conversely, it is simple to implement. I tried to make it possible with a little function as I show in the video above. Please note that it is required GLUT library to generate fonts. Do not forget to include to your project. I used SDL to manage Windows but it is optional for you.

Here is the code:

#include <stdlib.h>
#include <stdio.h>
#include <iostream>
#include <Windows.h>
#include <SDL.h>
#include <gl\GL.h>
#include <gl\GLU.h>
#include <glut.h>
#include <math.h>
#include <cstring>



#pragma comment(lib,"opengl32.lib")
#pragma comment(lib,"glu32.lib")


/*
 Drawing text 2D screen.
*/
void drawText(const char *text, int length, int x, int y){
 glMatrixMode(GL_PROJECTION); // change the current matrix to PROJECTION
 double matrix[16]; // allocate 16-byte in memory (thanks to BlueByteGames about memory-leak warning comment on YouTube)
 glGetDoublev(GL_PROJECTION_MATRIX, matrix); // get the values from PROJECTION matrix to local variable
 glLoadIdentity(); // reset PROJECTION matrix to identity matrix
 glOrtho(0, 800, 0, 600, -5, 5); // orthographic perspective
 glMatrixMode(GL_MODELVIEW); // change current matrix to MODELVIDE matrix again
 glLoadIdentity(); // reset it to identity matrix
 glPushMatrix(); // push current state of MODELVIEW matrix to stack
 glLoadIdentity(); // reset it again. (may not be required, but it my convention
 glRasterPos2i(x, y); // raster position in 2D
 for(int i=0; i<length; i++){
  glutBitmapCharacter(GLUT_BITMAP_9_BY_15, (int)text[i]); // generation of characters in our text with 9 by 15 GLU font
 }
 glPopMatrix(); // get MODELVIEW matrix value from stack
 glMatrixMode(GL_PROJECTION); // change current matrix mode to PROJECTION
 glLoadMatrixd(matrix); // reset
 glMatrixMode(GL_MODELVIEW); // change current matrix mode to MODELVIEW
}

void DrawScreen(SDL_Surface* screen, int h)
{ 
 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
 gluLookAt(0,0,-10, 0,0, 3, 0, 1, 0);

 glColor3f(1,0,0);

 glBegin(GL_LINES);
 glVertex3f(0,0,0);
 glVertex3f(1,0,0);
 glEnd();
 
 std::string text;
 text = "This is a simple text.";
 glColor3f(0, 1, 0);
 drawText(text.data(), text.size(), 50, 200);


 SDL_GL_SwapBuffers();
}

static void reshape(int width, int height)
{
 GLfloat h = (GLfloat) height / (GLfloat) width;
 glViewport(0, 0, (GLint) width, (GLint) height);
 glMatrixMode(GL_PROJECTION);
 glLoadIdentity();
 gluPerspective( 45.0, h, 1.0, 1000.0 ); 
 glMatrixMode(GL_MODELVIEW);
 glLoadIdentity();
}

SDL_Surface *surface;
int main(int argc, char **argv)
{

 if (SDL_Init(SDL_INIT_VIDEO || SDL_INIT_AUDIO)<0)
 {
  return 1;
 }

 surface = SDL_SetVideoMode(800, 600, 32, SDL_OPENGL | SDL_RESIZABLE | SDL_DOUBLEBUF);
 glShadeModel(GL_SMOOTH);
 glEnable(GL_DEPTH_TEST);
 glDepthFunc(GL_LEQUAL);

 glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);


 glLineWidth(1.5f);


 glMatrixMode(GL_MODELVIEW);

 reshape(800,600);
 SDL_Event event;

 int keypress = 0;
 int h=0; 

 while(!keypress) 
 {

  while(SDL_PollEvent(&event)) 
  {      
   switch (event.type) 
   {
   case SDL_QUIT:
    keypress = 1;
    break;
   case SDL_KEYDOWN:
    switch(event.key.keysym.sym){
    case SDLK_LEFT:
   
     break;
    case SDLK_RIGHT:
   
     break;
    case SDLK_UP:
    
     break;
    case SDLK_DOWN:
    
     break;
    default:
     break;
    }
   default:
    break;
   }

  }
  DrawScreen(surface,h++);
 }

 SDL_Quit();
 return 0;
}

Paralel Programlama ile PI Sayısının Hesaplanması

PI sayısı küçük yaşımdan beri bana hep gizemli gelmiştir. İrrasyonel yapıda olduğu için tam değeri hesaplanamayışı, bir çok matematiksel ve geometrik hesabın temelini oluşturması, çok eski medeniyetler tarafından kullanılmış olması insanın ister istemez ilgisini çekiyor. İnternetteki bir tanıma göre (bkz: wikipedia) "çapı 1 olan dairenin çevre uzunluğu" dur PI sayısı.

(bkz: http://tr.wikipedia.org/wiki/Dosya:Pi-unrolled-720.gif)

PI sayısının önemi hakkında daha fazla yazıp çizmek isterdim fakat bu yazının konusu dışında kalmaktadır. Asıl konumuz bu sayının yaklaşık değerini Paralel Programlama yöntemlerini kullanarak nasıl hesaplarız. Yaklaşık değerini dedim çünkü tam değerini hesaplayamayacağımızı artık biliyoruz. :) Bu sayı için hesaplayacağımız basamak sayısı yapmak istediğimiz işin büyüklüğüyle doğru orantılı. Arka bahçemizdeki havuzunuz kaç m^3 su aldığını hesaplamamız için 3.1415 değeri yeterken, Ay'a bir araç göndermek isteyen NASA mühendisleri için 3.1415926535 8979323846 2643383279 5028841971 6939937510 5820974944 5923078164 0628620899 8628034825 3421170679 8214808651 3282306647 0938446095 5058223172 5359408128 4811174502 8410270193 8521105559 6446229489 5493038196 4428810975 6659334461 2847564823 3786783165 2712019091 4564856692 3460348610 4543266482 1339360726 0249141273 7245870066 0631558817 4881520920 9628292540 9171536436 7892590360 0113305305 4882046652 1384146951 9415116094 3305727036 5759591953 0921861173 8193261179 3105118548 0744623799 6274956735 1885752724 8912279381 8301194912 9833673362 4406566430 8602139494 6395224737 1907021798 6094370277 0539217176 2931767523 8467481846 7669405132 0005681271 4526356082 7785771342 7577896091 7363717872 1468440901 2249534301 4654958537 1050792279 6892589235 4201995611 2129021960 8640344181 5981362977 4771309960 5187072113 4999999837 2978049951 0597317328 1609631859 5024459455 3469083026 4252230825 3344685035 2619311881 7101000313 7838752886 5875332083 8142061717 7669147303 5982534904 2875546873 1159562863 8823537875 9375195778 1857780532 1712268066 1300192787 6611195909 2164201989 3809525720 1065485863 2788659361 5338182796 8230301952 0353018529 6899577362 2599413891 2497217752 8347913151 5574857242 4541506959 5082953311 6861727855 8890750983 8175463746 4939319255 0604009277 0167113900 9848824012 8583616035 6370766010 4710181942 9555961989 4676783744 9448255379 7747268471 0404753464 6208046684 2590694912 9331367702 8989152104 7521620569 6602405803 8150193511 2533824300 3558764024 7496473263 9141992726 0426992279 6782354781 6360093417 2164121992 4586315030 2861829745 5570674983 8505494588 5869269956 9092721079 7509302955 3211653449 8720275596 0236480665 4991198818 3479775356 6369807426 5425278625 5181841757 4672890977 7727938000 8164706001 6145249192 1732172147 7235014144 1973568548 1613611573 5255213347 5741849468 4385233239 0739414333 4547762416 8625189835 6948556209 9219222184 2725502542 5688767179 0494601653 4668049886 2723279178 6085784383 8279679766 8145410095 3883786360 9506800642 2512520511 7392984896 0841284886 2694560424 1965285022 2106611863 0674427862 2039194945 0471237137 8696095636 4371917287 4677646575 7396241389 0865832645 9958133904 7802759009 değeri yetersiz ya da yanıltıcı olabilir. Bu yüzden sıradışı ihtiyaçlar için (fezaya mekik göndermek gibi) sıradışı çözümler sunmamız gerekmektedir. Bir gün NASA mühendisleri için PI sayısı hesaplarmıyız bilemiyorum fakat gelecekte çok fazla paralel işlem bizleri bekliyor. Şimdiden kendimizi hazırlamalıyız.

Lafı fazla dolandırmadan işe koyulalım. İlk PI hesabımızı Monte Carlo yöntemiyle yapacağız. Bu yöntem oldukça basit bir olasılık hesabına dayanmaktadır.



Bu olasılık hesabını yapmak için C++ programlama dili üzerinden openMP kütüphanesini kullandım. Paylaşımlı bellek üzerinden paralel programlama yapmak için geliştirilmiş olan bu kütüphane kullanması oldukça basittir. Mevcut kodunuza hiç dokunmadan (elbetteki paylaşımlı bellek paralel program mantığı güdülerek yazılmış kod olamalı) doğrudan programınızı paralel çalıştırabilirsiniz. Bu yazacağımız program dağıtık mimariler için değil tek bir süper bilgisayar için programlanmıştır. Makine üzerindeki çekirdek sayısıyla doğru orantılı olarak performans artışı sağlanacaktır.

Programımızı yazmadan önce Visual Studio 2010 üzerinden projemizin openMP desteğini açalım. Project -> Properties ...


(DÜZELTME)








Şimdi programımızı yazalım. Programda açıklamak istediğim tüm noktaları yorum satırı olarak ekledim. Bir göz atalım sonra sonuçları değerlendirelim.

/*
 Monte Carlo yöntemiyle PI sayısının yaklaşık değerinin hesaplanması.

 C++ / openMP

 Ramazan Bellek - Kasım 2010
*/

#include <iostream>
#include <ctime>
#include <math.h>

#define MAX_ITERATION 1000000 // tekrarlama sayısı
#define r 500 // yarıçap
#define R r*2+1 // çap + 1

int main(int argc, char **argv)
{
 srand(time(0));
 clock_t start = clock();

 bool iceride[MAX_ITERATION]; // doğruluk tablomuz
 double x,y;

 /*
  openMP ile birbirinden bağımsız olan hesaplama kısmını işlemciye paralel olarak işletiyoruz.
  x ve y değişkenleri her bir iş parçacığı için kişisel olarak tanımlandı, böylelikle bir iş parçacığı
  diğerinin konum bilgisini görememektedir. Doğruluk tablosunu belirten değişkeni ise ortak olarak
  kullanacaklardır.
 */
#pragma omp parallel for private(x,y) shared(iceride)
 for(int i=0;i<MAX_ITERATION; i++)
 {
  // uzayda bir noktayı (sözde) keyfi seçiyoruz.
  x = rand()%R;
  y = rand()%R;

  double fark = sqrt(pow(x-r,2)+pow(y-r,2)); // seçtiğimiz noktanın dairenin merkezine olan uzaklığını alıyoruz.

  if (fark<=r) // eğer bu uzaklık dairenin yarıçapından küçük ya da eşit ise nokta dairenin içerindedir.
   iceride[i]=true;
  else
   iceride[i]=false;
 }

 long toplamIceride = 0;
 // daire içerisine düşen toplam sayı 
 for(int i=0;i<MAX_ITERATION; i++){
  if (iceride[i]==true)
   toplamIceride++;
 }

 /*
  daire_icine_dusen/toplam = (pi*r^2)/(4*r^2)
         => pi = 4 * daire_icine_dusen/toplam
 */
   std::cout<<"PI ~= "<<4*(double)toplamIceride/MAX_ITERATION<<std::endl;

 printf("Gecen Sure: %f\n", ((double)clock() - start) / CLOCKS_PER_SEC);
 system("pause");
 return 0;
}

Programımızı çalıştırıyoruz.



Sonuç aslında pek istediğim gibi çıkmadı. Beklentim en azından ilk 4 basamağı (3.1415) bulmak üzereydi. İterasyonları arttırarak tekrar denenebilir, ayrıca burada ürettiğimiz rastgele sayılar sözde olduğu için bize tam bir sonuç vermesi beklenemez. İterasyonu arttırarak işlemcinin çekirdeklerindeki değişimi göstermek istiyorum.



Gördüğünüz gibi PI sayısını bir süper bilgisayarda nasıl hesaplayacağımızı basit olarak da olsa görmüş olduk. Daha detaylı görsel uygulama için http://www.eveandersson.com/pi/monte-carlo-demo adresindenki java applete göz atabilirler.

Bir sonraki paralel programlama yazımda paylaşımsız bellekli dağıtık mimari kullaranak PI sayısını hespalamaya çalışacağım. Küçük bir bilgisayar kümesi kurarak dev işlemleri basitleştirmeye çalışacağız. Gelecekteki bir bilgisayar ordusunun komutanı olmanız ümidiyle. Hoşçakalın...

Tic Tac Toe Oyunu - Yapay Zeka - MiniMax Algo.

Yapay zeka konusuna ilk girişi klasik Minimax algoritmasıyla yapıyorum. Algoritma çok basit ve etkili bir yöntem kullanmaktadır. Oyuncu bir hamle yaptıktan sonra diğer tüm oyunları oynayarak bilgisayarın en az kaybettiği en çok kazandığı hamle tespit edilmiş olur. Uygulamayı Python dilinde gerçeklemeye çalıştım. Doğası itibariyle %100 nesne yönelimli programlandı. Görsel arayüz için OpenGL (pyOpenGL) ve GLUT kütüphanelerini kullandım. Algoritma için daha detaylı bilgiyi http://en.wikipedia.org/wiki/Minimax adresinden edinebilirsiniz. İsterseniz programa ve kodların açıklamasına şöyle bir göz atalım, ardından kaynak kodu vereyim.

# -*- coding: cp1254 -*-


"""
MiniMax algoritmasını kullanarak Tic Tac Toe oyununun gerçeklenmesi

Sakarya Üniversitesi Bilgisayar Mühendisliği Bölümü
Yapay Zeka Dersi Ödevi

Ramazan Bellek - Ekim 2010


"""


from OpenGL.GL import *
from OpenGL.GLUT import *
from OpenGL.GLU import *
import time
import math
import copy
from Tkinter import *


# MiniMax algoritmasını gerçekleyen sınıf
class MiniMax:
    mevcutDurum = [[]]
    def __init__(self, mevcutDurum): # yapılandırıcı metod
        self.mevcutDurum = copy.deepcopy(mevcutDurum)

    # bilgisayarın bir sonraki yapacağı en mantıklı hareketi belirler
    def sonrakiHamleyiHesapla(self):
        tahta = self.mevcutDurum
        max = [[0 for satir in range(3)] for sutun in range(3)]
        for x in range(3):
            for y in range(3):
                if tahta[x][y] == 0:
                    tahta[x][y] = 1 # boş alana hamle yap
                    max[x][y] = self.__tara(tahta, 1) # alt ağaçları tara
                    tahta[x][y] = 0 # tarama bitince yapılan hamle geri alınır
                else:
                    max[x][y] = -99
        sonuc = -99
        donusDegeri = [0,0]
        for x in range(3):
            for y in range(3):
                if max[x][y]>sonuc:
                    sonuc=max[x][y]
                    donusDegeri = [x, y]
        return donusDegeri

    # alt oyun ağaçlarını tarar
    def __tara(self, t, s):
        tahta = copy.deepcopy(t)
        sonEl = copy.deepcopy(s)
        toplam = [[0 for satir in range(3)] for sutun in range(3)]
        for x in range(3):
            for y in range(3):
                if tahta[x][y] == 0:
                    tahta[x][y] = sonEl*-1
                    kontrolSonucu = Hakem.kontrolEt(tahta)
                    if kontrolSonucu != 5: # -> tahta henüz dolu değil!
                        return kontrolSonucu
                    toplam[x][y] = self.__tara(tahta, sonEl*-1)
                    tahta[x][y] = 0
        if sonEl == 1:
            return self.Min(toplam)
        else:
            return self.Max(toplam)

    # Katardaki azami değeri tespit eder.
    def Max(self, t):
        tahta = copy.deepcopy(t)
        deger = -99
        for x in range(3):
            for y in range(3):
                if tahta[x][y]>deger:
                    deger = tahta[x][y]
        return deger

    # Katardaki asgari değeri tespit eder.
    def Min(self, t):
        tahta = copy.deepcopy(t)
        deger = 99
        for x in range(3):
            for y in range(3):
                if tahta[x][y]                    deger = tahta[x][y]
        return deger
    
class Hakem:
    @staticmethod
    def bosMu(t):
        tahta = copy.deepcopy(t)
        for x in range(3):
            for y in range(3):
                if tahta[x][y] == 0:
                    return True
        return False
    @staticmethod
    def kontrolEt(t):
        tahta = copy.deepcopy(t)

        # oyuncu hamleleri --------------

        # yatay kontrol --
        if tahta[0][0] == tahta[1][0] == tahta[2][0] == -1:
            return -1
        elif tahta[0][1] == tahta[1][1] == tahta[2][1] == -1:
            return -1
        elif tahta[0][2] == tahta[1][2] == tahta[2][2] == -1:
            return -1
        # ----------------

        # dikey kontrol --
        elif tahta[0][0] == tahta[0][1] == tahta[0][2] == -1:
            return -1
        elif tahta[1][0] == tahta[1][1] == tahta[1][2] == -1:
            return -1
        elif tahta[2][0] == tahta[2][1] == tahta[2][2] == -1:
            return -1
        # ----------------

        # çapraz kontrol --
        elif tahta[0][0] == tahta[1][1] == tahta[2][2] == -1:
            return -1
        elif tahta[2][0] == tahta[1][1] == tahta[0][2] == -1:
            return -1
        # -----------------

        # ------------------------------------

        # Bilgisayar hamleleri --------------

        # yatay kontrol --
        if tahta[0][0] == tahta[1][0] == tahta[2][0] == 1:
            return 1
        elif tahta[0][1] == tahta[1][1] == tahta[2][1] == 1:
            return 1
        elif tahta[0][2] == tahta[1][2] == tahta[2][2] == 1:
            return 1
        # ----------------

        # dikey kontrol --
        elif tahta[0][0] == tahta[0][1] == tahta[0][2] == 1:
            return 1
        elif tahta[1][0] == tahta[1][1] == tahta[1][2] == 1:
            return 1
        elif tahta[2][0] == tahta[2][1] == tahta[2][2] == 1:
            return 1
        # ----------------

        # çapraz kontrol --
        elif tahta[0][0] == tahta[1][1] == tahta[2][2] == 1:
            return 1
        elif tahta[2][0] == tahta[1][1] == tahta[0][2] == 1:
            return 1
        # -----------------

        # ------------------------------------

        # Eşitlik durumu
        if Hakem.bosMu(tahta) == False:
            return 0
        return 5 # -> tahta henüz dolu değil!

class Tahta:
    """Oyun tahtası sınıfı"""
    tahta = [ [0 for satir in range(3)] for sutun in range(3)]
    siraBilgisayarda = False
    oyunBitti = False
    
    def __init__(self):
        oyunBitti = False
        self.ilkDefa = True

    def ciz(self):
        if self.oyunBitti == True:
            glColor(0.9, 0.6, 0.1)
            drawText("Oyun bitti... :|", 10 ,5 ,250, 250)
        elif self.ilkDefa == True:
            glColor(0.9, 0.6, 0.1)
            drawText("Oynamaya hazirim, lütfen bir hamle yapiniz... :)", 10 ,5 ,250, 250)
        else:
            glColor(0.9, 0.6, 0.1)
            drawText("Sizin siraniz ?", 10 ,5 ,250, 250)
            
        if self.ilkDefa == True:
            self.ilkDefa = False
        Tahta.cerceveCiz()
        self.__oyunCiz()
        

    @staticmethod
    def cerceveCiz():
        glLineWidth(2.5)
        glColor(0.0, 0.0, 1.0)
        glBegin(GL_LINES)
        
        # dış çerçeve ------------
        glVertex(-0.9, 0.9, 0.0)
        glVertex(0.9, 0.9, 0.0)
        glVertex(-0.9, 0.9, 0.0)
        glVertex(-0.9, -0.9, 0.0)
        glVertex(-0.9, -0.9, 0.0)
        glVertex(0.9, -0.9, 0.0)
        glVertex(0.9, -0.9, 0.0)
        glVertex(0.9, 0.9, 0.0)
        # -------------------------

        # ızgaralar ---------------
        glVertex(-0.3, -0.9, 0.0)
        glVertex(-0.3, 0.9, 0.0)
        glVertex(0.3, -0.9, 0.0)
        glVertex(0.3, 0.9, 0.0)
        glVertex(-0.9, -0.3, 0.0)
        glVertex(0.9, -0.3, 0.0)
        glVertex(-0.9, 0.3, 0.0)
        glVertex(0.9, 0.3, 0.0)
        # -------------------------
        glEnd()       

    def __xCiz(self, x, y):
        x =0.6*x-0.6
        y =-1*(0.6*y-0.6)
        glLineWidth(8.5)
        glColor(0.0, 1.0, 0.0)
        glBegin(GL_LINES)
        glVertex(x-0.175, y-0.175)
        glVertex(x+0.175, y+0.175)
        glVertex(x-0.175, y+0.175)
        glVertex(x+0.175, y-0.175)
        glEnd()

    def __oCiz(self, x, y):
        x =0.6*x-0.6
        y =-1*(0.6*y-0.6)
        glLineWidth(1.5)
        glColor(1.0, 0.0, 0.0)
        glPushMatrix()
        glTranslate(x, y, 0.0)
        glBegin(GL_LINES)
        for i in range(0, 1080):
            glVertex(math.sin(i)*0.2,math.cos(i)*0.2)
        glEnd()
        glPopMatrix()

    def __oyunCiz(self):
        for x in range(3):
            for y in range(3):
                if self.tahta[x][y] == -1:
                    self.__xCiz(x, y)
                elif self.tahta[x][y] == 1:
                    self.__oCiz(x, y)

    ''' tüm hamleler bu metod üzerinden gerçekleştirilir.
        kullanıcı girişleri bu metoda yönlendirilerek kullanıcının hamle yapması
        sağlanırken, her hamleden sonra öz yinelemeli olarak bilgisayar kendi hamlesini yapar.
        Yapacağı hamleyi MiniMax algoritmasınını kullanarak tespit etmeye çalışır.
    '''
    def oyna(self, x, y):
        try:
            if self.oyunBitti == True:
##                Mesaj.msj("Oyun bittiği için hamle yapamazsınız.","Üzgünüm... :(")
                return
            if x not in range(40, 760):
                return
            if y not in range(30, 560):
                return
            x = (x-40)/240
            y = (y-30)/176
            if self.tahta[x][y] == 0:
                if self.siraBilgisayarda:
                    self.siraBilgisayarda = ~self.siraBilgisayarda
                    self.tahta[x][y] = 1
                    self.ciz()
                    glFlush ()
                    glutSwapBuffers()
                    self.__kontrolEt()
                else:
                    self.siraBilgisayarda = ~self.siraBilgisayarda
                    self.tahta[x][y] = -1
                    self.ciz()
                    glFlush ()
                    glutSwapBuffers()
                    self.__kontrolEt()
                    if self.oyunBitti == True:
                        return
                    mm = MiniMax(self.tahta)
                    time.sleep(0.5)
                    xy = mm.sonrakiHamleyiHesapla()
                    self.oyna(xy[0]*240+40, xy[1]*176+30)
                    glutPostRedisplay()
        except:
            print "Beklenmeyen bir hata meydana geldi. Lütfen tekrar deneyiniz."
            raise
        
    def __kontrolEt(self):
        durum = Hakem.kontrolEt(self.tahta)
        if durum == 0:
            self.oyunBitti = True
            Mesaj.msj("Berabere bitti!", "Eşitlik durumu")
            glEnable(GL_LIGHTING)
            glutPostRedisplay()
            return

        # Bilgisayarın hamleleri --------------
        mesaj = "Bilgisayar kazandı! :/\nBiraz daha dikkatli olmalısınız..."
        if durum == 1:
            self.oyunBitti = True
            Mesaj.msj(mesaj, "Oyun bitti...")
            glEnable(GL_LIGHTING)
            glutPostRedisplay()
            return
        # ------------------------------------

        # oyuncu hamleleri --------------
        mesaj = "Tebrikler, siz kazandınız... :)"
        if durum == -1:
            self.oyunBitti = True
            Mesaj.msj(mesaj, "Oyun bitti...")
            glEnable(GL_LIGHTING)
            glutPostRedisplay()
            return
        # ------------------------------------
        if durum == 5: # -> tahta henüz dolu değil
            return

# Mesaj sınıfı ----
class Mesaj:
    root = None
    def __init__(self, root):
        self.root = root
    @staticmethod
    def msj(yazi, baslik):
        root = Tk()
        root.title(unicode(baslik, encoding="cp1254"))
        root.withdraw()
        mesaj = Mesaj(root)
        mesaj.top = Toplevel(root)
        Label(mesaj.top, text=unicode(yazi, encoding="cp1254")).pack()
        Button(mesaj.top, text="OK", command=mesaj.tamam).pack(pady=5)
        root.wait_window(mesaj.top) # pencere Tamam komutu verene kadar bekler.
        root.destroy()
    def tamam(self):
        self.top.destroy()
# -----------------

# Yazı yazma fonksiyonu (pyOpenGL - örneğinden alınmıştır!)
def drawText( value, x,y,  windowHeight, windowWidth, step = 18 ):
    value = unicode(value, encoding="cp1254")
    glMatrixMode(GL_PROJECTION);
    matrix = glGetDouble(GL_PROJECTION_MATRIX)
    glLoadIdentity();
    glOrtho(0.0, windowHeight or 32, 0.0, windowWidth or 32, -1.0, 1.0)
    glMatrixMode(GL_MODELVIEW);
    glPushMatrix();
    glLoadIdentity();
    glRasterPos2i(x, y);
    lines = 0
    for character in value:
        if character == '\n':
            glRasterPos2i(x, y-(lines*18))
        else:
            glutBitmapCharacter(GLUT_BITMAP_9_BY_15, ord(character));
    glPopMatrix();
    glMatrixMode(GL_PROJECTION);
    glLoadMatrixd(matrix)
    glMatrixMode(GL_MODELVIEW);
# --------------------------------
            
# uygulama giriş fonsiyonları ---------------

resX,resY = (800,600 ) # ekran çözünürlüğü
oyunTahtasi = Tahta() # tahta sınıfı

def goster( ): # openGL render fonksiyonu
    glutSetWindow(window);
    glClearColor (1.0, 1.0, 1.0, 1.0)
    glClear (GL_COLOR_BUFFER_BIT)
    oyunTahtasi.ciz()
    glFlush ()
    glutSwapBuffers()

def ayarla():
    ''' yumuşak çizim '''
    glShadeModel(GL_SMOOTH)
    glDisable(GL_LIGHTING)



def fare(button, state, x, y):
    if button == 0 and state == 1:
        oyunTahtasi.oyna(x, y)


if __name__ == "__main__":
    glutInit([])
    glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH)

    glutInitWindowSize(resX, resY) # pencere genişliği
    glutInitWindowPosition(0, 0)
    window = glutCreateWindow("Tic Tac Toe Oyunu / MiniMax Yapay Zeka Uygulaması - Ramazan Bellek | Ekim 2010")
    glutMouseFunc(fare)
    ayarla()

    
    glutDisplayFunc(goster)
    glutMainLoop()

Game Engine Programming

3 Boyutlu Oyun Motoru geliştirme seminerim önümüzdeki Salı günü (2 Kasım 2010) başlayacağını büyük bir mutlulukla duyurmak isterim :) Sau Bilgisayar Topluluğu bünyesinde gerçekleştilecek olan organizasyon için zaman 13:00~15:00 saatleri arası (D8 binası - sınıf henüz bana bildirilmedi) şeklinde düşünüldü. Ders yoğunluğuna bakarak en uygun zaman seçilmeye çalışıldı. Bu aralıkta dersi olan arkadaşlardan özür diliyorum. Eğer bir aksilik çıkmaz ise her salı bu seminerler düzenlenecek. Seminerlerle ilgili her türlü görüş ve eleştirilerinizi yorum olarak bu girdinin peşine bekliyorum.

Salı günü görüşmek üzere efendim. :)




-------02.11.2010------------------------------
İlk eğitimin başarılı geçtiğine inanıyorum. Katılan tüm arkadaşlara teşekkür ederim.
1. hafta sunum dosyasını buraya tıklayarak indirebilirsiniz.

Eğitimin bundan sonraki haftalarında tüm etkinliğin kameraya çekilmesi düşünülüyor. Ben de faydalı olacağına inanıyorum.

Haftaya aynı saatte görüşmek üzere.
-----------------------------------------------

-------09.11.2010------------------------------
İkinci hafta eğitim sunumları için:
sunum2
sunum3

sunumda kullanılan videolar:
Blender
Cry Engine 3
UDK

ayrıca sunumun bir kısmı video kameraya çekilmiştir. Görüntüler henüz elime ulaşmadı. Çekim yapan arkadaştan elde ettiğim zaman paylaşacağım.

Katılan herkese teşekkür ederim. Bayramdan sonraki hafta görüşmek üzere.

-------23.11.2010---------------------------------------
sunum4

Eğitim Videoları (YouTube)


Makine dilinde derleyicisiz yazdığımız uygulama.


--------------------------------------------------------



About this playlist

9 videos
Total length: 1 hour, 26 minutes

Description: Sakarya Üniversitesi Bilgisayar Mühendisliği 3 Boyutlu Oyun Motoru Programlama Seminerleri 5. Oturumu
Oturum Konusu: OpenGL
Toplam Uzunluk: 01:30:30

13. MÜSİAD Fuarı / CNR EXPO

2007 yılında Biltronik bilgi teknolojileri yarışmasında ödül kazandığım projemi tanıtmak üzere CNR EXPO 13. MÜSİAD Fuarı'nda kendim için ayrılan standa bulundum. Projemin gelişimini durdurmuş olsam da, standın arkasında olmanın zorluklarını anlama açısından faydalı bir deneyim olduğunu düşünyorum.

Java ile Nesneleri Dosyaya Kaydetme ve Okuma (Serialization)

Nesne yönelimli programlamada bellekte yüklü nesnelerin dosyaya kaydedilmesi ve tekrar dosyadan okunarak belleğe yüklenmesi olayına Serialization (Serileştirme olarak tercüme edilebilir) denmektedir.


Örneğimize geçmeden önce bu yöntem ile neler yapabileceğimizi değerlendirelim. Geliştirdiğimiz programlarda tüm işlemleri nesneler üzerinden gerçekleştiririz. Bazı durumlarda uygulamamızda kullanacağımız bilgileri bir dosya üzerinde saklamak isteyebiliriz. Bu noktada aklımıza veritabanı sistemleri gelebilir, fakat burada bahsettiğimiz veriler programın mantıksal verileri olduğu için genelde büyük boyutta olmazlar. Aynı zamanda nesnelerimizi veritabanında da tutabiliriz. Unutmamız gereken nokta Serialization dediğimiz olay nesnelerin hafızadaki yapısını ikili (binary) olarak saklamaktır. Neler yapılabilir sorusuna çok çeşitli cevaplar veribilir benim aklıma gelen şu başlıklar:
- Uygulamanın ayarlarının kaydedilmesi
- Basit bir veritabanı olarak kullanılması
- Programın çökmesi durumunda en son tutarlı yerden devam etmesi için hafızanın kaydedilmesi...

Normalde düşündüğümüz zaman bir nesneyi diskte saklamak çok külfetli bir iştir. Nesnenin tüm bilgilerini tek tek toplayıp bir sıraya koyacaksınız, ardından bunları karıştırmadan ve atlamadan (null değişkenler olabilir, ya da String benzeri dinamik genişleyen generic yapılar olabilir) doğru bir şekilde yazmalısınız. Okuma olayına hiç girmiyorum zaten. Ayrıca her nesnenin iç yapısı farklı olacaktır!

Peki hafızadan direk BYTE dizisi olarak diske yazmak? Java dilinde hafızaya direk erişimimiz olmadığı (işaretçilerin olamaması) için normal şartlar altında mümkün olmaması lazım. Fakat Java bize bu işlemi çok kolay bir şekilde yapacak bir imkan sağlamaktadır.

Java'da yazılan tüm nesneler Serializable arayüzünden (interface) kalıtım aldığı sürece sorunsuz bir şekilde diske yazılabilmektedir. Aynı rahatlıkla diskten okunabilmektedir. Bunun için özel olarak hazırlanmış yazan ve okuyan sınıfları kullanmaktadır.

Lafı fazla dolandırmadan örneğimize geçelim. Yorum satırlarını yeterli gördüğüm için tekrardan açıklama gereği duymadım.

/*
 * Öğrenci Sınıfı
 * Ogrenci.java
 */

package rbellek.blogspot.com;

import java.io.Serializable;

/**
 *
 * @author Ramazan
 */
public class Ogrenci implements Serializable {

    private String isim;

    public String getIsim() {
        return isim;
    }

    public void setIsim(String isim) {
        this.isim = isim;
    }
}


/*
 * Serilazation Örnek
 * Main.java
 */
package rbellek.blogspot.com;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 *
 * @author Ramazan
 */
public class Main {

    public static void main(String[] args) {
        Ogrenci o1 = new Ogrenci(); // Yeni bir öğrenci nesnesi oluşturalım.
        o1.setIsim("Ahmet"); // İsmini verelim.
        System.out.println(o1.getIsim()); // Test edelim.
        try {
            // Nesneyi dosyaya kaydedelim.
            FileOutputStream yazmac = new FileOutputStream("Ogrenci1.nesne"); // Dosyaya veri aktarım akışı nesnesi oluşturalım.
            ObjectOutputStream nesneYazmac = new ObjectOutputStream(yazmac); // Nesneleri veri akışlarına yazmaya yarayan nesneyi oluşturalım.
            nesneYazmac.writeObject(o1); // Öğrenci nesnemizi dosyaya yazıyoruz.
            nesneYazmac.close(); // akışı kapatalım.
        } catch (FileNotFoundException ex) {
            Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
        } catch (IOException ex) {
            Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
        }

        o1.setIsim("Mehmet"); // Öğrenci nesnemizin adını değiştirelim.
        System.out.println(o1.getIsim()); // Test edelim.

        Ogrenci o2 = null; // Başka bir öğrenci nesnesi referansı. (Henüz bir nesne oluşturmadık!)

        try {
            FileInputStream okuyucu = new FileInputStream("Ogrenci1.nesne"); // Dosyadan veri alan akış nesnesi.
            ObjectInputStream nesneOkuyucu = new ObjectInputStream(okuyucu); // Dosyada kayıtlı nesneleri okuyan nesne.
            o2 = (Ogrenci) nesneOkuyucu.readObject(); // Öğrenci nesnemizi okuyalım.
            nesneOkuyucu.close(); // akışı kapatalım.
        } catch (FileNotFoundException ex) {
            Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
        } catch (IOException ex) {
            Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
        } catch (ClassNotFoundException ex) {
            Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
        }

        System.out.println(o2.getIsim()); // Okunan nesne adı Ahmet olmalı...
    }
}

İyi çalışmalar...

Ford OTOSAN - jQuery Sunumu

Bünyesinde çalışmakta olduğum Ford OTOSAN firması Bilgi İşlem merkezinde geçtiğimiz günlerde jQuery JavaScript kütüphanesi hakkında genel bilgi ve tanıtım amacıyla bir sunum yaptım. Sunumda bahsettiğim uygulamaları video olarak hazırladım.


Genel hatlarıyla sunum içeriğinden bahsetmek gerekirse;

• jQuery Nedir?


• Kimler Kullanıyor?


• Lisans ve Kullanım Koşulları


• jQuery Kullanmak için 3 Temel Sebep


• Kimlere Hitap Ediyor?


• Kurulum Aşamaları


• Temel Taşları


• Basit Ajax İşlemleri


• Asp.NET Web Formlar ve Web Servis Entegrasyonu


• jQueryUI ile Etkileşimli Görsel Arayüzler


• Eklenti Desteği

jQuery Sunum Dosyaları

• Portable Document File - PDF


• Microsoft Office PowerPoint File - PPT


• Open Office Presentation File - ODP

Uygulama Videoları

• Tüm Videolar

Spring Framework - Web MVC / NetBeans 6.8 / Bölüm 2

Not: Bu yazı Spring Framework - Web MVC / NetBeans 6.8 adlı yazının devamı niteliğindedir.

Bir önceki yazımda kaldığım noktadan devame etmeye çalışacağım. Giriş yazımda bir Spring Web MVC projesini NetBeans 6.8 ile oluşturmuştuk. Şimdi yapıyı incelemeye devam edeceğiz. WEB-INF dizini altındaki ayar dosyalarını inceleyerek devam edelim.


İlk olarak Web.xml den biraz bahsetmek istiyorum. Bu dosya Java Web projelerinde genel ayarların yapıldığı standart bir dosyadır. Tıpkı Asp.NET projelerindeki Web.config dosyası gibi. Arzu ederseniz içeriğine bir gözatalım.

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>/WEB-INF/applicationContext.xml</param-value>
    </context-param>
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
    <servlet>
        <servlet-name>dispatcher</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <load-on-startup>2</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>dispatcher</servlet-name>
        <url-pattern>*.htm</url-pattern>
    </servlet-mapping>
    <session-config>
        <session-timeout>
            30
        </session-timeout>
    </session-config>
    <welcome-file-list>
        <welcome-file>redirect.jsp</welcome-file>
    </welcome-file-list>
</web-app>

İlk bakışta göze batan karmaşıklık sizi korkutmasın. Aslında anlaması gayet basit. Burada XML formatında ayarlar mevcut. Şimdilik bu dosya salt okunur gibi olmalı. Buradan herhangi bir ayarı değiştirmeyelim. Aksi takdirde uygulamamız doğru çalışmayabilir. Fakat anlamadan da geçemeyiz. Eğer bu detayları iyi kavramazsak, frameworke tam olarak hakim olamayız. context-param kısmında projemiz için içerik ayarlarının yapıldığı düğümdür. Buraya contextConfigLocation adında bir anahatar ve /WEB-INF/applicationContext.xml şeklinde bir değer girilmiştir. Bu dosya Spring projemizde yapacağımız bazı ayarların (veritabanı bağlantı cümleleri vb.) bulunacağı dosya. listener düğümünde dinleyici sınıfları belirtiyoruz. Değer olarak org.springframework.web.context.ContextLoaderListener sınıfı eklenmiş. Daha sonra bir servlet tanımlanmış. dispatcher adındaki bu servlet Spring'in temel çözümleme servlet sınıfıdır. Sınıfın yolu org.springframework.web.servlet.DispatcherServlet şeklinde eklenmiş. servlet-mapping düğümü ile hangi servlet hangi desenle (örüntü - pattern) eşleceği belirtiliyor. dispatcher servleti için *.htm şeklinde bir desen verilmiş. Daha önceki yazımda belirtiğim noktaya geldik. Kullanıcı web tarayıcısıyla web sunucumuza *.htm şeklinde bir sorgu yaptığı zaman web sunucumuz bunu anlayarak ilgili servleta (burada dispatcher oluyor) yönlendirecektir. Son olarak welcome-file-list düğümü ile sitemiz ilk açılışta hangi sayfayı direk gösterecek onu belirtiyoruz. Örneğin Apache web sunucusunda varsayılan karşılama dosyası index.html, index.htm ya da index.php, IIS sunucusunda default.html, default.htm, default.asp ya da default.aspx şeklinde olabilir. NetBeans otomatik olarak redirect.jsp dosyasını seçmiş. Bu kısmı dilediğiniz gibi (desene uygun bir URL ile) edeğiştirebilirsiniz.



NetBeans Web.xml için görsel ayar penceresi

Şimdi gelelim dispatcher-servlet.xml dosyamıza. Bu dosya Web.xml dosyasında belirtiğimiz dispathcer servlet sınıfı için ayar niteliğindedir. Vakit kaybetmeden içeriğine bir göz atalım.

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
       http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">
    
    <bean class="org.springframework.web.servlet.mvc.support.ControllerClassNameHandlerMapping"/>
    
    <!--
    Most controllers will use the ControllerClassNameHandlerMapping above, but
    for the index controller we are using ParameterizableViewController, so we must
    define an explicit mapping for it.
    -->
    <bean id="urlMapping" class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
        <property name="mappings">
            <props>
                <prop key="index.htm">indexController</prop>
            </props>
        </property>
    </bean>
    
    <bean id="viewResolver"
          class="org.springframework.web.servlet.view.InternalResourceViewResolver"
          p:prefix="/WEB-INF/jsp/"
          p:suffix=".jsp" />
    
    <!--
    The index controller.
    -->
    <bean name="indexController"
          class="org.springframework.web.servlet.mvc.ParameterizableViewController"
          p:viewName="index" />
    
</beans>

İlk baştaki uzun tanımlamaları direk atlıyorum. Şimdilik bu ayarlar konumuz değil. Olduğu gibi bırakıyoruz.

bean tagıyla başlayan satırda yeni Spring bean sınıfını (org.springframework.web.servlet.mvc.support.ControllerClassNameHandlerMapping) tanımlıyoruz. Alt satırdaki yorum bu satırları anlamamız için önemli. Yorum satırında bu eklediğimiz sınıfın (ControllerClassNameHandlerMapping) bir çok kontrollör sınıf tarafından kullanıldığından fakat indexController sınıfı için ParameterizableViewController sınıfının kullanıldığını bu yüzden harici bir rota belirlememiz gerektiğinden bahsetmektedir.
Bir alt satırda org.springframework.web.servlet.handler.SimpleUrlHandlerMapping sınıfının tanımlanmasıyla görebiliyoruz. Verdiği değerler önemli. index.htm şeklinde gelen bir isteğin indexController nesnesi tarafından yorumlanacağı bu satırda belirtilmektedir. Siz burayı dilediğiniz gibi değiştirebilirsiniz. Örneğin merhaba.htm yapabilirsiniz. Dikkat etmeniz gereken bir nokta olarak dosya uzantısı .htm olaması söylenebilir. Unutmayalım Web.xml dosyasında dispatcher servlet için *.htm şeklinde bir desen belirlemiştik. Buna uymak zorundayız.
Bir sonraki satırda viewResolver sınıfının tanımlandığını görüyoruz. Bu çok önemli özellikle yapıyı idrak etme hususunda. class="org.springframework.web.servlet.view.InternalResourceViewResolver" Spring'in dahili kaynak görüntü çözümleyici sınıfı. p:prefix="/WEB-INF/jsp/" ve p:suffix=".jsp" satırları dışardan gelen istekleri uygulamamızın iç yapısında nereye karşılık geldiğini gösterir. prefix (öntakı) değeri ile görüntülerin dizinini suffix(son ek) ile yerel dosyaların uzantısını belirtiyoruz. Yani dışarıdan gelen index.htm şeklindeki bir sorgu dispatcher servleta söylediğimiz *.htm şeklindeki desene uygun olarak parçalanır ve index kelimesi görüntü olarak elde edilir. Bir önceki satırda belirtilen rotaya uyun olarak (index.htm -> indexController), bir sonraki satırda inceleyeceğimiz görüntü<->kontrollör tanımlaması ile index görüntüsü olduğu karar kılınır. Sonra /WEB-INF/jsp/index.jsp dosyası (indexController denetiminde) görüntü olarak açılır.
Bir sonraki satırda (az önce de söylediğim gibi) görüntü<->kontrollör tanımlaması yapılmakta. name="indexController" ile kontrollör adını, class="org.springframework.web.servlet.mvc.ParameterizableViewController" ile kullanılacak sınıfı (burada hazır sınıf kullandık, kendi sınıfımızı oluşturup bu sınıftan kalıtım da alabilirdik), p:viewName="index" ile görüntü adını belirtiyoruz.

Ayarlarla ilgili kısmı burada noktalıyorum. Bir sonraki yazımda görüntü ve kontrollör oluşturma ve kullanma konularına değineceğim inşallah. Anlatımda kusurum varsa affınıza sığınıyorum.
Görüşmek üzere...

Yığın Veri Yapısı

Merhabalar,
Bu yazımda yığın veri yapısından bahsetmek istiyorum. Çalışması LIFO (Last In First Out - Son Giren İlk Çıkar) ilkesine dayanmaktadır. Fiziksel bir örnek vermek gerekirse yalnızca bir tek arabanın geçebileceği kadar genişlikte olan çıkmaz bir sokağa arabaların ard arda girmesi gibidir. Son giren araba ilk çıkmalıdır ki diğer arabalar çıkabilsin.

Peki Ne İşe Yarar?
Günümüzde bir çok sistem hafıza yönetiminde bu veri yapısını kullanmaktadır. Özellikle sıranın önemli olduğu durumlarda. Mesela, programlama dillerinde açtığımız parantezlerin kapatılıp kapatılmadığının kontrolü, işletim sistemi düzeyinde fonksiyonların çağrımı sırasında parametrelerin aktarımı, aritmetik işlemlerde işlem önceliğinin sağlanması ( çarpmanın toplamaya üstünlüğü), karakter katarlarının ters çevrilmesi vb. bir çok alanda kullanılmaktadır.

Teknik olarak açıklamak gerekirse...
Belirli bir hafıza bölgesini programcıdan soyutluyoruz. Direk erişimi engelliyoruz. Programcıya hafızaya erişmesi için fonksiyonlar veriyoruz. Bunlar push, pop ve isEmpty olabilir. Sırasıyla açıklayalım.

• Push

Yığına bir eleman eklemek istediğimizde bu fonksiyonu çağırırız. Fonksiyona veridiğimiz değer yığının en sonuna eklenir.

• Pop

Yığından bir eleman çekmek için kullanılır. Bu fonksiyon bize yığının en sonundaki yani son eklediğimiz elemanı yığından alır bize verir. Daha önceki elemanlara erişmek için Pop fonksiyonunu çağırmaya devam etmeliyiz. Bu fonksiyon herhangi bir parametre almaz.

• isEmpty

Bu fonksiyon ile yığının boş olup olmadığını kontrol edebiliriz.
Siz fonksiyonlarınıza istediğiniz ismi verebilirsiniz. Korumanız gereken tek şey LIFO ilkesidir. Geri kalan kısmı değiştirmekte özgürsünüz.

Hemen Java ile bir örnekleme yapalım:

package test;

import java.util.ArrayList;

class Stack
{
 private ArrayList<Object> objectList; // nesneleri tutacak generic yapımız.
 
 public Stack()
 {
  objectList = new ArrayList<Object>(); // nesnemizi üretelim.
 }
 
 public boolean isEmpty()
 {
  return objectList.isEmpty(); // liste boş ise yığında boştur.
 }
 
 public void Push(Object obj)
 {
  objectList.add(obj); // yığına eleman ekleyelim.
 }
 
 public Object Pop()
 {
  if (objectList.isEmpty())
   return null; // yığın boş ise eleman çekemeyiz. Sonuç null değeri.
  Object o = objectList.get(objectList.size()-1); // sondan bir elemanı alalım.
  objectList.remove(objectList.size()-1); // sonra bu elemanı yığından çıkartalım.
  return o; // geriye döndürelim.
 }
}


public class Main{

 public static void main(String[] args) {

  Stack s = new Stack();
  if (s.isEmpty())
   System.out.println("yığın boş.");
  s.Push(5);
  if (s.isEmpty())
   System.out.println("bu satırı görmememiz gerekiyor.");
  s.Push(45);
  System.out.println(s.Pop());
  System.out.println(s.Pop());
  System.out.println(s.Pop());
  System.out.println(s.Pop());
  if (s.isEmpty())
   System.out.println("yığında eleman yok.");
 }

}

En basit haliyle böyle gerçeklenebilirdi sanırım. Veri yapılarını açıklamaya devam edeceğim.
Görüşmek üzere...

Intel 8085 Mikroişlemci / Başlangıç

Herkese merhaba,
Bu yazımda Intel firması tarafından geliştirilmiş olan 8085 mikroişlemcisi yapısı, çalışma prensibi ve programlanması ile ilgili genel bilgi vereceğim. Başlıkta da belirttiğim gibi bu mikroişlemciler ve micro programlama konusuna girişimin imgesidir. Öncelikle bu basit mikroişlemciyi inceleyip programlamasına değineceğim. Daha sonra yine Intel firmasının 8051 mikrodenetleyicisinden bahsedeceğim. Daha sonraki yazılarımda sayısal sistemleri en başından alıp bir mikroişlemci nasıl çalıştığını anlatacağım. Daha sonra kendi mikroişlemcimi tasarlayacağım. Umarım atlamadan anlaşır bir biçimde anlatabilirim. Siz de üzerinde çalışıp kendi mikroişlemcinizi geliştirebilirsiniz.

Intel 8085 8-bit Microprocessor

Her konuda olduğu gibi bu konuda da tarihsel bilgilerle vaktinizi çalmak gibi bir niyetim yok. Merak edenler varsa http://en.wikipedia.org/wiki/8085 adresinden gerekli bilgileri alabilir. Programlama kısmına geçmeden önce işlemcinin yapısı hakkında bilgi vermek doğru olacaktır. Başlamadan önce belirtmeliyim. Bu yazımda sadece mikroişlemcinin yapısı ve programlamasından bahsedeceğim. Elektronik bir devrede nasıl kullanıldığından vb. diğer işlemlerden bahsetmeyeceğim. Genel olarak soyut sorunlar üzerinden yola çıkacağız.


Yukarıdaki şema mikroişlemcinin iç yapısını göstermektedir. Sırayla açıklayalım...

• 8 bit veri yolu

İşlemci birimleri arası haberleşmeyi sağlayan ortak kanal olarak tanımlanabilir. Bir seferde 8-bit veri taşıyabilir ve yalnızca tek bir birim kullanabilir. Bu birim kanala veriyi bırakır, veri yolunun bağlı olduğu tüm birimlere veri iletiri fakat yalnızca o anda ona ihtiyacı olan birim o veriyi kullanır. Tıpkı Ethernet (IEEE 802.3) protokolünde olduğu gibi. Burada farklı bir durum olarak veriyi kullanacak birimin aktif diğerlerinin pasif olamasını işlemci ayarlamaktadır. Toparlamak gerekirse, bir broadcast (yayın) tipi iletişim var fakat bu yayına yalnızca ilgili birim aldırış ediyor.

• ALU (Arithmetic Logic Unit)

Diğer bir değişle Ardışıl Mantık Birimi. Bu birimde tüm mantıksak ve aritmetik işlemler yapılmaktadır. Toplama, çıkarma, karşılaştırma vb.

• Accumulator (Akümülatör)

Temel kaydedici olarak tanımlasam çok yanlış olmaz sanırım. Tüm aritmetik işlem sonuçları bu kaydedicide saklanmaktadır. 8-bit veri saklayabilmektedir. Bir çok işlemde bu kaydedici kullanılmaktadır. Yeri geldikçe detaylandıracağım.

• Instruction Register

Bu saklayıcı mikroişlemcinin işleyeceği komutu tutar. 8 bitliktir. Bu mikroişlemcinin 8 bit kelime işlemci olduğunu belirtmiştik. Bir seferde bir tek komutu işleyebilmektedir ve bu komut 8 bit (1 byte) olmak zorundadır. Zaten hafıza birimimizin (RAM / ROM) her bir gözü 1 byte boyutundadır.

• Program Counter

İşlemcinin bir sonraki işleyeceği komutun adresini saklayan kaydedicidir. Boyutu 16 bittir. Buradan şu sonucu çıkartabiliriz, 8085 mikroişlemcisi 16 bit ile adreslenebilecek kadar hafıza alanında kod koşturabilmektedir. 2^16 ~= 64 kb hafıza alanı.

• Stack Pointer

Yığın hafıza bölgesinin adresini tutar. Buraya FILO (First In Last Out - İlk Giren Son Çıkar) mantığıyla veri ekleyip çıkartabiliyoruz. Boyut 16 bit.

• Flag Register

Bazı komutlar sonrasında durum kontrolü yapılması gerekmektedir. Örneğin bir toplama işleminde sonuç saklayıcının boyutunu aşabilir. Bu durumda işlemci kilitlenmez işleme devam eder, fakat programcı bu durumdan haberdar olması gerekmektedir. Programcı böyle bir durumun gerçekleşip gerçekleşmediğini Bayrak Saklayıcısındaki taşma bayrağının 1 - 0 durumunu inceleyerek anlayabilir. Bayraklardan kısaca bahsetmek gerekirse;
Sıfır Bayrağı = çıkarma işleminin sonucu 0 ise,
Taşma Bayrağı = toplama işlemi saklayıcıya sığmıyorsa, ya da çıkarılan çıkandan küçükse,
İşaret Bayrağı = Akümülatördeki sayı negatif ise (yani 8. bit 1 ise)
bu bayraklar 1 değerini alır. Aksi durumda 0 değerindelerdir.

Yazıma burada ara veriyorum. Bir sonraki yazımda kaldığım yerden tanıtmaya devam edeceğim. Daha sonra programlama kısmına geçeceğiz. Vaktim olursa bellek organizasyonu konusuna da değineceğim.
Görüşmek üzere...

Bağlı Listeler

Merhabalar,
Bu yazımda sizlere bağlı liste veri yapısından bahsedeceğim. Veri yapısı deyince kulağa egzotik gelebilir. Ama inanın bildiğiniz şeylerden farklı bir şey anlatmayacağım. "Bildiklerimizi bir araya getirerek bilmediğimiz bir yapıyı tanımlama" şeklinde anlıyorum veri yapılarını...

Nedir? Neden gerek duyulmuştur?
Bağlı liste veri yapısı hafızanın farklı bölgelerinde bulunan verileri birbirine katar şeklinde bağlayan yapıdır.Dizi vb. yapılar zaten bu işi sağlamıyor mu? şeklinde bir soru aklınıza tam bu satırda gelmiş olmalı. Evet sağlıyor ama bir yere kadar. Diziler hafızanın belirli bir noktasında ardışıl olarak gelir. Yani dizinin ilk elemanı hafızanın 100 nolu adresinde bulunuyorsa dizinin ikinci elemanı 101 nolu gözde bulunacaktır. Ayrıca diziler ilk oluşturulduğunda uzunluğu belli olmak zorundadır. Daha sonra genişleme imkanı yoktur. Ancak tekrar boyutlandırma yapılabilir ki bu iş oldukça maliyetlidir. İşte böyle dinamik genişleyen ucuz maliyetli bir yapıya ihtiyaç duyulduğu sırada keşfedilmiş olmalı bağlı listeler.

Bağlı derken?
Bağlı listenin her bir elemanı hafızada birbirine bir sonraki elemanın aderesini gösterecek bilgiye sahiptir. Biz yalnızca ilk elemanın adresini biliriz. İkinci elemana ulaşmak için önce birinci elemana gideriz, ondan bir sonraki yani ikinici elemanın adresini alırız daha sonra ikinci elemana ulaşabiliriz. Üç, dört, beş ... hafıza dolana kadar üretilebilir, ulaşım mekanizması hep aynı. Bağlı derken bu mekanizma kastediliyor.

İhtiyaca göre...
Sorunlar farklı olunca çözümler, dolayısıyla gereksinimler de farklı oluyor. Bağlı liste veri yapısı iki çeşittir. Tek yönlü ve çift yönlü. İlkinde sadece ileri yönlü haraket yapmak mümkünken ikinci tipde geri gelme de mümkündür. Siz kendi probleminize en uygun tipi seçmelisiniz.

Bırak gevezeliği de biraz kod yaz!

Tek yönlü bağlı liste, C örneği

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

typedef struct _eleman
{
 struct _eleman *sornakiEleman; // bir sonraki elemanı işaret eder.
 int veri; // yapının sakladığı veri. istenilen tipte istenildiği kadar veri eklenebilir.
} eleman;

typedef struct
{
 eleman *ilkEleman; // bağlı listeyi temsil eden yapı. Yalnızca ilk elemanı işaret ediyor.
} bagliListe;

bagliListe *bagliListeUret();
void elemanEkle(bagliListe*,int);
void elemanCikart(bagliListe*,int);
void listele(bagliListe*);

int main()
{
 bagliListe * bl = bagliListeUret(); // yeni bir bağlı liste ürettik.
 elemanEkle(bl,6); // eleman ekleyelim.
 elemanEkle(bl,34);
 elemanEkle(bl,987);
 elemanEkle(bl,5);
 elemanEkle(bl,2);
 listele(bl); // listele.
 system("pause");
 elemanCikart(bl,3); // 3. elemanı çıkart. ( ilk eleman 0'dan başlar)
 listele(bl); // tekrar listele, farkı gör.
 system("pause");
}

bagliListe *bagliListeUret()
{
 bagliListe* bl = (bagliListe*)malloc(sizeof(bagliListe)); // yeni bir bağlı listeyi hafızada oluşturup ilgili adresi alıyoruz.
 bl->ilkEleman = NULL;
 return bl;
}

void elemanEkle(bagliListe* bl,int veri)
{
 eleman *e = (eleman*)malloc(sizeof(eleman)); // yeni bir eleman oluşturalım.
 e->sornakiEleman = NULL;
 e->veri = veri;
 eleman *son = NULL; // katarın son elemanı.
 son = (eleman *)bl->ilkEleman; // başlangıç elemanını bağlı listeden alalım.
 if (son==NULL) // listemiz boş mu?
 {
  bl->ilkEleman = e;
  return;
 }
 while(son!=NULL) // değilse özyinelemeli olarak son elemana erişmeye çalış.
 {
  if (son->sornakiEleman==NULL)
   break;
  son = (eleman*)son->sornakiEleman; // düğümler arası atlama.
 }
 son->sornakiEleman = e; // nihayet son düğümün işaretçisine kendi adresimizi yazıyoruz.
}

void listele(bagliListe* bl)
{
 eleman *e = NULL;
 e=(eleman *)bl->ilkEleman;
 int i=0;
 while(e!=NULL) // özyinelemeli listeleme fonksiyonu.
 {
  printf("%i. eleman verisi = %i\n",i++,e->veri);
  e = (eleman*) e->sornakiEleman;
 }
}

void elemanCikart(bagliListe * bl, int sira)
{
 eleman *e = NULL;
 e=(eleman *)bl->ilkEleman;
 eleman *onceki = NULL;
 int i=0;
 if (e==NULL) // listemiz boş mu?
 {
  printf("Liste bos oldugu icin cikartma yapilamiyor!\n");
  return;
 }
 while(e!=NULL)
 {
  if (i==sira)
   break;
  i++;
  onceki = e;
  e = (eleman*) e->sornakiEleman; 
 }
 onceki->sornakiEleman = e->sornakiEleman; // silmek istediğimiz elemanın bir önceki düğümü ile bir sonraki düğümü birbirine bağlıyoruz. Böylelikle aradan çekilerek silinmiş izlenimi oluşturuluyor.
 free(e); // hafıza sızıntısını önlemek için serbert bıraktığımız elemanı hafızadan silmeyi unutmayalım.

}

Diğer yüksek seviyeli dillerde (Java, C# vb.) bu veri yapısını yapmak çok daha kolay. Mantıktan yola çıkarak o dillerde de sorunsuz bir şekilde bağlı liste veri yapısını oluşturabileceğinize inanıyorum.
Görüşmek üzere...

JQuery ve Sanat

Tekrar merhaba,
Bu yazımda JQuery ile sanat nasıl yapılır konusuna ışık tutmaya çalışacağım. Sanat yapmak derken belki biraz abartmış olabilirim ama abartı çoğu insanın ilgilini çeken bir olgudur. Klasik, nedir - ne değildir zamazingosunu yapalım. Öncelikle resmi sitesini vererek kaynak belirtebiliriz - http://jquery.com/
not: indirirken size 2 seçenek sunmaktadır. Production / development şeklinde. Farkı, ilkinde gereksiz boşluk ve satır atlama karakterleri silinerek dosyanın boyutu küçültülmüş, bir nevi sıkıştırma yapılmış. Fakat kodun okunması neredeyse imkansız çünkü herşey birbirine geçmiş durumda. İkinci seçenekte ise kodlar okunaklı bir şekilde yayınlanıyor. Boyutu ilkine göre daha fazla ama bir geliştirici için çok değerli.
JQuery kütüphane içerisindeki kopyalama hakkı yazısını değiştirmediğiniz sürece ticari uygulamalarda dahi kullanabilirsiniz. Tamamen ücretsiz. Lisans detayları için resmi sitesinden bilgi alabilirsiniz.

Bu aralar çok duymaya başladım, nedir bu JQuery?
Özetle javascript yazımını kolaylaştıran kütüphane. İçerisinde bir çok javascript fonksiyonu barındırıyor. En önemli özelliği tarayıcı bağımsız olması. Yani JQuery ile yazdığımız javascript komutları tüm tarayıcılarda aynı şekilde sorunsuz olarak çalışmaktadır. Web ortamında javascript geliştirenler tarayıcı uyumsuzluğu sorununu bilmektedir. JQuery ile bu ortadan kalkmaktadır. Pratikte JQuery bize yeni birşey değil. Normal javascript komutlarıyla yapacaklarımızdan ötesi yok. O bize hızlı, güvenilir ve tarayıcı bağımsız javascript geliştirme imkanı sunmaktadır.

Hızlı bir giriş

 $(document).ready(function(){
   $("a").click(function(event){
     alert("Tum linkler bu yaziyi gosterir!");
   });
 });

Sırayla inceleyelim. Öncelikle $ karakterinden başlamak istiyorum. Bu fark edebileceğiniz gibi bir fonksiyon aslında. Bildiğimiz javascript fonksiyonu. JQuery için temel ifade ediyor. Tüm çağrılarımızı bu fonksiyon üzerinden yapıyoruz. Reguler Expression tanımlamalarını çok iyi kullandıkları için bu fonksiyonun içerisine verebileceğimiz parametrelerin sayısı oldukça fazla. $(document) ile javascript'in çalıştığı dosyayı seçiyoruz. Daha sonra gelen .ready(... ifadesiyle sayfamızın işlem için hazır olduğunu garantiliyoruz.
function() { } neden gerekli?
.ready olayında çalışmasını istediğimiz kodları direk parantez içerisinde yazsaydık kodumuz çalışmayacaktı. Çünkü JQuery çalışma mantığında bir iş yapmak için o işi yapacak fonksiyonun adını ilgili JQuery fonksiyonuna vermeliyiz. Aynı fonksiyon işaretçileri gibi ya da diğer bir benzetmeyle klasik setTimeout javascript komutunda olduğu gibi.
Şimdi biraz toparlayalım:
$(document) // sayfamız
.ready( // hazır olunca çalıştır
function() { ... } // yeni bir fonksiyon ürettik ve bağladık
);

İyi gidiyoruz, ya sonra?
Yeni oluşturduğumuz fonksiyonun içeriğini inceleyelim.
$("a") // a taglı elemanları seç.
.click( // tıklayınca çalıştır.
function() { ... } // yeni bir fonksiyon ürettik ve bağladık
);
Burada oluşturduğumuz fonksiyonun içerisine alert komutumuzu yerleştirdik.
Kodumuzu çalıştırdığımızda sayfamızdaki tüm linkler tıklandığında bu mesajı alacaklar.
Giriş olarak bu kadarla yetineceğim. Daha sonraki yazılarımda detaylı incelemeler ve yeni örnekler sunacağım.
Görüşmek üzere...

Spring Framework - Web MVC / NetBeans 6.8

Herkese merhaba,
Bu yazımda sizlerle Spring Framework ile mvc web uygulamalarına giriş yapacağız. Amacım framework altyapısını uzun uzun anlatmak, çıkış hikayesi vb. yazılarla aklınızı karıştırmak değil. Detaylı bilgi almak isteyenler http://www.springsource.com/ adresinden ya da arama motorlarını kullanarak bilgi alabilirler. Arama yaptığınızda siz de anlayacaksınız, tüm sitelerde bu konuya giriş yapılmış. Framework alt yapısı çalışma mantığı anlatılmış fakat elle tutulur bir proje yok. En büyük sorun çalışan uygulama eksikliği. Elimden geldiğince sizlere gerçek şartlarda çalışan uygulamalar göstermeye çalışacağım.

Hangi IDE?
Ben bu örnekte Netbeans 6.8 üzerinden anlatacağım. Bu geliştirme ortamını seçmemin sebebi kolay olması. İçeresinde bir çok gerekli kütüphane hazır olarak geliyor. Olayı kavradıktan sonra Eclipse ile projelerimizi geliştirmeye devam edeceğiz. Buradaki tek amacımız Spring, IDE kaynaklı sorunlarla kafamızı yoramayız.

Ortamın Hazırlanması
Netbeans 6.8 Web EE içeren bir paketini kurmanız yeterli. Ayrıca Java kodlarının derlenmesi için JDK gerekli konumuz Java olmadığı için bundan bahsetme gereği duymuyorum.
File | New
Netbeans geliştirme ortamını açtıktan sonra yeni bir Dynamic Web Application projesi oluşturuyoruz.



Daha sonra dikkat etmeniz gereken tek nokta projemize dahil edeceğimiz kütüphanelerdir. Burada Spring Web MVC 2.5 seçeneğini işaretliyoruz.



Finish diyerek projemizi oluşturuyoruz. Sonra karşınıza şu şekilde bir görüntü çıkmalı.



Şimdi projemizi Run menüsünden ya da F6 kısayol tuşu ile çalıştıralım. Karşınıza aşağıdaki gibi bir ekran çıktıysa merak etmeyin doğru yoldasınız :)



Dur bir dakika! Burada neler oluyor?
Hemen izah edeyim. Az önce bir Spring Web MVC projesi oluşturduk. Netbeans bizim yerimize varsayılan bazı ayarlamaları ve iskelet yapıyı oluşturdu. Bu Netbeans'in özelliği. Sol taraftaki klasör yapısına bakmamız yapıyı anlamada faydalı olacaktır. Web Pages klasörü altında WEB-INF, META-INF klasörleri ve redirect.jsp dosyası var. WEB-INF ve META-INF dışarıdan erişilemeyen (dışarıdan derken, projeyi siteye yüklediğimizde internetten sitemize giren kullanıcıları kastediyorum) özel ayar klasörleridir. Bu klasörlerden bahsetmeden önce ana dizinde bulunan tek dosya olan redirect.jsp ye bakalım. Bildiğimiz gibi Java Dynamic Web projelerinde bütün JSP dosyaları Web Pages altında olurdu ve biz buradaki dosyalara web tarayıcımız vasıtasıyla erişebiliyorduk. Fakat burada yalnız bir dosya var? Öyle ise hemen merakımızı redirect.jsp dosyasına bakarak giderelim.

Buyurun efendim:


Hiçbir şey anlamadım?
Kesinlikle çok saçma! index.htm nerede? Olmayan bir dosyaya yönlendirme mi yapılıyor? Burada bir gariplik var sanki. Evet durum biraz garip ama biraz incelediğimizde ve detaylara dikkat ettiğimizde aslında ne kadar güzel bir yapı olduğunu daha iyi anlayacağız. Burada index.htm dosyasına yönlendirerek aslında index.htm dosyasını açmıyoruz, index adındaki görüntüyü çağırıyoruz.
Görüntü mü? Nasıl yani?
MVC tasarım şablonunun (Model View Controller) ortasındaki View olayından bahsediyoruz. Bu tasarım desenini anlamak biraz sancılı olabilir ama anladıktan sonra hele bir de nimetlerinden faydalandıktan sonra ne kadar güzel bir şey olduğunu siz de anlayacaksınız. Görüntü dediğimiz kavram, önceden hazırlanmış tasarım dosyalarıdır. Herbiri bir controller nesnesine bağlıdır. Onun yetkisi olamadan ilgili görüntüye erişmek mümkün değildir.
İyice karıştı, Controller derken?
Controller sınıflar görüntüleri kullanıcıdan gelen talepler doğrultusunda göstermek ve şekillendirmek adına geliştirilmiştir. Daha detaylı bilgiyi ilerleyen kısımlarda vereceğim.

Tamam ama hâlâ olmayan bir index.htm dosyasını nasıl açtığımızı anlayamadım?
Sır perdesi WEB-INF klasörünü açmamızla aralanacaktır. Bildiğimiz gibi WEB-INF klasörü özel bir ayar klasörü.



xml uzuntılı dosyalar ayarlama için gerekli dosyalar. Sorumuzun cevabı ise jsp klasörü altında gizli. Evet haklısınız, index.jsp :D
Görüntü dosyalarımızı bu klasör altına atmamızın sebebi dış dünyadan soyutlamak. Yalnızca controller nesnesi tarafından erişilmesini sağlamak için yapılmış bir sarmalama mekanizması. Zekice!
Hmm.. Peki ya uzantı?
Sizden de hiçbir şey kaçmıyor :) ama yine de dikkatsizsiniz. Projemizi ilk oluşturduğumuz zamana geri dönelim. Orada Spring Web MVC 2.5 kütüphanesini seçerken Dispatcher Mapping: *.htm şeklinde bir desen girmiştik. İşte bu *.htm şeklinde gelen istekleri .jsp uzantılı görüntülere aktarılmasını sağlıyor. Bu desen çok farklı şekilde olabilir bunları daha sonra inceleyeceğiz. Tüm bu ayarlar WEB-INF altındaki xml uzantılı dosyalarda tanımlanıyor. Bu konuya da daha sonra değineceğim.
Kafam karıştı, böylece bırakıp gidemezsin!
Bu yazımı burada noktalayacağım. Amacım çalışan örneklerle bu konuya değinmekti. Tam olarak hedefime ulaştığım söylenemez, fakat parça parça anlatmak daha faydalı olacak gibi. Konu hakkında yazmaya kaldığım yerden devam edeceğim.
Görüşmek üzere...

Dynamic-Link Library (DLL) / Giriş

DLL dosyaları Microsoft'un Windows ve OS/2 işletim sistemleri için gerçeklediği kütüphane paylaşım konsepti olarak tanımlanabilir. Bu kütüphaneler genellikle DLL, OCX ya da DRV uzuntasındadır.

DLL dosyaları aynen EXE dosyaları gibi kod, veri ve kaynak bölümlerine (ve bunların herhangi bir kombinasyonunda) olabilir.

Windows işletim sisteminin ilk sürümlerinde tüm programlar tek bir bellek bölgesinde koşturuluyordu. İşletim sistemi düzeyindeki tüm işlemler MS-DOS tarafından gerçekleştirilirken yüksek seviyeli hizmetler Windows DLL leri tarafından sağlanıyordu. Çizim API'leri yani GDI.EXE, kullanıcı arayüzü işlemleri USER32.EXE adlı kütüphane dosyasında gerçeklenmiştir.


Günümüzde daha farklı bir yaklaşım kullanılmaktadır. Sistem tarafından sunulan kütüphaneler uygulamalara ayrı ayrı yüklenmektedir. Korumalı modda olduğu için bir program başka bir programın hafıza alanına doğrudan bir müdehalede bulunamıyor.

Assembly dilinde basit bir mesaj gösteren DLL uygulaması şu şekilde olabilir:

.386 ; intel x86 architecture
.model flat,stdcall ; use flat memory management
option casemap:none ; ignore letter case

include \masm32\include\windows.inc 
include \masm32\include\user32.inc ; for MessageBox func.
include \masm32\include\kernel32.inc

includelib \masm32\lib\user32.lib
includelib \masm32\lib\kernel32.lib

.data
message db "Test message...",0 ; content of our simple message

.code
DllEntry proc hInstance:HINSTANCE, reason:WORD, reserved1:WORD ; DLL entry point function
mov eax,TRUE
ret
DllEntry Endp

SimpleMessage proc
invoke MessageBox,NULL,addr message,NULL,MB_OK ; win32 MessageBox func.
ret
SimpleMessage Endp

End DllEntry

Bu programı derlemek için birde def dosyası oluşturmalıyız. Bu dosyada 2 satır bilgi gerekiyor. Birinci satırda kütüphanenin ismini ikinci satırda ise kütüphaneden dışarı aktarılacak yani diğer programların hizmetine sunuculacak olan fonksiyonların isimleri.

örnek olarak

LIBRARY Simple
EXPORTS SimpleMessage

Projemizi derlemek için komut satırına bazı komutlar girmemiz gerekecek. Bu işlemin otomasyonu için şöyle bir batch dosya oluşturabiliriz.

c:\masm32\bin\ml.exe /c /coff /Cp "%CD%\Simple.asm"
c:\masm32\bin\link.exe /DLL /DEF:"%CD%\Simple.def" /SUBSYSTEM:WINDOWS /LIBPATH:c:\masm32\lib "%CD%\Simple.obj"

Not: Bu uygulamayı derleyebilmeniz için sisteminizde Masm32 derleyicisi yüklü durumda olmalıdır. http://www.masm32.com/

Şimdi oluşturduğumuz bu DLL dosyasını başka bir programdan çağıralım. Bunun için çağırı yapacak programımızı derlerken DLL dosyamızın yapısını bildirmek üzere bir .lib dosyası vereceğiz. Bu dosya DLL projemizi derlerken derleyici tarafından otomatik olarak oluşturulmaktadır.

Kısa basit bir örnek:

.386
.model flat,stdcall
option casemap:none
include \masm32\include\windows.inc
include \masm32\include\kernel32.inc
includelib Simple.lib ; lib file of Simple.dll to inform linker 
includelib \masm32\lib\kernel32.lib

SimpleMessage PROTO ; name of the function in DLL

.code
start:
        invoke SimpleMessage ; invoke the function in DLL
        invoke ExitProcess,NULL ; terminate process
end start

Şimdi benzer bir çağırı programını C++ dilinde dinamik çağırma yöntemiyle yapalım.

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

typedef void (WINAPI *SimpleMessage)(); // type defination to call dll function.

int main(int argc, char **argv)
{
 HINSTANCE hDLL = LoadLibrary(L"simple.dll"); // loads our DLL into application memory section.
 SimpleMessage sm = (SimpleMessage)GetProcAddress(hDLL,"SimpleMessage"); // gets address of our function in the dll.
 if (!sm) // function address validation.
 {
  printf("Couldn't load library!\n");
 }
 else
 {
  sm(); // simple call.
 }
 return 0;
}

C# tarafında işler çok daha kolay:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.InteropServices;

namespace SimpleCall
{
    class Program
    {
        [DllImport("simple.dll")]
        static extern void SimpleMessage();

        static void Main(string[] args)
        {
            SimpleMessage();
        }
    }
}

Java tarafında direk bir erişim şekli mevcut değil. Bunun yerine bazı 3. parti kütüphaneleri kullabiliriz. Bunlar JNI (Java Native Interface) tabanlı kütüphaneler. Biz bu örnekte JNA (Java Native Access) kullanacağız.

Bu kütüphanenin açıklamasını daha önceki bir yazımda (Bkz: http://rbellek.blogspot.com/2010/04/java-native-access-basit-ornek.html) bahsettiğim için burada yüzeysel geçiyorum.

Örnek uygulama:

//Main.java
package simple;

import com.sun.jna.Native;

public class Main {

    public static void main(String[] args)
    {
        Simple simpleDLL = (Simple)Native.loadLibrary("e:\\Simple.dll", Simple.class);
        simpleDLL.SimpleMessage();
    }
}

//Simple.java
package simple;

import com.sun.jna.Library;

public interface Simple extends Library {
    void SimpleMessage();
}

DLL dosyasının aynı EXE dosyaları gibi bir giriş noktları mevcuttur. Bu noktanın adı DllEntry adlı bir fonksiyondur. Ve giriş parametreleri olarak şu 4 değerden birini almaktadır.

DLL_PROCESS_ATTACH
DLL_PROCESS_DETACH
DLL_THREAD_ATTACH
DLL_THREAD_DETACH

Basit bir toplama kütüphanesi:

.386
.model flat,stdcall
option casemap:none
include \masm32\include\windows.inc
include \masm32\include\user32.inc
include \masm32\include\kernel32.inc
includelib \masm32\lib\user32.lib
includelib \masm32\lib\kernel32.lib

.data
AppName db "Simple 2",0
HelloMsg db "Hello, you're calling a function in this DLL",0
LoadMsg db "The DLL is loaded",0
UnloadMsg db "The DLL is unloaded",0
ThreadCreated db "A thread is created in this process",0
ThreadDestroyed db "A thread is destroyed in this process",0

.code
DllEntry proc hInstance:HINSTANCE, reason:DWORD, reserved1:DWORD
 .if reason==DLL_PROCESS_ATTACH
  invoke MessageBox,NULL,addr LoadMsg,addr AppName,MB_OK
 .elseif reason==DLL_PROCESS_DETACH
  invoke MessageBox,NULL,addr UnloadMsg,addr AppName,MB_OK
 .elseif reason==DLL_THREAD_ATTACH
  invoke MessageBox,NULL,addr ThreadCreated,addr AppName,MB_OK
 .else        ; DLL_THREAD_DETACH
  invoke MessageBox,NULL,addr ThreadDestroyed,addr AppName,MB_OK
 .endif
 mov  eax,TRUE
 ret
DllEntry Endp

Addition proc param1:DWORD, param2:DWORD
 mov ebx,param1
 mov eax,param2
 add eax,ebx
 ret 
Addition endp
End DllEntry

Bu toplama fonksiyonunu (parametreli) çağıran C++ uygulaması:

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

typedef int (WINAPI* Addition)(int,int); // two DWORD (32-bit integer) in parameters
           // WINAPI same as __stdcall
              // __stdcall gives order of parameters in stack
int main(int argc, char **argv)
{
 HINSTANCE hDLL = LoadLibrary(L"calculator.dll");
 Addition addition = (Addition)GetProcAddress(hDLL,"Addition");
 if (!addition)
 {
  printf("Couldn't load library!");
 }
 else
 {
  printf("5 + 9 = %i",addition(5,9)); // simple two parameter call
 }
 return EXIT_SUCCESS;
}

Şimdilik basit bir girişle yetiniyorum. Umarım devamında detaylandırabilirim...