Tampilkan postingan dengan label Code Blocks. Tampilkan semua postingan
Tampilkan postingan dengan label Code Blocks. Tampilkan semua postingan

Sabtu, 29 Juli 2017

Membuat Pesawat Oleng Kiri Kanan


Selamat siang rekan-rekan sekalian...

Masih dengan topik membuat game perang-perangan dengan Code Block, kali ini ogut akan memberikan variasi sederhana atau trik sederhana, tetapi bermanfaat untuk membuat tampilan game rekan-rekan menjadi lebih yahut.


Artikel ini belum selesai ntar ogut terusin, karena ogut harus kembali kerja.....see you later



Salam


Heriady

Minggu, 09 Juli 2017

Variasi Peluru Pesawat

Artikel kali ini tidak akan menjelaskan cara untuk membuat peluru. Tapi ogut hanya memberikan ide variasi beberapa peluru pesawat yang dapat rekan-rekan buat. Ini sebagai tantangan bagi rekan-rekan untuk belajar. Jadi ogut tidak akan membahasnya dan tidak akan menulis artikelnya, serta tidak akan membagikan source code nya.





Selamat Belajar dan Sukses Selalu


Heriady





Membuat Peluru Pesawat Dengan Code Block


Salam rekan-rekan sekalian, ketemu lagi dengan ogut. Dan kali ini ogut masih akan menyambung tentang artikel terdahulu, yaitu artikel tentang membuat game dengan menggunakan compiler Code Block.

Kali ini topiknya adalah membuat peluru untuk pesawat jagoan agar pesawat bisa berperang.




Untuk membuat peluru tersebut caranya tidak susah-susah amat.

Ogut siapin typedef struct dan variable seperti di bawah ini.

////peluru jagoan================================\/
typedef struct
{
int aktif;
int Type;
double Ax;
double Ay;
double Bx;
double By;
double Cx;
double Cy;
double Dx;
double Dy;
}Objek_Peluru;

int delay_peluru_Jagoan = 0;
int Total_Peluru_Jagoan = 50;
Objek_Peluru Peluru_Jagoan[50];
//Objek_Peluru Peluru_Hely[90];
int Tipe_Peluru_Aktif;

unsigned int peluru_mask;
unsigned int peluru_image;
///peluru jagoan=================================/\

Pada fungsi void Keyboard_ditekan() ogut tambahin, jika tombol 'V' di tekan maka peluru diisi dengan cara memanggil fungsi Jagoan_Fire().

void Keyboard_ditekan()
{
...
...
...

//tekan tombol peluru========================\/
delay_peluru_Jagoan = delay_peluru_Jagoan + 1;

if (GetKeyState('V') & 0x80)
{

if (delay_peluru_Jagoan >= 15)
{
delay_peluru_Jagoan = 0;
Jagoan_Fire();
            }
}
//tekan tombol peluru========================/\

}

Ini adalah fungsi void Jagoan_Fire() yang berguna untuk mengisi peluru, ingat ya posisi peluru tergantung dari posisi pesawat jagoan. Untuk lebih mudahnya perhatikan oret-oretan di bawah ini.


ABCD peluru tergantung dari posisi pesawat atau ABCD nya pesawat.

//isi peluru
void Jagoan_Fire()
{
int i;

for (i = 0; i < Total_Peluru_Jagoan; i++)
{
if (Peluru_Jagoan[i].aktif == 0)
{

Peluru_Jagoan[i].aktif = 1;
Peluru_Jagoan[i].Type = 0;

//menentukan posisi awal peluru

//posisi awal peluru ditentukan oleh
//posisi badan hely, pada saat hely
//melepaskan peluru
Peluru_Jagoan[i].Ax = ((Pesawat_Jagoan.Cx - Pesawat_Jagoan.Dx) / 2.0) + Pesawat_Jagoan.Dx - 15.0;
Peluru_Jagoan[i].Bx = ((Pesawat_Jagoan.Cx - Pesawat_Jagoan.Dx) / 2.0) + Pesawat_Jagoan.Dx + 15.0;
Peluru_Jagoan[i].Dx = Peluru_Jagoan[i].Ax;
Peluru_Jagoan[i].Cx = Peluru_Jagoan[i].Bx;

Peluru_Jagoan[i].Ay = Pesawat_Jagoan.Dy - 10.0;
Peluru_Jagoan[i].By = Peluru_Jagoan[i].Ay;
Peluru_Jagoan[i].Cy = Peluru_Jagoan[i].By + 50.0;
Peluru_Jagoan[i].Dy = Peluru_Jagoan[i].Cy;

i = Total_Peluru_Jagoan;
}
}

}

