szit

Ez az oldal csak olvasható. Megtekintheted a forrását, de nem változtathatod meg. Ha úgy gondolod, hogy ez helytelen, kérdezd az Adminisztrátorokat!
[[oktatas:programozás:opengl|< OpenGL]]


====== OpenGL GLUT Linuxon ======

  * **Szerző:** Sallai András
  * Copyright (c) Sallai András, 2020
  * [[https://creativecommons.org/licenses/by-sa/4.0/|CC Attribution-Share Alike 4.0 International]]
  * Web: https://szit.hu

===== 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.

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

===== Szükséges csomagok telepítése =====


<code>
apt install libglu1-mesa-dev freeglut3-dev mesa-common-dev
</code>

===== Első program =====

<code cpp 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;
}

</code>


Fordítás:
<code>
g++ elso.cpp -o elso -lglut -lGLU -lGL
</code>

Futtatás:
<code>
./elso
</code>


===== OpenGL glut =====


<code cpp 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;
}

</code>


===== Koordináta rendszer rajzolása =====


<code 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 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;
}

</code>


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:

<code>
void glRotated(	GLdouble szog,
 	GLdouble x,
 	GLdouble y,
 	GLdouble z);
 
void glRotatef(	GLfloat szog,
 	GLfloat x,
 	GLfloat y,
 	GLfloat z);
</code>

Forgatás a különböző tengelyek körül:
<code c>
//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);
</code>

===== Koordináta rendszerben egy háromszög =====

<code 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();

    //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;
}

</code>

===== Forgatás =====

<code cpp 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;
}

</code>

===== Billentyűzet figyelése =====

<code cpp 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;
}



</code>
===== Pontmeghatározó függvények =====

<code>
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);
</code>

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


<code>
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);
</code>


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 =====

  * http://www.codebind.com/linux-tutorials/install-opengl-ubuntu-linux/ (2020)
  * http://math.hws.edu/graphicsbook/c3/s6.html (2020)