Arkanoid 3D krok po kroku

23.04.2010 - Olgierd Humeńczuk
TrudnośćTrudność

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

5
Twoja ocena: Brak Ocena: 5 (2 ocen)

Copyright © 2008-2010 Wrocławski Portal Informatyczny

design: rafalpolito.com