Terakhir tampilkan peluru. Posisi peluru harus terus diupdate agar bergerak. Dan peluru yang ditampilkan hanya peluru yang aktif (Peluru_Jagoan[i].aktif ==  1). Jika posisi peluru telah keluar dari layar game maka Peluru_Jagoan[i].aktif = 0.

for (i = 0; i <= Total_Peluru_Jagoan; i++)
{
//==============================================================================================

//=================================segiempat PELURU tarus disini \/
//tampilkan peluru mask

//ubah posisi peluru
if (Peluru_Jagoan[i].aktif ==  1)
{
Peluru_Jagoan[i].Ay = Peluru_Jagoan[i].Ay + 15.0;
Peluru_Jagoan[i].By = Peluru_Jagoan[i].By + 15.0;
Peluru_Jagoan[i].Cy = Peluru_Jagoan[i].Cy + 15.0;
Peluru_Jagoan[i].Dy = Peluru_Jagoan[i].Dy + 15.0;
}

//cek peluru aktif/ tidak
if (Peluru_Jagoan[i].Ay > (double)(Ymax))
{
Peluru_Jagoan[i].aktif = 0;
}

if (Peluru_Jagoan[i].aktif == 1)
{
glEnable(GL_BLEND);
glBlendFunc(GL_DST_COLOR, GL_ZERO);

glBindTexture(GL_TEXTURE_2D, peluru_mask);
glBegin(GL_POLYGON);
glTexCoord2d(0.0, 0.0);
glVertex2d(Peluru_Jagoan[i].Ax, Peluru_Jagoan[i].Ay);

glTexCoord2d(1.0, 0.0);
glVertex2d(Peluru_Jagoan[i].Bx, Peluru_Jagoan[i].By);

glTexCoord2d(1.0, 1.0);
glVertex2d(Peluru_Jagoan[i].Cx, Peluru_Jagoan[i].Cy);

glTexCoord2d(0.0, 1.0);
glVertex2d(Peluru_Jagoan[i].Dx, Peluru_Jagoan[i].Dy);
glEnd();


//tampilkan peluru image
glBlendFunc(GL_ONE, GL_ONE);


glBindTexture(GL_TEXTURE_2D, peluru_image);
//glColor3f(1.0f,1.0f,1.0f);
glBegin(GL_POLYGON);
glTexCoord2d(0.0, 0.0);
glVertex2d(Peluru_Jagoan[i].Ax, Peluru_Jagoan[i].Ay);

glTexCoord2d(1.0, 0.0);
glVertex2d(Peluru_Jagoan[i].Bx, Peluru_Jagoan[i].By);

glTexCoord2d(1.0, 1.0);
glVertex2d(Peluru_Jagoan[i].Cx, Peluru_Jagoan[i].Cy);

glTexCoord2d(0.0, 1.0);
glVertex2d(Peluru_Jagoan[i].Dx, Peluru_Jagoan[i].Dy);
glEnd();

glDisable(GL_BLEND);
}
//=================================segiempat PELURU tarus disini /\


}
//peluru==================================================/\


Selesai sudah bahasan tentang peluru. Gak susah kan. Sampai jumpa lagi di artikel ogut yang lain.

Salam Sukses Selalu


Heriady




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

Kamis, 29 Juni 2017

Animasi Latar Belakang Bergulung Code Block OpenGL


Selamat Sore rekan-rekan sekalian, masih dalam suasana lebaran, mohon maaf lahir dan batin. Kali ini ogut akan meneruskan artikel pemrograman game 2D dengan menggunakan compiler Code Block. Artikel kali ini membahas tentang cara membuat latar belakang yang bergulung, atau animasi bergulung, sehingga game yang rekan-rekan buat akan tampak semakin hidup seperti video berikut ini.



