Tampilkan postingan dengan label OpenGL. Tampilkan semua postingan

Jumat, 15 Juni 2012

Membuat Segitiga Pelangi dengan OpenGL dan Dev C++

Cerita begini, dosen kuliah komputer grafik memberi tugas pertama dengan ketentuan membuat gambar 2 dimensi (2D) dengan OpenGL, terserah bahasa program apa saja. kebetulan di komputer saya telah terinstal Dev C++, nah tinggal nambahi library OpenGl dech. untuk cara menginstal OpenGL di Dev C++, silakan ikuti Tutorial Instalasi OpenGL di Dev C++.
nah, kalo di Dev C++ sudah terinstal OpenGL silakan mencoba tutorial berikut.

Klik File --> New --> Projec

Baca selengkapnya »

Kamis, 14 Juni 2012

Latihan 3

Baca selengkapnya »

Latihan 2

#include
#include "stdio.h"
#include "math.h"

GLfloat moveX=1.0,moveY=0.0,moveZ=0.0;

void init() {

glEnable(GL_DEPTH_TEST);
glShadeModel(GL_FLAT);
glClearColor(0,0,0,0); // Mengubah Warna Latar Belakang
}

void display() {
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
gluLookAt(moveX,moveY,moveZ,0.0,0.0,0.0,0.0,1.0,0.0);
printf("X: %f, Y: %f, Z: %f\n",moveX,moveY,moveZ);

//Gambar 1 Kiri
glColor3f(1.0f,1.0f,0.0f);// Mengubah Warna Kotak Luar
glTranslated(0.0,0.75,5.0);
glutWireCube(1.2);
glBegin(GL_POLYGON); //Menggambar Tutup Atas
glColor3f(1,1,0);
glVertex3f(0.5,0.5,0.5);
glVertex3f(0.5,0.5,-0.5);
glVertex3f(-0.5,0.5,-0.5);
glVertex3f(-0.5,0.5,0.5);
glEnd();

glBegin(GL_POLYGON); //Menggambar Tutup Bawah
glColor3f(1,0,0);
glVertex3f(-0.5,-0.5,-0.5);
glVertex3f(-0.5,-0.5,0.5);
glVertex3f(0.5,-0.5,0.5);
glVertex3f(0.5,-0.5,-0.5);
glEnd();

glBegin(GL_QUADS);
glColor3f(0.0f,0.0f,1.0f);
glVertex3f(0.5f,-0.5f,0.5f);
glVertex3f(0.5f,0.5f,0.5f);
glVertex3f(0.5f,0.5f,-0.5f);
glVertex3f(0.5f,-0.5f,-0.5f);

glColor3f(0.0f,1.0f,0.0f);
glVertex3f(-0.5f,0.5f,-0.5f);
glVertex3f(-0.5f,-0.5f,-0.5f);
glVertex3f(0.5f,-0.5f,-0.5f);
glVertex3f(0.5f,0.5f,-0.5f);

glColor3f(1.0f,1.0f,1.0f);
glVertex3f(0.5,-0.5,0.5);
glVertex3f(0.5,0.5,0.5);
glVertex3f(-0.5,0.5,0.5);
glVertex3f(-0.5,-0.5,0.5);
glEnd();

//Gambar 1 bawah
glColor3f(1.0f,1.0f,0.0f);
glTranslated(0.0,-1.5,0.0);
glutWireCube(1.2);
glBegin(GL_POLYGON);
glColor3f(1,1,0);
glVertex3f(0.5,0.5,0.5);
glVertex3f(0.5,0.5,-0.5);
glVertex3f(-0.5,0.5,-0.5);
glVertex3f(-0.5,0.5,0.5);
glEnd();

glBegin(GL_POLYGON);
glColor3f(1,0,0);
glVertex3f(-0.5,-0.5,-0.5);
glVertex3f(-0.5,-0.5,0.5);
glVertex3f(0.5,-0.5,0.5);
glVertex3f(0.5,-0.5,-0.5);
glEnd();

glBegin(GL_QUADS);
glColor3f(0.0f,0.0f,1.0f);
glVertex3f(0.5f,-0.5f,0.5f);
glVertex3f(0.5f,0.5f,0.5f);
glVertex3f(0.5f,0.5f,-0.5f);
glVertex3f(0.5f,-0.5f,-0.5f);

glColor3f(0.0f,1.0f,0.0f);
glVertex3f(-0.5f,0.5f,-0.5f);
glVertex3f(-0.5f,-0.5f,-0.5f);
glVertex3f(0.5f,-0.5f,-0.5f);
glVertex3f(0.5f,0.5f,-0.5f);

glColor3f(1.0f,1.0f,1.0f);
glVertex3f(0.5,-0.5,0.5);
glVertex3f(0.5,0.5,0.5);
glVertex3f(-0.5,0.5,0.5);
glVertex3f(-0.5,-0.5,0.5);
glEnd();

//Gambar 2
glColor3f(1.0f,1.0f,0.0f);
glTranslated(0.0,1.5,-3.0);
glutWireCube(1.2);
glBegin(GL_POLYGON);
glColor3f(1,1,0);
glVertex3f(0.5,0.5,0.5);
glVertex3f(0.5,0.5,-0.5);
glVertex3f(-0.5,0.5,-0.5);
glVertex3f(-0.5,0.5,0.5);
glEnd();

glBegin(GL_POLYGON);
glColor3f(1,0,0);
glVertex3f(-0.5,-0.5,-0.5);
glVertex3f(-0.5,-0.5,0.5);
glVertex3f(0.5,-0.5,0.5);
glVertex3f(0.5,-0.5,-0.5);
glEnd();

glBegin(GL_QUADS);
glColor3f(0.0f,0.0f,1.0f);
glVertex3f(0.5f,-0.5f,0.5f);
glVertex3f(0.5f,0.5f,0.5f);
glVertex3f(0.5f,0.5f,-0.5f);
glVertex3f(0.5f,-0.5f,-0.5f);

glColor3f(0.0f,1.0f,0.0f);
glVertex3f(-0.5f,0.5f,-0.5f);
glVertex3f(-0.5f,-0.5f,-0.5f);
glVertex3f(0.5f,-0.5f,-0.5f);
glVertex3f(0.5f,0.5f,-0.5f);

glColor3f(1.0f,1.0f,1.0f);
glVertex3f(0.5,-0.5,0.5);
glVertex3f(0.5,0.5,0.5);
glVertex3f(-0.5,0.5,0.5);
glVertex3f(-0.5,-0.5,0.5);
glEnd();

//Gambar 2 bawah
glColor3f(1.0f,1.0f,0.0f);
glTranslated(0.0,-1.5,0.0);
glutWireCube(1.2);
glBegin(GL_POLYGON);
glColor3f(1,1,0);
glVertex3f(0.5,0.5,0.5);
glVertex3f(0.5,0.5,-0.5);
glVertex3f(-0.5,0.5,-0.5);
glVertex3f(-0.5,0.5,0.5);
glEnd();

glBegin(GL_POLYGON);
glColor3f(1,0,0);
glVertex3f(-0.5,-0.5,-0.5);
glVertex3f(-0.5,-0.5,0.5);
glVertex3f(0.5,-0.5,0.5);
glVertex3f(0.5,-0.5,-0.5);
glEnd();

glBegin(GL_QUADS);
glColor3f(0.0f,0.0f,1.0f);
glVertex3f(0.5f,-0.5f,0.5f);
glVertex3f(0.5f,0.5f,0.5f);
glVertex3f(0.5f,0.5f,-0.5f);
glVertex3f(0.5f,-0.5f,-0.5f);

glColor3f(0.0f,1.0f,0.0f);
glVertex3f(-0.5f,0.5f,-0.5f);
glVertex3f(-0.5f,-0.5f,-0.5f);
glVertex3f(0.5f,-0.5f,-0.5f);
glVertex3f(0.5f,0.5f,-0.5f);

glColor3f(1.0f,1.0f,1.0f);
glVertex3f(0.5,-0.5,0.5);
glVertex3f(0.5,0.5,0.5);
glVertex3f(-0.5,0.5,0.5);
glVertex3f(-0.5,-0.5,0.5);
glEnd();

//Gambar 3
glColor3f(1.0f,1.0f,0.0f);
glTranslated(0.0,1.5,-3.0);
glutWireCube(1.2);
glBegin(GL_POLYGON);
glColor3f(1,1,0);
glVertex3f(0.5,0.5,0.5);
glVertex3f(0.5,0.5,-0.5);
glVertex3f(-0.5,0.5,-0.5);
glVertex3f(-0.5,0.5,0.5);
glEnd();

glBegin(GL_POLYGON);
glColor3f(1,0,0);
glVertex3f(-0.5,-0.5,-0.5);
glVertex3f(-0.5,-0.5,0.5);
glVertex3f(0.5,-0.5,0.5);
glVertex3f(0.5,-0.5,-0.5);
glEnd();

glBegin(GL_QUADS);
glColor3f(0.0f,0.0f,1.0f);
glVertex3f(0.5f,-0.5f,0.5f);
glVertex3f(0.5f,0.5f,0.5f);
glVertex3f(0.5f,0.5f,-0.5f);
glVertex3f(0.5f,-0.5f,-0.5f);

glColor3f(0.0f,1.0f,0.0f);
glVertex3f(-0.5f,0.5f,-0.5f);
glVertex3f(-0.5f,-0.5f,-0.5f);
glVertex3f(0.5f,-0.5f,-0.5f);
glVertex3f(0.5f,0.5f,-0.5f);

glColor3f(1.0f,1.0f,1.0f);
glVertex3f(0.5,-0.5,0.5);
glVertex3f(0.5,0.5,0.5);
glVertex3f(-0.5,0.5,0.5);
glVertex3f(-0.5,-0.5,0.5);
glEnd();

//Gambar 3 bawah
glColor3f(1.0f,1.0f,0.0f);
glTranslated(0.0,-1.5,0.0);
glutWireCube(1.2);
glBegin(GL_POLYGON);
glColor3f(1,1,0);
glVertex3f(0.5,0.5,0.5);
glVertex3f(0.5,0.5,-0.5);
glVertex3f(-0.5,0.5,-0.5);
glVertex3f(-0.5,0.5,0.5);
glEnd();

glBegin(GL_POLYGON);
glColor3f(1,0,0);
glVertex3f(-0.5,-0.5,-0.5);
glVertex3f(-0.5,-0.5,0.5);
glVertex3f(0.5,-0.5,0.5);
glVertex3f(0.5,-0.5,-0.5);
glEnd();

glBegin(GL_QUADS);
glColor3f(0.0f,0.0f,1.0f);
glVertex3f(0.5f,-0.5f,0.5f);
glVertex3f(0.5f,0.5f,0.5f);
glVertex3f(0.5f,0.5f,-0.5f);
glVertex3f(0.5f,-0.5f,-0.5f);

glColor3f(0.0f,1.0f,0.0f);
glVertex3f(-0.5f,0.5f,-0.5f);
glVertex3f(-0.5f,-0.5f,-0.5f);
glVertex3f(0.5f,-0.5f,-0.5f);
glVertex3f(0.5f,0.5f,-0.5f);

glColor3f(1.0f,1.0f,1.0f);
glVertex3f(0.5,-0.5,0.5);
glVertex3f(0.5,0.5,0.5);
glVertex3f(-0.5,0.5,0.5);
glVertex3f(-0.5,-0.5,0.5);
glEnd();

//Gambar 4
glColor3f(1.0f,1.0f,0.0f);
glTranslated(0.0,1.5,-3.0);
glutWireCube(1.2);
glBegin(GL_POLYGON);
glColor3f(1,1,0);
glVertex3f(0.5,0.5,0.5);
glVertex3f(0.5,0.5,-0.5);
glVertex3f(-0.5,0.5,-0.5);
glVertex3f(-0.5,0.5,0.5);
glEnd();

glBegin(GL_POLYGON);
glColor3f(1,0,0);
glVertex3f(-0.5,-0.5,-0.5);
glVertex3f(-0.5,-0.5,0.5);
glVertex3f(0.5,-0.5,0.5);
glVertex3f(0.5,-0.5,-0.5);
glEnd();

glBegin(GL_QUADS);
glColor3f(0.0f,0.0f,1.0f);
glVertex3f(0.5f,-0.5f,0.5f);
glVertex3f(0.5f,0.5f,0.5f);
glVertex3f(0.5f,0.5f,-0.5f);
glVertex3f(0.5f,-0.5f,-0.5f);

glColor3f(0.0f,1.0f,0.0f);
glVertex3f(-0.5f,0.5f,-0.5f);
glVertex3f(-0.5f,-0.5f,-0.5f);
glVertex3f(0.5f,-0.5f,-0.5f);
glVertex3f(0.5f,0.5f,-0.5f);

glColor3f(1.0f,1.0f,1.0f);
glVertex3f(0.5,-0.5,0.5);
glVertex3f(0.5,0.5,0.5);
glVertex3f(-0.5,0.5,0.5);
glVertex3f(-0.5,-0.5,0.5);
glEnd();

//Gambar 4 bawah
glColor3f(1.0f,1.0f,0.0f);
glTranslated(0.0,-1.5,0.0);
glutWireCube(1.2);
glBegin(GL_POLYGON);
glColor3f(1,1,0);
glVertex3f(0.5,0.5,0.5);
glVertex3f(0.5,0.5,-0.5);
glVertex3f(-0.5,0.5,-0.5);
glVertex3f(-0.5,0.5,0.5);
glEnd();

glBegin(GL_POLYGON);
glColor3f(1,0,0);
glVertex3f(-0.5,-0.5,-0.5);
glVertex3f(-0.5,-0.5,0.5);
glVertex3f(0.5,-0.5,0.5);
glVertex3f(0.5,-0.5,-0.5);
glEnd();

glBegin(GL_QUADS);
glColor3f(0.0f,0.0f,1.0f);
glVertex3f(0.5f,-0.5f,0.5f);
glVertex3f(0.5f,0.5f,0.5f);
glVertex3f(0.5f,0.5f,-0.5f);
glVertex3f(0.5f,-0.5f,-0.5f);

glColor3f(0.0f,1.0f,0.0f);
glVertex3f(-0.5f,0.5f,-0.5f);
glVertex3f(-0.5f,-0.5f,-0.5f);
glVertex3f(0.5f,-0.5f,-0.5f);
glVertex3f(0.5f,0.5f,-0.5f);

glColor3f(1.0f,1.0f,1.0f);
glVertex3f(0.5,-0.5,0.5);
glVertex3f(0.5,0.5,0.5);
glVertex3f(-0.5,0.5,0.5);
glVertex3f(-0.5,-0.5,0.5);
glEnd();

glutSwapBuffers();

}

