Spróbujmy odwzorować powyższą scenę w naszej aplikacji korzystając z bibliotek Open GL i GLU.
Po pierwsze stworzymy strukturę która opisuje punkt w przestrzeni trójwymiarowej.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
| /**
* @struct vertex3f
* @brief Struktura opisujaca wierzchołek w przestrzeni 3d
*/
struct vertex3f
{
/**
* @brief Domyslny konstruktor
* Ustawia wszystkie wspolrzedne na ( 0, 0, 0 )
*/
vertex3f( void ) : x( .0f ), y( .0f ), z( .0f )
{
}
/**
* @brief Konstruktor ustawiajacy wspolrzedne
* @param in_x wspolrzedna x
* @param in_y wspolrzedna y
* @param in_z wspolrzedna z
*/
vertex3f( GLfloat in_x, GLfloat in_y, GLfloat in_z )
: x( in_x ), y( in_y ), z( in_z )
{
}
///wspolrzedna x
GLfloat x;
///wspolrzedna y
GLfloat y;
///wspolrzedna z
GLfloat z;
}; |
Rys 4. Sześcian z zaznaczoną przednią ścianą i jej wierzchołkami.
Wypiszmy współrzędne wierzchołków zaznaczonej na Rys 4. ściany sześcianu. Przyjmijmy że szerokość sześcianu wynosi 1.0 w jednostkach Open GL, a jego środek
leży w centrum globalnego układu współrzędnych.
id
|
wsp. x
|
wsp. y
|
wsp. z
|
v0
|
-0.5
|
0.5
|
0.5
|
v1
|
-0.5
|
-0.5
|
0.5
|
v2
|
0.5
|
-0.5
|
0.5
|
v3
|
0.5
|
0.5
|
0.5
|
Analogicznie określimy współrzędne pozostałych ścian sześcianu. Do przechowania współrzędnych wierzchołków użyjemy jednego z kontenerów biblioteki stl:
std::vector< vertex3f >
.
Napiszmy zatem funkcję która realizuje tworzenie wierzchołków sześcianu:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
| /** Deklaracja typu tablicy wierzcholkow */
typedef std::vector< vertex3f > vertexes;
/**
* @brief Tworzy tablice wierzcholkow szescianu
* @param width dlugosc boku szescianu
*/
vertexes createCube( GLfloat width )
{
vertexes ret;
//rezerwacja pamięci
ret.reserve( 6 * 4 * sizeof( vertexes::value_type ) );
GLfloat min = -width * 0.5f;
GLfloat max = -min;
//przednia sciana
ret.push_back( vertex3f( min, max, max ) );
ret.push_back( vertex3f( min, min, max ) );
ret.push_back( vertex3f( max, min, max ) );
ret.push_back( vertex3f( max, max, max ) );
. //tutaj kod dodający współrzędne wierzchołków
. //dla pozostałych ścian
.
//dolna sciana
ret.push_back( vertex3f( min, min, max ) );
ret.push_back( vertex3f( min, min, min ) );
ret.push_back( vertex3f( max, min, min ) );
ret.push_back( vertex3f( max, min, max ) );
return ret;
} |
Następnie uzupełnimy kod głównej pętli o tworzenie i wyświetlanie sześcianu na ekranie.
1
2
3
4
5
6
7
8
9
10
11
12
13
| vertexes cubeVertexes = createCube( 2.0f );
glEnableClientState( GL_VERTEX_ARRAY) ;
// główna pętla
while( processInput() )
{
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
glMatrixMode( GL_MODELVIEW );
glLoadIdentity();
gluLookAt( 0.0f, 0.0f, 10.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f );
glVertexPointer( 3, GL_FLOAT, 0, &cubeVertexes[ 0 ] );
glDrawArrays( GL_QUADS, 0, cubeVertexes.size() );
SDL_GL_SwapBuffers();
} |
-
linia 1 to oczywiście skopiowanie tablicy wierzchołków stworzonej w funkcji
createCube
-
w linii 2 włączamy możliwość podawania bibliotece Open GL bezpośredniego wskaźnika do pamięci zawierającej dane wierzchołków
-
w linii 6 znajduje się polecenie które czyści bufory koloru oraz głębokości
-
następnie znane już nam włącznie trybu operowania na macierzy widoku i ustawienie macierzy jednostkowej
-
linia 9 to wykorzystanie wspomnianego polecenia gluLookAt do ustawienia pozycji obserwatora w scenie, parametry
gluLookAt to:
-
pozycja obserwatora ( pierwsze trzy parametry )
-
punkt na który patrzy obserwator ( kolejne trzy parametry )
-
wektor określający nachylenie obserwatora względem płaszczyzny ( kolejne trzy parametry )
-
w linii 10 podajemy wskaźnik do danych wierzchołków poleceniem którego kolejne parametry oznaczają:
-
ilość współrzędnych przypadających na wierzchołek
-
typ jakim zadeklarowaliśmy każdą współrzędną wierzchołków
-
krok, czyli ilość bajtów o jaką oddalone są od siebie części z danymi kolejnych wierzchołków
-
wskaźnik do początku pamięci zawierającej współrzędne wierzchołków
-
przedostatnie polecenie informuje bibliotekę Open GL w jaki sposób ma traktować podane tablice z danymi, jego argumenty to:
-
za pomocą jakiego typu wielokątów mają być przedstawione wierzchołki podane wcześniej
-
index pierwszego wierzchołka w tablicy
-
ilość wielokątów które chcemy wyświetlić
-
ostatnie polecenie to zmiana buforów i w efekcie wyświetlenie wygenerowanego obrazu na ekranie