Atau screen capture-nya seperti ini.


Untuk membuat latar belakang bergulung, ingatlah satu hal, yaitu rantai sepeda.



Waduh apa hubungan bengkel sepeda dayung dengan game ini ya...???

Untuk membuat latar belakang bergulung ogut hanya meniru rantai sepeda. Rantai sepeda panjangnya hanya segitu-gitu aja, tapi karena diputar akan terlihat seperti tidak putus-putus alias nyambung terus.

Nah itu dia rahasianya.Untuk lebih jelasnya lihat gambar di bawah ini.



Nah lho gambar apa lagi ini...???
Gambar di atas adalah gambar layar / screen game rekan-rekan yang dibagi menjadi beberapa bagian(sebelah kiri) dan gambar tekstur latar belakang(sebelah kanan) yg ogut bagi-bagi juga. Perhatikan tekstur latar belakang yang ada tanda ujung rantai. Betul ujung-ujung tekstur di program game akan ogut sambungkan lalu akan ogut putar seperti rantai sepeda. Dengan berputarnya tekstur latar belakang seperti rantai sepeda, maka latar belakang tidak akan berhenti berputar. Ini yang akan menghasilkan efek animasi yang bagus sekali.

Di program ogut membuat typedef struct seperti berikut ini.

//BG============================================
typedef struct
{
double V_Y1;
double V_Y2;
int Index_TK;
}Vertex_BG;

typedef struct
{
double TK_Y1;
double TK_Y2;
}TK_BG;


Vertex_BG V_BG[300];
TK_BG Text_BG[600];

//+++++++++++++++++++++++++++++++++++++++++++

Lalu ogut membuat tiga fungsi berikut untuk seting nilai-nilai yang diperlukan dan menampilkan efek animasi bergulung di layar monitor.

void Create_Vertex_BG(Vertex_BG Array_BG[], int total_ar, double Ymax_P)
{
int i;

//tinggi layar dibagi dengan total array
//untuk membagi layar menjadi bagian yang
//sama besar secara horisontal
double beda_VBG = (Ymax_P * 2.0 / (double)total_ar);

for (i = 0; i < total_ar; i++)
{
Array_BG[i].V_Y1 = -Ymax_P + (beda_VBG * (double)i);
Array_BG[i].V_Y2 = -Ymax_P + (beda_VBG * (double)(i + 1));

Array_BG[i].Index_TK = i;
}

}

void Create_TK_BG(TK_BG Array_TK_BG[], int total_ar)
{
int i;

//tinggi texture = 1
//dibagi dengan banyaknya array.
double beda_TK_BG = 1.0 / (double)total_ar;

for (i = 0; i < total_ar; i++)
{
Array_TK_BG[i].TK_Y1 = beda_TK_BG * (double)i;
Array_TK_BG[i].TK_Y2 = beda_TK_BG * (double)(i + 1);
}

}


void Display_Scrolling_BG(Vertex_BG Array_BG[], TK_BG Array_TK_BG[],
int total_ar_V, int total_ar_TK,
unsigned int texture_BG, double Xmax_P)
{
int i;

glBindTexture(GL_TEXTURE_2D, texture_BG);

for (i = 0; i < total_ar_V; i++)
{
glBegin(GL_POLYGON);
glTexCoord2d(0.0, Array_TK_BG[Array_BG[i].Index_TK].TK_Y1);
glVertex2d(-Xmax_P, Array_BG[i].V_Y1);

glTexCoord2d(1.0, Array_TK_BG[Array_BG[i].Index_TK].TK_Y1);
glVertex2d(Xmax_P, Array_BG[i].V_Y1);

glTexCoord2d(1.0, Array_TK_BG[Array_BG[i].Index_TK].TK_Y2);
glVertex2d(Xmax_P, Array_BG[i].V_Y2);

glTexCoord2d(0.0, Array_TK_BG[Array_BG[i].Index_TK].TK_Y2);
glVertex2d(-Xmax_P, Array_BG[i].V_Y2);
glEnd();

//perbaharui nilai Index TK
//supaya tercipta animasi
//background berjalan/bergulung
Array_BG[i].Index_TK++;

if (Array_BG[i].Index_TK >= total_ar_TK)
Array_BG[i].Index_TK = 0;
}
}