void reshape(int w, int h) {

glViewport(0,0,w,h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-7.0,7.0,-1.5,1.5,-9.0,9.0);// Mengubah Ukuran
}

void MyKeyboard(unsigned char key, int x,int y) {

if (key == '1')
moveY+=0.1;
if (key == '2')
moveY-=0.1;
if (key == '3')
moveZ+=0.1;
if (key == '4')
moveZ-=0.1;
glutPostRedisplay();
}

int main(int argc, char* argv[])
{
printf("M.W Andryan | 09.10.031.802.156 |IV_A Malam...= ");
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutInitWindowSize(900,600);
glutInitWindowPosition(10,10);
glutCreateWindow("OpenGL - 3D Balok");
glutReshapeFunc(reshape);
glutDisplayFunc(display);
glutKeyboardFunc(MyKeyboard);

init();
glutMainLoop();
return 0;
}

By. M W Andryan Rv -- Mhs -- Stmik-Amik-Riau

Latihan 1

// Silahkan Di Coba..
//Tekan s Untuk Menghapus Titik Terakhir
//Tekan a Untuk Menghapus Titik Pertama
//Tekan x Untuk Exit
#include
#include

#include
#include

#define MaxNumPts 5 //Jumlah Titik
float PointArray[MaxNumPts][2];
int NumPts = 0;

