szit

Felhasználói eszközök

Eszközök a webhelyen

Itt vagy: start » oktatas » programozas » opengl » opengl_glut_linuxon
Nyomvonal: • opengl_glut_linuxon
oktatas:programozas:opengl:opengl_glut_linuxon

Tartalomjegyzék

< OpenGL

OpenGL GLUT Linuxon

A GLUT

A GLUT lehetővé teszi egyszerű OpenGL programok írását. A GLUT tartalmaz eseménykezelési lehetőségeket, egér és billentyűzetfigyelés. A GLUT használatához emeled be a forráskódba a glut.h vagy a freeglut.h fejléc fájlokat. 

#include <GL/gl.h>
#include <GL/glut.h>

Szükséges csomagok telepítése

apt install libglu1-mesa-dev freeglut3-dev mesa-common-dev

Első program

elso.cpp
#include <GL/glut.h>
 
void display(void) {
    glClear(GL_COLOR_BUFFER_BIT);
    glColor3f(0.5, 0.5, 0.0);
    glBegin(GL_LINES);
        glVertex3f(-0.5, 0.0, 0.0);
        glVertex3f(0.5, 0.0, 0.0);
    glEnd();
    glFlush();
}
 
int main(int argc, char** argv) {
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_SINGLE);
    glutInitWindowSize(640, 450);
    glutInitWindowPosition(200, 200);
    glutCreateWindow("Hello Vilag!");
    glutDisplayFunc(display);
    glutMainLoop();
    return 0;
}

Fordítás: 

g++ elso.cpp -o elso -lglut -lGLU -lGL

Futtatás: 

./elso

OpenGL glut

main.cpp
#include <GL/glut.h>
 
void displayTriangle(void) {
    glClear(GL_COLOR_BUFFER_BIT);
    glColor3f(0.0, 0.0, 0.8);
    glBegin(GL_POLYGON);
        glVertex3f(-1.0, -0.5, -0.4);
        glVertex3f(1.0, -0.5, -0.4);
        glVertex3f(0.0, 0.5, -0.4);
    glEnd();
    glFlush();
}
 
int main(int argc, char** argv) {
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_SINGLE);
    glutInitWindowSize(640, 450);
    glutInitWindowPosition(200, 200);
    glutCreateWindow("Helló Világ!");
    glutDisplayFunc(displayTriangle);
    glutMainLoop();
    return 0;
}

Koordináta rendszer rajzolása

#include <GL/glut.h>
 
void axes() {
    glBegin(GL_LINES);
		// x tengely
        glColor3f(1, 0, 0);
        glVertex3f(-1, 0, 0);
        glVertex3f(1, 0, 0);
 
		// y tengely
        glColor3f(0, 1, 0);
        glVertex3f(0, -1, 0);
        glVertex3f(0, 1, 0);
 
		// z tengely
        glColor3f(0, 0, 1);
        glVertex3f(0, 0, -1);
        glVertex3f(0, 0, 1);
    glEnd();
}
 
 
void display(void) {
    glClear(GL_COLOR_BUFFER_BIT);
    axes();
 
    //forgatás x tengely mentén
    glRotatef(15.0, 0.5, 0.0, 0.0);
    //forgatás y tengely mentén
    glRotatef(-30.0, 0.0, 0.5, 0.0);
 
    glFlush();
}
 
int main(int argc, char** argv) {
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_SINGLE);
    glutInitWindowSize(640, 450);
    glutInitWindowPosition(200, 200);
    glutCreateWindow("Hello Vilag!");
    glutDisplayFunc(display);
    glutMainLoop();
    return 0;
}

Ahhoz hogy lássuk a z tengelyt is, elfordítottuk a koordinátatrendszert a glRotatef() függvénnyel. Használható még a glRotated() függvény. Szintaxisuk: 

void glRotated(	GLdouble szog,
 	GLdouble x,
 	GLdouble y,
 	GLdouble z);
 
void glRotatef(	GLfloat szog,
 	GLfloat x,
 	GLfloat y,
 	GLfloat z);

Forgatás a különböző tengelyek körül: 