Jadi dah program animasi bergulung ogut, selamat belajar rekan-rekan semoga artikel sederhana ini bermanfaat.

Salam


Heriady




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

Rabu, 28 Juni 2017

Animasi Sederhana dan Kombinasi Tombol Code Block


Hai rekan-rekan sekalian kwmbali ogut akan membagikan sedikit ilmu tentang pemrograman game dengan menggunakan compiler Code Block.

Ini adalah lanjutan artikel ogut sebelumnya dan artikel ini berkaitan dengan artikel sebelumnya, jadi supaya rekan-rekan tidak bingung, silahkan baca juga artikel yang terkait dengan artikel ini.


Kali ini ogut akan membagikan contoh program animasi sederhana untuk membuat game perang 2D. Jika rekan-rekan menekan tombol 'J' , 'K', 'L' dan 'I'. maka pesawat akan bergerak kesana kemari mengikuti arah yang diberikan.

Untuk membuat animasi pesawat bergerak kesana kemari, caranya sangat mudah. Cukup dengan mengubah nilai titik koordinat ABCD. Ya hanya itu, dengan mengubah nilai titik koordinat persegipanjang ABCD maka pesawat akan ber-animasi.

Perhatikan potongan source code berikut ini.

//pesawat ke atas saja
if (kombinasi_tombol == 100000)
{
        Pesawat_Jagoan.Ay = Pesawat_Jagoan.Ay +  geser_atas_bawah;
        Pesawat_Jagoan.By = Pesawat_Jagoan.By +  geser_atas_bawah;
        Pesawat_Jagoan.Cy = Pesawat_Jagoan.Cy +  geser_atas_bawah;
        Pesawat_Jagoan.Dy = Pesawat_Jagoan.Dy +  geser_atas_bawah;
}

Untuk membuat pesawat bergerak ke atas, maka nilai koordinat Y ditambah. Hal ini juga berlaku untuk bergerak kekiri, kekanan dan kebawah.

Sedangkan untuk mendeteksi tombol keyboard yang ditekan, gunakan fungsi berikut ini.

void Keyboard_ditekan()
{
double geser_kiri_kanan = 1.0;
double geser_atas_bawah = 1.0;

int kombinasi_tombol = 0;


//tombol kanan di tekan
if (GetKeyState('L') & 0x80)
{
kombinasi_tombol = kombinasi_tombol + 1000000;
}

//tombol kiri di tekan
if (GetKeyState('J') & 0x80)
{
kombinasi_tombol = kombinasi_tombol + 2000000;
}

//tombol atas di tekan
if (GetKeyState('I') & 0x80)
{
kombinasi_tombol = kombinasi_tombol + 100000;
}

//tombol bawah di tekan
if (GetKeyState('K') & 0x80)
{
kombinasi_tombol = kombinasi_tombol + 200000;
}

...
...
...
}

Ternyata mudah ya untuk membuat animasi game 2D, selamat belajar rekan-rekan semoga artikel sederhana ini bisa bermanfaat. Ini ada contoh animasi lain yg ogut buat dengan Code Block, prisipnya sama dengan yang ogut terangkan di atas. Nanti ogut update lagi perkembangannya.



Salam


Heriady




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

Rabu, 07 Juni 2017

Program Teknik Masking Dengan Code Block


Selamat Siang rekan-rekan sekalian...kembali ogut mau membagikan sedikit ilmu yang bermanfaat untuk prmrograman game 2D.

Program akan menampilkan tampilan seperti gambar di bawah ini. Perhatikan burung biru yang ditampilkan dengan teknik masking dan yang ditampilkan tanpa teknik masking.


Burung biru yang di tampilkan dengan teknik masking akan terlihat tanpa kotak, teknik seperti ini yang digunakan untuk menampilkan objek-objek game 2D.