void myKeyboardFunc( unsigned char key, int x, int y );
void myMouseFunc( int button, int state, int x, int y );

void displayLines(void);
void removeFirstPoint();
void removeLastPoint();
void addNewPoint( float x, float y );

void initRendering();
void resizeWindow(int w, int h);

// Besar Windows Dalam Pixel
int WindowHeight;
int WindowWidth;

void myKeyboardFunc (unsigned char key, int x, int y)
{
switch (key) {
case 'a':
removeFirstPoint();
glutPostRedisplay();
break;
case 's':
removeLastPoint();
glutPostRedisplay();
break;
case 'x': //
exit(0);
break;
}
}

void removeFirstPoint() {
int i;
if ( NumPts>0 ) {
// Menghapus Titik Awal
NumPts--;
for ( i=0; i PointArray[i][0] = PointArray[i+1][0];
PointArray[i][1] = PointArray[i+1][1];
}
}
}

// Menekan tombol Kiri menempatkan titik kontrol.
void myMouseFunc( int button, int state, int x, int y ) {
if ( button==GLUT_LEFT_BUTTON && state==GLUT_DOWN ) {
float xPos = ((float)x)/((float)(WindowWidth-1));
float yPos = ((float)y)/((float)(WindowHeight-1));

yPos = 1.0f-yPos; // Membalik nilai karena posisi y adalah dari baris atas.

addNewPoint( xPos, yPos );
glutPostRedisplay();
}
}