//forgatás 30 fokkal az x tengely mentén
glRotatef(30.0, 1.0, 0.0, 0.0);
 
//forgatás 30 fokkal az y tengely mentén
glRotatef(30.0, 0.0, 1.0, 0.0);
 
//forgatás 30 fokkal az z tengely mentén
glRotatef(30.0, 0.0, 0.0, 1.0);

Koordináta rendszerben egy háromszög

#include <GL/glut.h>
 
void axes() {
    glBegin(GL_LINES);
		// x tengely
        glColor3f(1, 0, 0);
        glVertex3f(-1, 0, 0);
        glVertex3f(1, 0, 0);
 
		// y tengely
        glColor3f(0, 1, 0);
        glVertex3f(0, -1, 0);
        glVertex3f(0, 1, 0);
 
		// z tengely
        glColor3f(0, 0, 1);
        glVertex3f(0, 0, -1);
        glVertex3f(0, 0, 1);
    glEnd();
}
 
void triangle(void) {
	glColor3f(0.8, 0.8, 0);
	glBegin(GL_POLYGON);
		glVertex3f(0.2, 0.5, 0.0);
		glVertex3f(0.5, 0.5, 0.0);
		glVertex3f(0.5, 0.2, 0.0);
	glEnd();
}
 
void display(void) {
    glClear(GL_COLOR_BUFFER_BIT);
    axes();
    triangle();
 
    //forgatás x tengely mentén
    glRotatef(15.0, 0.5, 0.0, 0.0);
    //forgatás y tengely mentén
    glRotatef(-30.0, 0.0, 0.5, 0.0);
 
    glFlush();
}
 
int main(int argc, char** argv) {
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_SINGLE);
    glutInitWindowSize(640, 450);
    glutInitWindowPosition(200, 200);
    glutCreateWindow("Hello Vilag!");
    glutDisplayFunc(display);
    glutMainLoop();
    return 0;
}

Forgatás

forgat.cpp
#include <GL/glut.h>
 
void axes() {
    glBegin(GL_LINES);
		// x tengely
        glColor3f(1, 0, 0);
        glVertex3f(-1, 0, 0);
        glVertex3f(1, 0, 0);
 
		// y tengely
        glColor3f(0, 1, 0);
        glVertex3f(0, -1, 0);
        glVertex3f(0, 1, 0);
 
		// z tengely
        glColor3f(0, 0, 1);
        glVertex3f(0, 0, -1);
        glVertex3f(0, 0, 1);
    glEnd();
}
 
void triangle(void) {
	glColor3f(0.8, 0.8, 0);
	glBegin(GL_POLYGON);
		glVertex3f(0.2, 0.5, 0.0);
		glVertex3f(0.5, 0.5, 0.0);
		glVertex3f(0.5, 0.2, 0.0);
	glEnd();
}
 
void display(void) {
    glClear(GL_COLOR_BUFFER_BIT);
 
    axes();
    triangle();
 
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    static float rot = -30;
 
    //forgatás x tengely mentén
    glRotatef(15.0, 0.5, 0.0, 0.0);
    //forgatás y tengely mentén
    glRotatef(rot, 0.0, 0.5, 0.0);
 
    rot += 1;
 
    glutSwapBuffers();
}
 
int main(int argc, char** argv) {
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA);
    glutInitWindowSize(640, 450);
    glutInitWindowPosition(200, 200);
    glutCreateWindow("Hello Vilag!");
    glutDisplayFunc(display);
    glutIdleFunc(display);    
    glutMainLoop();
    return 0;
}

Billentyűzet figyelése

bill.cpp
#include <GL/glut.h>
 
// forgatás x tengely körül
double rX=15;
// forgatás y tengely körül
double rY=-30;
 
void axes() {
    glBegin(GL_LINES);
		// x tengely
        glColor3f(1, 0, 0);
        glVertex3f(-1, 0, 0);
        glVertex3f(1, 0, 0);
 
		// y tengely
        glColor3f(0, 1, 0);
        glVertex3f(0, -1, 0);
        glVertex3f(0, 1, 0);
 
		// z tengely
        glColor3f(0, 0, 1);
        glVertex3f(0, 0, -1);
        glVertex3f(0, 0, 1);
    glEnd();
}
 