Penjelasan tentang teknik masking dapat rekan-rekan lihat pada link berikut ini. Karena ogut sudah pernah membahasnya dengan menggunakan Visual Studio.


Teknik masking menggunakan dua buah tekstur, yaitu tekstur image dan tekstur mask. Jika rekan-rekan masih bingung ogut sudah pernah menulis beberapa artikel yang berkaitan dengan teknik masking, semuanya dapat Anda lihat di Daftar Isi.

Untuk menamplkan burung tanpa masking source code seperti ini.

//burung tanpa masking
glBindTexture(GL_TEXTURE_2D, texture_image);
glBegin(GL_POLYGON);
glTexCoord2f(0.0f, 0.0f);glVertex2d(-350.0d,-450.0d);
        glTexCoord2f(1.0f, 0.0f);glVertex2d(150.0d,-450.0d);
        glTexCoord2f(1.0f, 1.0f);glVertex2d(150.0d,-100.0d);
        glTexCoord2f(0.0f, 1.0f);glVertex2d(-350.0d,-100.0d);
glEnd();

Dan untuk menampilkan burung dengan masking source code seperti ini.

//burung dengan masking
glEnable(GL_BLEND);
glBlendFunc(GL_DST_COLOR, GL_ZERO);
glBindTexture(GL_TEXTURE_2D, texture_mask);
glBegin(GL_POLYGON);
        glTexCoord2f(0.0f, 0.0f);glVertex2d(-100.0d,150.0d);
        glTexCoord2f(1.0f, 0.0f);glVertex2d(350.0d,150.0d);
        glTexCoord2f(1.0f, 1.0f);glVertex2d(350.0d,400.0d);
        glTexCoord2f(0.0f, 1.0f);glVertex2d(-100.0d,400.0d);
glEnd();

glBlendFunc(GL_ONE, GL_ONE);
glBindTexture(GL_TEXTURE_2D, texture_image);
glBegin(GL_POLYGON);
        glTexCoord2f(0.0f, 0.0f);glVertex2d(-100.0d,150.0d);
        glTexCoord2f(1.0f, 0.0f);glVertex2d(350.0d,150.0d);
        glTexCoord2f(1.0f, 1.0f);glVertex2d(350.0d,400.0d);
        glTexCoord2f(0.0f, 1.0f);glVertex2d(-100.0d,400.0d);
glEnd();
glDisable(GL_BLEND);

Mudah ya, tidak sulit.

Selamat Belajar rekan-rekan


Heriady




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

Kamis, 18 Mei 2017

Membuat Persegipanjang Dengan C++ Code Block


Hai semuanya...jumpa lagi dengan ogut...kali ini ogut akan membagikan program C++ sederhana dengan menggunakan Code Block. Program akan menghasilkan  penampilan seperti gambar di bawah ini.


Program merupakan gambar segiempat di koordinat kartesius 2D yang dulu pernah ogut tulis artikelnya.


Untuk membuat segiempat seperti itu hanya menggunakan perintah sederhana seperti berikut ini.

glBegin(GL_LINE_LOOP);
glVertex2d(100.0d,100.0d);  //TITIK A
        glVertex2d(500.0d,100.0d);  //TITIK B
        glVertex2d(500.0d,300.0d);  //TITIK C
        glVertex2d(100.0d,300.0d);  //TITIK D
glEnd();

Untuk rekan-rekan yang ingin belajar membuat game 2D objek segiempat seperti ini yang nantinya akan digunakan untuk menampilkan objek-objek game seperti pesawat, bom, misil dan lain-lain.



Salam


Heriady




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

Selasa, 16 Mei 2017

Code Block OpenGL Load Multi Tekstur


Halo rekan-rekan sekalian...jumpa lagi di artikel ogut yang menggunakan Code Block. Dan kali ini ogut akan memberikan contoh program me-load multi tekstur. Contoh program ini sangat bermanfaat bagi rekan-rekan yang ingin belajar membuat game 2D.

Bagi yang baru pertama kali mencoba Code Block silahkan klik link ini dahulu supaya tidak bingung.