// Menambahkan titik baru ke akhir daftar.
// Hapus titik pertama dalam daftar jika terlalu banyak poin.
void removeLastPoint() {
if ( NumPts>0 ) {
NumPts--;
}
}

// Menambahkan titik baru ke akhir daftar.
// Hapus titik pertama dalam daftar jika poin terlalu banyak.
void addNewPoint( float x, float y ) {
if ( NumPts>=MaxNumPts ) {
removeFirstPoint();
}
PointArray[NumPts][0] = x;
PointArray[NumPts][1] = y;
NumPts++;
}

void displayLines(void)
{
int i;

glClear(GL_COLOR_BUFFER_BIT);

// Menggambar Segment Garis
glColor3f(0.0f, 1.0f, 0.0f); // Warna Hijau Untuk Garis
if ( NumPts>1 ) {
glBegin( GL_LINE_STRIP );
for ( i=0; i glVertex2f( PointArray[i][0], PointArray[i][1] );
}
glEnd();
}

// Menggambar Titik.
glColor3f( 1.0f, 1.0f, 1.0f); // Warna Putih Untuk Titik
glBegin( GL_POINTS );
for ( i=0; i glVertex2f( PointArray[i][0], PointArray[i][1] );
}
glEnd();

glFlush();
}

void initRendering() {
//Peroses Percetakan
glClearColor( 0.0f, 0.0f, 0.0f, 0.0f );//Warna Latar

glPointSize(10);// Membuat Besar Titik
glLineWidth(5);//Membuat Besat Garis

glEnable(GL_POINT_SMOOTH);
glEnable(GL_LINE_SMOOTH);
glHint(GL_POINT_SMOOTH_HINT, GL_NICEST); // Membuat Titik Bilat
glHint(GL_LINE_SMOOTH_HINT, GL_NICEST); // Membuat Garis
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
}