void triangle(void) {
	glColor3f(0.8, 0.8, 0);
	glBegin(GL_POLYGON);
		glVertex3f(0.2, 0.5, 0.0);
		glVertex3f(0.5, 0.5, 0.0);
		glVertex3f(0.5, 0.2, 0.0);
	glEnd();
}
 
void display(void) {
    glClear(GL_COLOR_BUFFER_BIT);
 
    axes();
    triangle();
 
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
 
    glRotatef( rX, 1.0, 0.0, 0.0 );
    glRotatef( rY, 0.0, 1.0, 0.0 );
 
    glutSwapBuffers();
}
 
void keyboard(int key, int x, int y) {
    if (key == GLUT_KEY_RIGHT) {
                rY += 5;
    } else if (key == GLUT_KEY_LEFT) {
                rY -= 5;
    } else if (key == GLUT_KEY_DOWN) {
                rX -= 5;
    } else if (key == GLUT_KEY_UP) {
                rX += 5;
    }
 
    // a képernyő újrarajzolása
    glutPostRedisplay();
}
 
int main(int argc, char** argv) {
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA);
    glutInitWindowSize(640, 450);
    glutInitWindowPosition(200, 200);
    glutCreateWindow("Hello Vilag!");
    glutDisplayFunc(display);
    glutSpecialFunc(keyboard);
 
    glutMainLoop();
    return 0;
}

Pontmeghatározó függvények

void glVertex2s(GLshort x, GLshort y);

void glVertex2i(GLint x, GLint y);

void glVertex2f(GLfloat x, GLfloat y);

void glVertex2d(GLdouble x, GLdouble y);

void glVertex3s(GLshort x, GLshort y,	GLshort z);

void glVertex3i(GLint x, GLint y, GLint z);

void glVertex3f(GLfloat x, GLfloat y,	GLfloat z);

void glVertex3d(GLdouble x, GLdouble y, GLdouble z);

void glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w);

void glVertex4i(GLint x, GLint y, GLint z, GLint w);
 
void glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w);

void glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w);

Az x, y, z, és w a vertex koordináták. 

void glVertex2sv(const GLshort * v);

void glVertex2iv(const GLint * v);

void glVertex2fv(const GLfloat * v);

void glVertex2dv(const GLdouble * v);

void glVertex3sv(const GLshort * v);

void glVertex3iv(const GLint * v);

void glVertex3fv(const GLfloat * v);

void glVertex3dv(const GLdouble * v);

void glVertex4sv(const GLshort * v);

void glVertex4iv(const GLint * v);

void glVertex4fv(const GLfloat * v);

void glVertex4dv(const GLdouble * v);

A v egy mutató egy tömbre, amely kettő, három vagy négy elemet tartalmaz. Két elem az x és y, három elem x, y és z, a négy elem x, y, z és w.

A függvények végén, egy vagy két betű áll, amelyek megmondják, milyen paramétereket vár a függvény. Lehetséges típusok:

jel Adattípus C-nyelv típus OpenGL típus
b 8-bit integer signed char GLbyte
s 16-bit integer short GLshort
i 32-bit integer long GLint, GLsizei
f 32-bit floating-point float GLfloat, GLclampf
d 64-bit floating-point double GLdouble GLclampd
ub 8-bit unsigned integer unsigned char GLubyte, GLboolean
us 16-bit unsigned integer unsigned short GLushort
ui 32-bit unsigned integer unsigned long GLunit, GLenum, GLbitfield

Forrás

oktatas/programozas/opengl/opengl_glut_linuxon.txt · Utolsó módosítás: 2020/08/20 21:26 szerkesztette: admin

Eszközök az oldalon

Hacsak máshol nincs egyéb rendelkezés, ezen wiki tartalma a következő licenc alatt érhető el: CC Attribution-Share Alike 4.0 International
CC Attribution-Share Alike 4.0 International Donate Powered by PHP Valid HTML5 Valid CSS Driven by DokuWiki