OK langsung saja, program akan menghasilkan tampilan seperti gambar di bawah ini.Di gambar terlihat dua buah persegipanjang yang berisi tekstur kucing dan cakar kucing. Gambar kucing dan cakar kucing dibuat dari file bitmap 24 bit.


Untuk menampilkan kucing dan cakar kucing caranya sangat sederhana, perhatikanlah source di bawah ini.

 //cakar kucing
glBindTexture(GL_TEXTURE_2D, texture[1]);
    glBegin(GL_POLYGON);
        glTexCoord2f(0.0f, 0.0f);glVertex2d(-350.0d,-450.0d);
        glTexCoord2f(1.0f, 0.0f);glVertex2d(150.0d,-450.0d);
        glTexCoord2f(1.0f, 1.0f);glVertex2d(150.0d,-100.0d);
        glTexCoord2f(0.0f, 1.0f);glVertex2d(-350.0d,-100.0d);
glEnd();

//kucing
glBindTexture(GL_TEXTURE_2D, texture[0]);
    glBegin(GL_POLYGON);
        glTexCoord2f(0.0f, 0.0f);glVertex2d(-100.0d,150.0d);
        glTexCoord2f(1.0f, 0.0f);glVertex2d(350.0d,150.0d);
        glTexCoord2f(1.0f, 1.0f);glVertex2d(350.0d,400.0d);
        glTexCoord2f(0.0f, 1.0f);glVertex2d(-100.0d,400.0d);
glEnd();

Untuk Load tekstur gunakan fungsi berikut ini.

unsigned int Create_Tekstur(char *file)
{
    unsigned int IDImage;

    FILE *pFile = 0;
    BITMAPFILEHEADER BmpFileHeader;
    BITMAPINFOHEADER BmpInfoHeader;
    unsigned char *BmpImage;

    unsigned char BGR_to_RGB = 0;

    int i;

    if ((pFile = fopen(file, "rb"))==NULL)
    {
        //printf("File Not Found : %s\n",filename);
        MessageBox(NULL, file, "File Bmp tidak ditemukan, BMP Error 01", MB_OK);
        return NULL;
    }

    fread(&BmpFileHeader, sizeof(BITMAPFILEHEADER), 1, pFile);

    if(BmpFileHeader.bfType != 0x4D42)
    {
        fclose(pFile);

        MessageBox(NULL, file, "Format file bukan Bmp, BMP Error 02", MB_OK);

        return NULL;
    }

    fread(&BmpInfoHeader, sizeof(BITMAPINFOHEADER), 1, pFile);

    if(BmpInfoHeader.biSizeImage == 0)
        BmpInfoHeader.biSizeImage = BmpInfoHeader.biWidth * BmpInfoHeader.biHeight * 3;

    fseek(pFile, BmpFileHeader.bfOffBits, SEEK_SET);

    BmpImage = (unsigned char*)malloc(BmpInfoHeader.biSizeImage);

    if(!BmpImage)
    {
        free(BmpImage);
        fclose(pFile);

        MessageBox(NULL, file, "Gagal alokasi memory untuk texture, BMP Error 03", MB_OK);
        return NULL;
    }

    fread(BmpImage, 1, BmpInfoHeader.biSizeImage, pFile);

    fclose(pFile);

    if(BmpImage == 0)
    {
        MessageBox(NULL, file, "Gagal membaca data Bmp, BMP Error 04", MB_OK);

        return NULL;
    }

    for( i = 0; i < (int)BmpInfoHeader.biSizeImage; i += 3)
    {
        BGR_to_RGB = BmpImage[i];
        BmpImage[i] = BmpImage[i + 2];
        BmpImage[i + 2] = BGR_to_RGB;
    }

    if(BmpImage == 0)
    {
        MessageBox(NULL, file, "Gagal membuat RGB texture, BMP Error 05", MB_OK);
        return NULL;
    }

    //generate texture
    glGenTextures(1, &IDImage);
    glBindTexture(GL_TEXTURE_2D, IDImage);

    gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGB, BmpInfoHeader.biWidth, BmpInfoHeader.biHeight, GL_RGB, GL_UNSIGNED_BYTE, BmpImage);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, BmpInfoHeader.biWidth, BmpInfoHeader.biHeight, 0, GL_RGB, GL_UNSIGNED_BYTE, BmpImage);

    return IDImage;
}