void resizeWindow(int w, int h)
{
WindowHeight = (h>1) ? h : 2;
WindowWidth = (w>1) ? w : 2;
glViewport(0, 0, (GLsizei) w, (GLsizei) h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0.0f, 1.0f, 0.0f, 1.0f); // Selalu Tampilkan [0,1]x[0,1].
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
}

int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB );
glutInitWindowSize(600, 600);
glutInitWindowPosition(200, 100);
glutCreateWindow(argv[0]);
initRendering();

glutDisplayFunc(displayLines);
glutReshapeFunc(resizeWindow);
glutKeyboardFunc(myKeyboardFunc);
glutMouseFunc(myMouseFunc);
glutMainLoop();

return 0; // Selalu Jalankan Hingga Akhir
}

by. Dedy Apry --Mhs -- Stmik-Amik Riau

Sabtu, 02 Juli 2011

OpenGL Keyboard Interaksi (Versi 2.0)

Pengenalan

Keyboard adalah salah satu hal yang penting untuk game komputer, dan menggunakan komputer secara umum. Bisakah Anda bayangkan mencoba untuk mengetik dengan mouse? Atau jumlah tombol yang akan diperlukan pada mouse untuk memungkinkan pergerakan * dan * memotret di First Person Shooter? Kabar baiknya adalah bahwa keyboard interaksi, berkat GLUT, adalah hal yang sangat mudah untuk menangani. Saya akan melihat 2 GLUT yang berbeda metode untuk menekan tombol, satu untuk ketika tombol pertama ditekan, dan satu untuk ketika tombol dilepaskan. Kemudian saya akan menunjukkan bagaimana untuk melakukan beberapa penyangga kunci untuk memungkinkan penekanan tombol sekaligus.

Coding

Tekan tombol

Untuk memulai dengan keyboard, sama seperti kami menciptakan tampilan dan membentuk metode untuk GLUT untuk digunakan, kita akan perlu membangun metode .Yang pertama metode kita akan berurusan dengan adalah menekan tombol metode , inimetode yang akan memberitahu kita yang saat ini tombol ditekan.

Saya akan nama ini metode keyPressed dan menyatakan GLUT bahwa ia memiliki 3 parameter, satu untuk kunci yang saat ini ditekan, dan dua lagi yang memberikan kita lokasimouse saat kunci itu ditekan

tampilan biasa copy ke clipboard cetak ?
kekosongan  keyPressed (unsigned  arang  kunci,  int  x,  int  y) {  
}  

Sekarang kita telah kosong metode , mari kita pergi ke depan dan memberikan ini informasiuntuk GLUT untuk digunakan. Down di utama kami metode , kita akan mengakses glutKeyboardFunc metode dan pasokan dengan kami metode .

tampilan biasa copy ke clipboard cetak ?
glutKeyboardFunc (keyPressed);  / / Katakan GLUT untuk menggunakan  metode  "keyPressed" untuk penekanan tombol  

Dan itu cukup banyak semua ada untuk itu.

Dalam rangka untuk akses yang mereka tombol ditekan, di dalam keyPressed Anda metodeAnda dapat menggunakan salah pernyataan switch atau 'jika' pernyataan, yang memeriksa mereka variabel kunci terhadap karakter ASCII yang ingin Anda periksa , dan akan terlihat seperti ini:

tampilan biasa copy ke clipboard cetak ?
Jika (tombol == 'a') {  / / Jika mereka 'sebuah' tombol ditekan  
/ / Lakukan tindakan yang terkait dengan 'a' kunci  
}  

Tombol Up