Sampai disini dulu rekan-rekan

Salam


Heriady




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

Jumat, 28 April 2017

Tekstur Merah Dan Putih OpenGL Code Block

Lagi contoh program dengan Code Block, artikel kali ini masih menyangkut Code Block, karena program-program dengan Code Block masih sedikit yang ogut buat, oleh sebab itu ogut akan terus menambah contoh-contoh program grafik OpenGL dengan menggunakan Code Block.


Contoh program OpenGL berikut ini akan menampilkan tektur merah putih seperti yang rekan-rekan lihat pada gambar di bawah ini.

Tekstur tidak dibuat dengan file bitmap 24 bit, tetapi dengan array 64 X 64 yang diisi dengan nilai RGB 255, 255, 255 untuk menghasilkan warna putih dan nilai 255, 0, 0 untuk menghasilkan warna merah.

Bagi rekan-rekan yag belum memahami tentang RGB silahkan klik link ini untuk menuju ke artikel tentang RGB.


Untuk membuat project silahkan klik link berikut ini, karena sudah pernah ogut bahas sebelumnya.


Nah sampai disini dahulu rekan-rekan, berikut ini ogut juga sertakan source code untuk memudahkan rekan-rekan belajar, serta jangan lupa ada artikel yang terkait dengan artikel ini di bawgian bawah, serta ada link download source code nya juga di bagian bawah. Komplit nya passs.........

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

GLuint texture;

#define checkImageWidth 64
#define checkImageHeight 64
GLubyte checkImage[checkImageWidth][checkImageHeight][3];
void makeCheckImage(void)
{
    int i, j, c;
    for (i = 0; i < checkImageWidth; i++)
    {
        for (j = 0; j < checkImageHeight; j++)
        {
            c = ((((i&0x8)==0)^((j&0x8)==0)))* 255;

            if (c == 0)
            {
                //warna putih
                checkImage[i][j][0] = (GLubyte) 255;
                checkImage[i][j][1] = (GLubyte) 255;
                checkImage[i][j][2] = (GLubyte) 255;
            }
            else
            {
                //warna merah
                checkImage[i][j][0] = (GLubyte) 255;
                checkImage[i][j][1] = (GLubyte) 0;
                checkImage[i][j][2] = (GLubyte) 0;
            }
        }
    }
}


void myinit(void)
{
    makeCheckImage();

    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
    // Create Texture
    glGenTextures(1, &texture);
    glBindTexture(GL_TEXTURE_2D, texture);
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR); //
    //scale linearly when image bigger than texture
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR); //


    glTexImage2D(GL_TEXTURE_2D, 0, 3, checkImageWidth,
    checkImageHeight, 0, GL_RGB, GL_UNSIGNED_BYTE,
    &checkImage[0][0][0]);

    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
    glEnable(GL_TEXTURE_2D);
    glShadeModel(GL_FLAT);
}

void myinit(void);

LRESULT CALLBACK WindowProc(HWND, UINT, WPARAM, LPARAM);
void EnableOpenGL(HWND hwnd, HDC*, HGLRC*);
void DisableOpenGL(HWND, HDC, HGLRC);