Fungsi tombol register sampai ketika tombol dilepaskan. Ini dapat sangat berguna untuk pengaturan beberapa nilai ketika kunci pertama ditekan, dan ingin menjaga nilai itu sampai tombol dilepaskan. Sekali lagi, karena hal ini ditangani oleh GLUT, kita perlu pergi dan membuat metode untuk menangani hal ini, dan hanya seperti keyPressed metode , yang satu ini akan mengambil dalam 3 parameter. Ketiga parameter yang persis sama dengan 3 dalam keyPressed metode . Tapi kita akan menyebutnya metode keyup. Jadi mari kita pergi ke depan dan membuat metode untuk ini.

tampilan biasa copy ke clipboard cetak ?
kekosongan  keyup (unsigned  arang  kunci,  int  x,  int  y) {  
}  

Dan sekali lagi kita perlu mendaftarkan metode dengan GLUT, dan kali ini kita akan menggunakan glutKeyboardUpFunc metode .

tampilan biasa copy ke clipboard cetak ?
glutKeyboardUpFunc (keyup);  / / Katakan GLUT untuk menggunakan metode  "keyup" sampai kunci  peristiwa  

Untuk menggunakan keyup metode , persis sama dengan menggunakan keyPressedmetode , sehingga kita dapat memanggil kode yang sama persis jika kita ingin.

tampilan biasa copy ke clipboard cetak ?
jika  (tombol ==  'a' ) {  / / Jika mereka 'sebuah' kunci dirilis  
/ / Lakukan tindakan yang terkait dengan 'a' kunci  
}  

Kunci Buffer

Langkah berikutnya adalah tentu saja , untuk melakukan beberapa penyangga utama, yang akan memungkinkan kita untuk menangani penekanan tombol beberapa di kemudian kamiOpenGL proyek. Seperti yang Anda mungkin menyadari, variabel char adalah sama dengan byte dan dapat mengambil nilai integer dari 0 hingga 255. Hal ini karena variabel arang memiliki ukuran 2, ^ 8 atau 256. Hal ini memungkinkan kita untuk menangani hingga 256 tombol berbeda pada keyboard, atau set karakter ASCII seluruh.

Jadi mari kita mulai dengan menciptakan sebuah array dari nilai Boolean yang akan memegang negara-negara kunci kami. Benar akan ditekan, dan False akan tidak ditekan.Aku akan menyebutnya keyStates variabel karena mudah dimengerti.

tampilan biasa copy ke clipboard cetak ?
bool * keyStates =  baru  bool [256];  / / Membuat sebuah array nilai boolean panjang 256 (0-255)  

Dan sekarang di keyPressed kami metode , mari kita tambahkan baris baru, yang akan menetapkan nilai dari kunci yang kita miliki ditekan. Ini hanya menetapkan posisi saat ini dalam array keyStates, pada posisi kunci saat ditekan, ke true.

tampilan biasa copy ke clipboard cetak ?
kekosongan  keyPressed (unsigned  arang  kunci,  int  x,  int  y) {  
keyStates [key] =  true ;  / / Mengatur negara dari kunci saat ini untuk menekan  
}  

Dan sekarang kita hanya perlu menambahkan hampir kode yang sama persis dengan keyup metode yang kita buat sebelumnya. Hanya saja kali ini, kita akan menetapkan keadaan kunci saat ini menjadi false, artinya tidak lagi ditekan.

tampilan biasa copy ke clipboard cetak ?
kekosongan  keyup (unsigned  arang  kunci,  int  x,  int  y) {  
keyStates [key] =  palsu ;  / / Mengatur negara dari kunci saat ini untuk tidak ditekan  
}  

Semua yang tersisa sekarang untuk kita untuk belajar adalah bagaimana untuk benar-benar menggunakan ini. Kabar baiknya adalah bahwa sekarang bahwa Anda memiliki kunciinformasi , Anda dapat menggunakannya namun Anda inginkan, Anda hanya perlu men-setup suatu tempat dalam kode Anda untuk mengelola ini. Aku akan pergi melalui contoh ini untuk Anda mulai.

Untuk melakukan hal ini, saya akan membuat yang lain metode , kali ini disebut keyOperations, di mana kita akan memeriksa yang tombol telah ditekan, dan kemudian melakukan tindakan mereka. Ini Metode tidak perlu kembali apa-apa, dan tidak perlu menerima parameter apapun. Hanya menyatakan sebelum Anda tampilan () metode , karena kita benar-benar akan menyebutnya dari kami menampilkan metode .

tampilan biasa copy ke clipboard cetak ?
kekosongan  keyOperations ( batal ) {  
}  

Dan seperti yang kita panggil ini dari kami menampilkan metode , maju dan menyebutnya dari awal sangat kami menampilkan metode , sebaiknya sebelum segala sesuatu yang lain.Alasan saya mengatakan menyebutnya sebelum segala sesuatu yang lain, adalah jika Anda menyebutnya setengah melalui render Anda, maka setengah dari membuat Anda akan terpengaruh oleh nilai-nilai diperbarui oleh penekanan tombol, dan setengah lainnya membuat Anda tidak akan terpengaruh, memberikan ketidakcocokan dan artefak mungkin.

tampilan biasa copy ke clipboard cetak ?
kekosongan  layar  ( kosong ) {  
keyOperations ();  
glClearColor (1.0f, 0.0f, 0.0f, 1.0f);  / / Hapus latar belakang  jendela "href =" http://www.swiftless.com/tutorials/opengl/ jendela . html " >jendela  untuk merah  
...  
}  

Akhirnya, kita mengisi keyOperations kami metode dengan sejumlah besar jika laporan untuk memeriksa apakah tombol kita ingin ditekan, dan kemudian melakukan tindakan yang diperlukan.

tampilan biasa copy ke clipboard cetak ?
kekosongan  keyOperations ( batal ) {  
jika  (keyStates [ 'a' ]) {  / / Jika 'a' tombol telah ditekan  
/ / Lakukan 'a' operasi kunci  
}  
}  

Tombol Khusus

Sementara semua di atas adalah sempurna baik untuk menggunakan penekanan tombol yang biasa, ada beberapa kunci Anda mungkin ingin menggunakan, misalnya, tombol panah, yang dapat diwakili berbeda pada beberapa sistem. Untungnya, GLUT memungkinkan kita untuk menggunakan kunci ini, asalkan kita sebut berbeda metode untuk glutKeyboardFunc. Sebaliknya, kita harus menggunakan glutSpecialFunc yang memeriksa penekanan tombol khusus. Sebagai contoh, jika kita ingin mengecek apakah panah kiri telah ditekan, kita dapat menggunakan GLUT_KEY_LEFT. Kabar terbaik adalah bahwametode yang Anda buat untuk menangani tombol khusus Anda, akan hampir identik dengan glutKeyboardFunc metode Anda buat sebelumnya. Di bawah ini adalah contoh penggunaan tombol khusus.

Pertama, membuat baru metode yang saya akan menelepon keySpecial, yang mengambil tiga parameter, semuanya menjadi nilai integer, pertama untuk tombol ditekan, dan dua detik adalah untuk posisi x dan y mouse di saat itu metode yang disebut. Dan kemudian menyebutnya metode utama kami dalam metode bersama dengan sisa penekanan tombol kita.

tampilan biasa copy ke clipboard cetak ?
kekosongan  keySpecial ( int  kunci,  int  x,  int  y) {  
  
}  

Dan kemudian untuk fungsi untuk tombol khusus, menyatakan baru metode untuk menangani sampai acara untuk kunci khusus.

tampilan biasa copy ke clipboard cetak ?
kekosongan  keySpecialUp ( int  kunci,  int  x,  int  y) {  
  
}  

tampilan biasa copy ke clipboard cetak ?
int  main ( int  argc,  arang  ** argv) {  
...  
glutReshapeFunc (membentuk kembali);  / / Katakan GLUT untuk menggunakan metode "membentuk kembali" untuk membentuk kembali  
  
glutKeyboardFunc (keyPressed);  / / Katakan GLUT untuk menggunakan metode "keyPressed" untuk penekanan tombol  
glutKeyboardUpFunc (keyup);  / / Katakan GLUT untuk menggunakan metode "keyup" untuk kejadian-kejadian kunci  
  
glutSpecialFunc (keySpecial);  / / Katakan GLUT untuk menggunakan metode "keySpecial" untuk menekan tombol khusus  
glutSpecialUpFunc (keySpecialUp);  / / Katakan GLUT untuk menggunakan metode "keySpecialUp" untuk kejadian-kejadian kunci khusus  
  
glutMainLoop ();  / / Masukkan loop utama GLUT itu  
}  

Jika Anda ingin untuk buffer kunci ini, Anda dapat membuat array lain sama seperti yang kami lakukan untuk buffering kunci biasa, dan mendedikasikan array ini untuk setiap tombol khusus ditekan.

tampilan biasa copy ke clipboard cetak ?
bool * keySpecialStates =  baru  bool [246];  / / Membuat sebuah array nilai boolean panjang 256 (0-255)  