int WINAPI WinMain(HINSTANCE hInstance,
                   HINSTANCE hPrevInstance,
                   LPSTR lpCmdLine,
                   int nCmdShow)
{
    WNDCLASSEX wcex;
    HWND hwnd;
    HDC hDC;
    HGLRC hRC;
    MSG msg;
    BOOL bQuit = FALSE;
    float theta = 0.0f;

    /* register window class */
    wcex.cbSize = sizeof(WNDCLASSEX);
    wcex.style = CS_OWNDC;
    wcex.lpfnWndProc = WindowProc;
    wcex.cbClsExtra = 0;
    wcex.cbWndExtra = 0;
    wcex.hInstance = hInstance;
    wcex.hIcon = LoadIcon(NULL, IDI_APPLICATION);
    wcex.hCursor = LoadCursor(NULL, IDC_ARROW);
    wcex.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
    wcex.lpszMenuName = NULL;
    wcex.lpszClassName = "GLSample";
    wcex.hIconSm = LoadIcon(NULL, IDI_APPLICATION);;


    if (!RegisterClassEx(&wcex))
        return 0;

    /* create main window */
    hwnd = CreateWindowEx(0,
                          "GLSample",
                          "OpenGL Sample",
                          WS_OVERLAPPEDWINDOW,
                          CW_USEDEFAULT,
                          CW_USEDEFAULT,
                          512,
                          512,
                          NULL,
                          NULL,
                          hInstance,
                          NULL);

    ShowWindow(hwnd, nCmdShow);

    /* enable OpenGL for the window */
    EnableOpenGL(hwnd, &hDC, &hRC);

    myinit();

    /* program main loop */
    while (!bQuit)
    {
        /* check for messages */
        if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
        {
            /* handle or dispatch messages */
            if (msg.message == WM_QUIT)
            {
                bQuit = TRUE;
            }
            else
            {
                TranslateMessage(&msg);
                DispatchMessage(&msg);
            }
        }
        else
        {
            /* OpenGL animation code goes here */

            glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
            glClear(GL_COLOR_BUFFER_BIT);

            glPushMatrix();
            glRotatef(theta / 5.0, 0.0f, 0.0f, 1.0f);

            glBindTexture(GL_TEXTURE_2D, texture);
            glBegin(GL_POLYGON);

                glTexCoord2f(0.0f, 0.0f);   glVertex2f(0.0f,   0.0f);
                glTexCoord2f(0.0f, 1.0f);   glVertex2f(0.0f,   1.0f);
                glTexCoord2f(1.0f, 1.0f);   glVertex2f(1.0f,   1.0f);
                glTexCoord2f(1.0f, 0.0f);   glVertex2f(1.0f,   0.0f);

            glEnd();

            glPopMatrix();

            SwapBuffers(hDC);

            theta += 1.0f;
            Sleep (1);
        }
    }

    /* shutdown OpenGL */
    DisableOpenGL(hwnd, hDC, hRC);

    /* destroy the window explicitly */
    DestroyWindow(hwnd);

    return msg.wParam;
}

LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    switch (uMsg)
    {
        case WM_CLOSE:
            PostQuitMessage(0);
        break;

        case WM_DESTROY:
            return 0;

        case WM_KEYDOWN:
        {
            switch (wParam)
            {
                case VK_ESCAPE:
                    PostQuitMessage(0);
                break;
            }
        }
        break;

        default:
            return DefWindowProc(hwnd, uMsg, wParam, lParam);
    }

    return 0;
}

void EnableOpenGL(HWND hwnd, HDC* hDC, HGLRC* hRC)
{
    PIXELFORMATDESCRIPTOR pfd;

    int iFormat;

    /* get the device context (DC) */
    *hDC = GetDC(hwnd);

    /* set the pixel format for the DC */
    ZeroMemory(&pfd, sizeof(pfd));

    pfd.nSize = sizeof(pfd);
    pfd.nVersion = 1;
    pfd.dwFlags = PFD_DRAW_TO_WINDOW |
                  PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
    pfd.iPixelType = PFD_TYPE_RGBA;
    pfd.cColorBits = 24;
    pfd.cDepthBits = 16;
    pfd.iLayerType = PFD_MAIN_PLANE;

    iFormat = ChoosePixelFormat(*hDC, &pfd);

    SetPixelFormat(*hDC, iFormat, &pfd);

    /* create and enable the render context (RC) */
    *hRC = wglCreateContext(*hDC);

    wglMakeCurrent(*hDC, *hRC);
}

void DisableOpenGL (HWND hwnd, HDC hDC, HGLRC hRC)
{
    wglMakeCurrent(NULL, NULL);
    wglDeleteContext(hRC);
    ReleaseDC(hwnd, hDC);
}


Salam


Heriady
heriady.yoh@gmail.com




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