Setelah Anda membuat array ini, pastikan Anda menetapkan nilai-nilai ke benar dan palsu, seperti yang Anda lakukan dalam metode kunci biasa, dan kemudian membuat metode lain untuk mengendalikan apa yang terjadi ketika kita menekan tombol khusus kami, saya menelepon keySpecialOperations tambang, yang sudah memiliki kode untuk memeriksa apakah tombol panah kiri telah ditekan.

tampilan biasa copy ke clipboard cetak ?
kekosongan  keySpecialOperations ( batal ) {  
jika  (keySpecialStates [GLUT_KEY_LEFT]) {  / / Jika tombol panah kiri telah ditekan  
/ / Lakukan operasi tombol panah kiri  
}  
}  

Mudah-mudahan ini telah membantu Anda mendapatkan pemahaman tentang bagaimana mengelola menekan kunci dalam GLUT dan OpenGL sehingga Anda bisa mendapatkan beberapa interaksi keyboard yang terjadi di tutorial selanjutnya.

Jika Anda memiliki pertanyaan, silakan email saya di swiftless@gmail.com

Tutorial Kode

tampilan biasa copy ke clipboard cetak ?
# Include  
# Include  
  
bool * keyStates =  baru  bool [256];  / / Membuat sebuah array nilai boolean panjang 256 (0-255)  
  
kekosongan  keyOperations ( batal ) {  
jika  (keyStates [ 'a' ]) {  / / Jika 'a' tombol telah ditekan  
/ / Lakukan 'a' operasi kunci  
}  
}  
  
kekosongan  layar ( kosong ) {  
keyOperations ();  
  
glClearColor (1.0f, 0.0f, 0.0f, 1.0f);  / / Hapus latar belakang  jendela  untuk merah  
glClear (GL_COLOR_BUFFER_BIT);  / / Hapus buffer warna (buffer lebih di kemudian hari)  
glLoadIdentity ();  / / Load Matrix Identitas untuk mereset lokasi gambar kami  
  
glFlush ();  / / Bersihkan buffer OpenGL untuk jendela  
}  
  
kekosongan  membentuk kembali ( int  lebar,  int  tinggi) {  
glViewport (0, 0, (GLsizei), lebar (GLsizei) tinggi);  / / Set viewport kita dengan ukuran jendela kita  
glMatrixMode (GL_PROJECTION);  / / Beralih ke matriks proyeksi sehingga kita dapat memanipulasi bagaimana adegan kami dilihat  
glLoadIdentity ();  / / Reset matriks proyeksi dengan matriks identitas sehingga kita tidak mendapatkan artefak (membersihkan)  
gluPerspective (60, (GLfloat) lebar / (GLfloat) tinggi, 1,0, 100,0);  / / Set Bidang sudut pandang (dalam derajat), rasio aspek jendela kami, dan pesawat baru dan jauh  
glMatrixMode (GL_MODELVIEW);  / / Beralih kembali ke matriks melihat model, sehingga kita dapat mulai menggambar bentuk dengan benar  
}  
  
kekosongan  keyPressed (unsigned  arang  kunci,  int  x,  int  y) {  
keyStates [key] =  true ;  / / Mengatur negara dari kunci saat ini untuk menekan  
}  
  
kekosongan  keyup (unsigned  arang  kunci,  int  x,  int  y) {  
keyStates [key] =  palsu ;  / / Mengatur negara dari kunci saat ini untuk tidak ditekan  
}  
  
int  main ( int  argc,  arang  ** argv) {  
glutInit (& argc, argv);  / / Inisialisasi GLUT  
glutInitDisplayMode (GLUT_SINGLE);  / / Mengatur tampilan dasar penyangga (buffer hanya satu untuk sekarang)  
glutInitWindowSize (500, 500);  / / Set lebar dan tinggi jendela  
glutInitWindowPosition (100, 100);  / / Mengatur posisi jendela  
glutCreateWindow ( "Kau pertama OpenGL Jendela" );  / / Mengatur judul untuk jendela  
  
glutDisplayFunc (tampilan);  / / Katakan GLUT untuk menggunakan metode "layar" untuk rendering  
  
glutReshapeFunc (membentuk kembali);  / / Katakan GLUT untuk menggunakan metode "membentuk kembali" untuk membentuk kembali  
  
glutKeyboardFunc (keyPressed);  / / Katakan GLUT untuk menggunakan metode "keyPressed" untuk penekanan tombol  
glutKeyboardUpFunc (keyup);  / / Katakan GLUT untuk menggunakan metode "keyup" untuk kejadian-kejadian kunci  
  
glutMainLoop ();  / / Masukkan loop utama GLUT itu  
}  

Kumpulan Bahan Kuliah

Menu

Blog Archive

CS

ONLINE YM

FOLLOWERS