Problem z przykładowym programem do wczytywania obj

/*
(c) Janusz Ganczarski
http://www.januszg.hg.pl
JanuszG@enter.net.pl
*/

#include <GL/glu.h>
#include <stdio.h>
#include <string.h>
#include <vector>
#include "obj.h"
#include "targa.h"

// struktura ze współrzędnymi wierzchołków

struct geometric_vertices
{
    GLfloat x, y, z, w;
};

// struktura ze współrzędnymi tekstur

struct texture_vertices
{
    GLfloat u, v, w;
};

// struktura ze współrzędnymi wektorów normalnych

struct vertex_normals
{
    GLfloat i, j, k;
};

// współrzędne przestrzeni parametrycznej

struct parameter_space_vertices
{
    GLfloat u, v, w;
};

// tablica ze współrzędnymi wierzchołków

std::vector < geometric_vertices > v;

// tablica ze współrzędnymi tekstur

std::vector < texture_vertices > vt;

// tablica ze współrzęnymi wektorów normalnych

std::vector < vertex_normals > vn;

// tablica ze współrzędnymi przestrzeni parametrycznej

std::vector < parameter_space_vertices > vp;

// definicja materiału

struct material
{
    char name[ 256 ]; // nazwa materiału
    GLfloat Ka[ 4 ]; // stopień odbicia światła otaczającego
    GLfloat Kd[ 4 ]; // stopień rozproszenia światła rozproszonego
    GLfloat Ks[ 4 ]; // stopień odbicia światła odbitego
    int illum; // model oświetlenia
    GLfloat d; // stopień przezroczystości materiału
    GLfloat Ns; // wykładnik odbłysku światła
    char map_Kd[ 256 ]; // nazwa pliku z teksturą
};

// tablica z definicjami materiałów

std::vector < material > materials;

// ustawienie domyślnych właściwości materiału

void DeafultMaterial( material & mat )
{
    mat.name[ 0 ] = 0;
    mat.Ka[ 0 ] = 0.2;
    mat.Ka[ 1 ] = 0.2;
    mat.Ka[ 2 ] = 0.2;
    mat.Ka[ 3 ] = 1.0;
    mat.Kd[ 0 ] = 0.8;
    mat.Kd[ 1 ] = 0.8;
    mat.Kd[ 2 ] = 0.8;
    mat.Kd[ 3 ] = 1.0;
    mat.Ks[ 0 ] = 1.0;
    mat.Ks[ 1 ] = 1.0;
    mat.Ks[ 2 ] = 1.0;
    mat.Ks[ 3 ] = 1.0;
    mat.illum = 1;
    mat.d = 1.0;
    mat.Ns = 0.0;
    mat.map_Kd[ 0 ] = 0;
}

// odczyt danych wierzchołków

void load_vertex_data( const char * str )
{
    switch( str[ 1 ] )
    {
        // współrzędne wierzchołków
    case ' ':
        geometric_vertices tmp_v;
        tmp_v.w = 1.0;
        sscanf( str + 1, "%f %f %f %f", & tmp_v.x, & tmp_v.y, & tmp_v.z, & tmp_v.w );
        v.insert( v.end(), tmp_v );
        break;
       
        // współrzędne tekstur
    case 't':
        texture_vertices tmp_vt;
        tmp_vt.v = tmp_vt.w = 0.0;
        sscanf( str + 2, "%f %f %f", & tmp_vt.u, & tmp_vt.v, & tmp_vt.w );
        vt.insert( vt.end(), tmp_vt );
        break;
       
        // współrzędne wektorów normalnych
    case 'n':
        vertex_normals tmp_vn;
        sscanf( str + 2, "%f %f %f", & tmp_vn.i, & tmp_vn.j, & tmp_vn.k );
        vn.insert( vn.end(), tmp_vn );
        break;
       
        // współrzędne przestrzeni parametrycznej
    case 'p':
        parameter_space_vertices tmp_vp;
        tmp_vp.w = 1.0;
        sscanf( str + 2, "%f %f %f", & tmp_vt.u, & tmp_vt.v, & tmp_vt.w );
        vp.insert( vp.end(), tmp_vp );
        break;
    }
}

// odczyt biblioteki materiałów

void load_materials( const char * str )
{
    // sprawdzenie czy jest to definicja materiałów
    char tmpstr[ 512 ];
    unsigned int pos = 0;
    sscanf( str, "%s", tmpstr );
    if( !strcmp( tmpstr, "mtllib" ) )
    {
        // odczyt kolejnych plików z definicjami materiałów
        pos += strlen( tmpstr ) + 1;
        while( pos < strlen( str ) )
        {
            // pobranie nazwy pliku
            sscanf( str + pos, "%s", tmpstr );
           
            // następny (opcjonalny) plik z definicją materiałów
            pos += strlen( tmpstr ) + 1;
           
            // otwarcie pliku do odczytu
            FILE * mtl = fopen( tmpstr, "rt" );
           
            // sprawdzenie poprawności otwarcia pliku
            if( !mtl )
                 continue;
           
            // struktura z danymi materiału z wartościami domyślnymi
            material mat;
            DeafultMaterial( mat );
           
            // odczyt danych pliku
            char mtlstr[ 512 ];
            while( !feof( mtl ) )
            {
                // pobranie linii pliku
                fgets( mtlstr, 512, mtl );
               
                // sprawdzenie co zawiera linia
                switch( mtlstr[ 0 ] )
                {
                    // nazwa materiału newmtl name
                case 'n':
                    sscanf( mtlstr, "%s", tmpstr );
                    if( !strcmp( tmpstr, "newmtl" ) )
                    {
                        // sprawdzenie czy to pierwsza definicja materiału
                        // jeżeli nie, to zapisujemy materiał do tablicy
                        if( strlen( mat.name ) )
                        {
                            materials.insert( materials.end(), mat );
                           
                            // ponownie wartości domyślne
                            DeafultMaterial( mat );
                        }
                        sscanf( mtlstr + strlen( tmpstr ) + 1, "%s", mat.name );
                    }
                    break;
                   
                    // stopień odbicia światła otaczającego (Ka)
                    // stopień rozproszenia światła rozproszonego (Kd)
                    // stopień odbicia światła odbitego (Ks)
                case 'K':
                    switch( mtlstr[ 1 ] )
                    {
                    case 'a':
                        sscanf( mtlstr + 3, "%f %f %f", mat.Ka + 0, mat.Ka + 1, mat.Ka + 2 );
                        break;
                       
                    case 'd':
                        sscanf( mtlstr + 3, "%f %f %f", mat.Kd + 0, mat.Kd + 1, mat.Kd + 2 );
                        break;
                       
                    case 's':
                        sscanf( mtlstr + 3, "%f %f %f", mat.Ks + 0, mat.Ks + 1, mat.Ks + 2 );
                        break;
                    }
                    break;
                   
                    // składowa alfa - przezroczystość (d)
                case 'd':
                    if( mtlstr[ 1 ] == ' ' )
                    {
                        sscanf( mtlstr + 2, "%f", & mat.d );
                        mat.Ka[ 3 ] = mat.d;
                        mat.Kd[ 3 ] = mat.d;
                        mat.Ks[ 3 ] = mat.d;
                    }
                    break;
                   
                    // wykładnik odbłysku światła (Ns)
                case 'N':
                    if( mtlstr[ 1 ] == 's' && mtlstr[ 2 ] == ' ' )
                         sscanf( mtlstr + 3, "%f", & mat.Ns );
                   
                    break;
                   
                    // tekstura (map_Kd)
                case 'm':
                    sscanf( mtlstr, "%s", tmpstr );
                   
                    // sprawdzenie czy to tekstura
                    if( !strcmp( tmpstr, "map_Kd" ) )
                         sscanf( mtlstr + strlen( tmpstr ) + 1, "%s", mat.map_Kd );
                   
                    break;
                   
                    // model oświetlenia (illum)
                case 'i':
                    sscanf( mtlstr, "%s", tmpstr );
                   
                    // sprawdzenie czy to model oświetlenia
                    if( !strcmp( tmpstr, "illum" ) )
                         sscanf( mtlstr + strlen( tmpstr ) + 1, "%i", & mat.illum );
                   
                    break;
                   
                    // domyślnie - pominięcie linii pliku
                    default:
                    break;
                }
            }
           
            // zapisanie ostatniego materiału do tablicy
            materials.insert( materials.end(), mat );
           
            // zamknięcie pliku
            fclose( mtl );
        }
    }
}

// odczyt danych o wierzchołkach ściany (wielokąta)

void load_face( const char * str )
{
    // ustalenie ilości i formatu danych opisujących wierzchołek ściany
    char tmpstr[ 512 ];
    unsigned int pos = 2;
    sscanf( str + pos, "%s", tmpstr );
    unsigned int count = 0;
    for( unsigned int i = 0; i < strlen( tmpstr ); i++ )
    if( tmpstr[ i ] == '/' )
    {
        count++;
        if( tmpstr[ i + 1 ] == '/' )
             count++;
       
    }
   
    // zliczanie ilości wierzchołków ściany
    int vertex = 0;
    while( pos < strlen( str ) )
    {
        vertex++;
        pos += strlen( tmpstr ) + 1;
        sscanf( str + pos, "%s", tmpstr );
    }
   
    // początek definiowania wielokąta
    switch( vertex )
    {
    case 3:
        glBegin( GL_TRIANGLES );
        break;
    case 4:
        glBegin( GL_QUADS );
        break;
        default:
        glBegin( GL_POLYGON );
        break;
    };
   
    // odczyt i definiowanie danych poszczególnych wierzchołków
    pos = 2;
    vertex = 0;
    int iv, ivt, ivn;
    sscanf( str + pos, "%s", tmpstr );
    while( pos < strlen( str ) )
    {
        switch( count )
        {
            // f v
        case 0:
            sscanf( tmpstr, "%i", & iv );
            glVertex3f( v[ iv - 1 ].x, v[ iv - 1 ].y, v[ iv - 1 ].z );
            break;
           
            // f v/t
        case 1:
            sscanf( tmpstr, "%i/%i", & iv, & ivt );
            glTexCoord3f( vt[ ivt - 1 ].u, vt[ ivt - 1 ].v, vt[ ivt - 1 ].w );
            glVertex3f( v[ iv - 1 ].x, v[ iv - 1 ].y, v[ iv - 1 ].z );
            break;
           
            // f v/t/n
        case 2:
            sscanf( tmpstr, "%i/%i/%i", & iv, & ivt, & ivn );
            glNormal3f( vn[ ivn - 1 ].i, vn[ ivn - 1 ].j, vn[ ivn - 1 ].k );
            glTexCoord3f( vt[ ivt - 1 ].u, vt[ ivt - 1 ].v, vt[ ivt - 1 ].w );
            glVertex3f( v[ iv - 1 ].x, v[ iv - 1 ].y, v[ iv - 1 ].z );
            break;
           
            // f v//n
        case 3:
            sscanf( tmpstr, "%i//%i", & iv, & ivn );
            glNormal3f( vn[ ivn - 1 ].i, vn[ ivn - 1 ].j, vn[ ivn - 1 ].k );
            glVertex3f( v[ iv - 1 ].x, v[ iv - 1 ].y, v[ iv - 1 ].z );
            break;
        }
       
        // kolejny wierzchołek
        vertex++;
        pos += strlen( tmpstr ) + 1;
        sscanf( str + pos, "%s", tmpstr );
    }
   
    // koniec definicji wielokąta
    glEnd();
}

// odczyt tekstury w formacie TARGA
// filename - nazwa pliku

GLboolean load_texture( const char * filename )
{
    // zmienne użyte przy obsłudze plików TARGA
    GLsizei width, height;
    GLenum format, type;
    GLvoid * pixels;
   
    // tryb upakowania bajtów danych tekstury
    glPixelStorei( GL_UNPACK_ALIGNMENT, 1 );
   
    // wczytanie tekstury grass_color.tga
    GLboolean error = load_targa( filename, width, height, format, type, pixels );
   
    // błąd odczytu pliku
    if( error == GL_FALSE )
    {
        delete[]( unsigned char * ) pixels;
        return GL_FALSE;
    }
   
    // utworzenie tekstury wraz z mipmapami
    gluBuild2DMipmaps( GL_TEXTURE_2D, GL_RGB, width, height, format, type, pixels );
   
    // ustawienie parametów środowiska tekstur
    glTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE );
   
    // filtr powiększający
    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
   
    // filtr pomniejszający
    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
   
    // porządki
    delete[]( unsigned char * ) pixels;
   
    // sukces
    return GL_TRUE;
}

// odczyt pliku graficznego w formacie OBJ
// filename - nazwa pliku
// object_list - numer listy wyświetlania

GLboolean load_obj( const char * filename, GLuint & object_list )
{
    // otwarcie pliku do odczytu
    FILE * obj = fopen( filename, "rt" );
   
    // sprawdzenie poprawności otwarcia pliku
    if( !obj )
         return GL_FALSE;
   
    // generowanie identyfikatora listy wyświetlania
    object_list = glGenLists( 1 );
   
    // lista wyświetlania z obiektem
    glNewList( object_list, GL_COMPILE );
   
    // odczyt danych pliku
    char str[ 512 ];
    while( !feof( obj ) )
    {
        // pobranie linii pliku
        fgets( str, 512, obj );
       
        // sprawdzenie co zawiera linia
        switch( str[ 0 ] )
        {
            // dane wierzchołków
        case 'v':
            load_vertex_data( str );
            break;
           
            // ściana wielokąta
        case 'f':
            load_face( str );
            break;
           
            // mtllib - plik z biblioteką materiałów
        case 'm':
            load_materials( str );
            break;
           
            // usemtl - użycie wybranego materiału
        case 'u':
            char name[ 128 ];
            sscanf( str, "%s", name );
            if( !strcmp( name, "usemtl" ) )
            {
                sscanf( str + 7, "%s", name );
                for( unsigned int i = 0; i < materials.size(); i++ )
                if( !strcmp( materials[ i ].name, name ) )
                {
                    // wyłączenie teksturowania dwuwymiarowego
                    glDisable( GL_TEXTURE_2D );
                   
                    // wyłączenie mieszania kolorów
                    glDisable( GL_BLEND );
                   
                    // właściwości materiału
                    glMaterialfv( GL_FRONT_AND_BACK, GL_AMBIENT, materials[ i ].Ka );
                    glMaterialfv( GL_FRONT_AND_BACK, GL_DIFFUSE, materials[ i ].Kd );
                    if( materials[ i ].illum == 2 )
                         glMaterialfv( GL_FRONT_AND_BACK, GL_SPECULAR, materials[ i ].Ks );
                   
                    glMaterialf( GL_FRONT_AND_BACK, GL_SHININESS, materials[ i ].Ns );
                   
                    // sprawdzenie przezroczystości
                    if( materials[ i ].d < 1.0 )
                    {
                        // włączenie mieszania kolorów
                        glEnable( GL_BLEND );
                       
                        // współczynniki mieszania kolorów
                        glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
                       
                    }
                   
                    // sprawdzenie czy jest tekstura
                    if( materials[ i ].map_Kd[ 0 ] )
                    {
                        // jeżeli tak, to włączenie teksturowania dwuwymiarowego
                        if( load_texture( materials[ i ].map_Kd ) )
                             glEnable( GL_TEXTURE_2D );
                       
                    }
                    break;
                }
            }
            break;
           
            // domyślnie - pominięcie linii pliku
            default:
            break;
        }
    }
   
    // koniec listy wyświetlania z obiektem
    glEndList();
   
    // porządki
    v.erase( v.begin(), v.end() );
    vt.erase( vt.begin(), vt.end() );
    vn.erase( vn.begin(), vn.end() );
    vp.erase( vp.begin(), vp.end() );
    materials.erase( materials.begin(), materials.end() );
   
    // zamknięcie pliku
    fclose( obj );
   
    // sukces
    return GL_TRUE;
}

/*
(c) Janusz Ganczarski
http://www.januszg.hg.pl
JanuszG@enter.net.pl
*/

#include <GL/glut.h>
#include <GL/glu.h>
#include <stdlib.h>
#include <stdio.h>
#include "obj.h"

// stałe do obsługi menu podręcznego

enum
{
    FULL_WINDOW, // aspekt obrazu - całe okno
    ASPECT_1_1, // aspekt obrazu 1:1
    EXIT // wyjście
};

// aspekt obrazu

int aspect = FULL_WINDOW;

// rozmiary bryły obcinania

const GLdouble left = - 10.0;
const GLdouble right = 10.0;
const GLdouble bottom = - 10.0;
const GLdouble top = 10.0;
const GLdouble neara = 10.0;
const GLdouble fara = 30.0;

// kąty obrotu obiektu

GLfloat rotatex = 0.0;
GLfloat rotatey = 0.0;

// wskaźnik naciśnięcia lewego przycisku myszki

int button_state = GLUT_UP;

// położenie kursora myszki

int button_x, button_y;

// współczynnik skalowania

GLfloat scale = 1.0;

// wektory przesunięcia

GLfloat translatex = 0.0;
GLfloat translatey = 0.0;

// identyfikator listy wyświetlania z obiektem

GLuint OBJECT_LIST;

// funkcja generująca scenę 3D

void Display()
{
    // kolor tła - zawartość bufora koloru
    glClearColor( 1.0, 1.0, 1.0, 1.0 );
   
    // czyszczenie bufora koloru i bufora głębokości
    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
   
    // wybór macierzy modelowania
    glMatrixMode( GL_MODELVIEW );
   
    // macierz modelowania = macierz jednostkowa
    glLoadIdentity();
   
    // włączenie testu bufora głębokości
    glEnable( GL_DEPTH_TEST );
   
    // przesunięcie układu współrzędnych obiektu do środka bryły odcinania
    glTranslatef( 0, 0, -( neara + fara ) / 2 );
   
    // przesunięcie obiektu
    glTranslatef( translatex, translatey, 0.0 );
   
    // obroty obiektu
    glRotatef( rotatex, 1.0, 0.0, 0.0 );
    glRotatef( rotatey, 0.0, 1.0, 0.0 );
   
    // skalowanie obiektu - klawisze "+" i "-"
    glScalef( scale, scale, scale );
   
    // ustawienie parametrów modelu oświetlenia
    glLightModelf( GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE );
   
    // włączenie oświetlenia
    glEnable( GL_LIGHTING );
   
    // włączenie światła GL_LIGHT0 z parametrami domyślnymi
    glEnable( GL_LIGHT0 );
   
    // włączenie automatycznej normalizacji wektorów normalnych
    glEnable( GL_NORMALIZE );
   
    // tryb renderingu wielokątów
    glPolygonMode( GL_FRONT_AND_BACK, GL_FILL );
   
    // wyświetlenie listy wyświetlania z obiektem
    glCallList( OBJECT_LIST );
   
    // skierowanie poleceń do wykonania
    glFlush();
   
    // zamiana buforów koloru
    glutSwapBuffers();
}

// zmiana wielkości okna

void Reshape( int width, int height )
{
    // obszar renderingu - całe okno
    glViewport( 0, 0, width, height );
   
    // wybór macierzy rzutowania
    glMatrixMode( GL_PROJECTION );
   
    // macierz rzutowania = macierz jednostkowa
    glLoadIdentity();
   
    // parametry bryły obcinania
    if( aspect == ASPECT_1_1 )
    {
        // wysokość okna większa od wysokości okna
        if( width < height && width > 0 )
             glFrustum( left, right, bottom * height / width, top * height / width, neara, fara );
        else
       
        // szerokość okna większa lub równa wysokości okna
        if( width >= height && height > 0 )
             glFrustum( left * width / height, right * width / height, bottom, top, neara, fara );
       
    }
    else
         glFrustum( left, right, bottom, top, neara, fara );
   
    // generowanie sceny 3D
    Display();
}

void SpecialKeys( int key, int x, int y )
{
    switch( key )
    {
        // kursor w górę
    case GLUT_KEY_UP:
        translatey += 0.5;
        break;
       
        // kursor w dół
    case GLUT_KEY_DOWN:
        translatey -= 0.5;
        break;
       
        // kursor w lewo
    case GLUT_KEY_LEFT:
        translatex -= 0.5;
        break;
       
        // kursor w prawo
    case GLUT_KEY_RIGHT:
        translatex += 0.5;
        break;
       
    case GLUT_KEY_PAGE_UP:
        scale += 0.5;
        break;
       
    case GLUT_KEY_PAGE_DOWN:
        if( scale > 0.5 )
             scale -= 0.5;
       
        break;
    }
   
    // odrysowanie okna
    glutPostRedisplay();
}

// obsługa klawiatury

void Keyboard( unsigned char key, int x, int y )
{
    // klawisz +
    if( key == '+' )
         scale += 0.01;
    else
   
    // klawisz -
    if( key == '-' && scale > 0.01 )
         scale -= 0.01;
   
    // narysowanie sceny
    Display();
}

// obsługa przycisków myszki

void MouseButton( int button, int state, int x, int y )
{
    if( button == GLUT_LEFT_BUTTON )
    {
        // zapamiętanie stanu lewego przycisku myszki
        button_state = state;
       
        // zapamiętanie położenia kursora myszki
        if( state == GLUT_DOWN )
        {
            button_x = x;
            button_y = y;
        }
    }
}

// obsługa ruchu kursora myszki

void MouseMotion( int x, int y )
{
    if( button_state == GLUT_DOWN )
    {
        rotatey += 30 *( right - left ) / glutGet( GLUT_WINDOW_WIDTH ) *( x - button_x );
        button_x = x;
        rotatex -= 30 *( top - bottom ) / glutGet( GLUT_WINDOW_HEIGHT ) *( button_y - y );
        button_y = y;
        glutPostRedisplay();
    }
}

// obsługa menu podręcznego

void Menu( int value )
{
    switch( value )
    {
        // obszar renderingu - całe okno
    case FULL_WINDOW:
        aspect = FULL_WINDOW;
        Reshape( glutGet( GLUT_WINDOW_WIDTH ), glutGet( GLUT_WINDOW_HEIGHT ) );
        break;
       
        // obszar renderingu - aspekt 1:1
    case ASPECT_1_1:
        aspect = ASPECT_1_1;
        Reshape( glutGet( GLUT_WINDOW_WIDTH ), glutGet( GLUT_WINDOW_HEIGHT ) );
        break;
       
        // wyjście
    case EXIT:
        exit( 0 );
    }
}

int main( int argc, char * argv[] )
{
    // inicjalizacja biblioteki GLUT
    glutInit( & argc, argv );
   
    // inicjalizacja bufora ramki
    glutInitDisplayMode( GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH );
   
    // rozmiary głównego okna programu
    glutInitWindowSize( 500, 500 );
   
    // utworzenie głównego okna programu
    glutCreateWindow( "OBJ View" );
   
    // dołączenie funkcji generującej scenę 3D
    glutDisplayFunc( Display );
   
    // dołączenie funkcji wywoływanej przy zmianie rozmiaru okna
    glutReshapeFunc( Reshape );
   
    // dołączenie funkcji obsługi klawiatury
    glutKeyboardFunc( Keyboard );
   
    // dołączenie funkcji obsługi klawiszy funkcyjnych i klawiszy kursora
    glutSpecialFunc( SpecialKeys );
   
    // obsługa przycisków myszki
    glutMouseFunc( MouseButton );
   
    // obsługa ruchu kursora myszki
    glutMotionFunc( MouseMotion );
   
    // utworzenie menu podręcznego
    glutCreateMenu( Menu );
   
    int MenuAspect = glutCreateMenu( Menu );
    #ifdef WIN32
   
    glutAddMenuEntry( "Aspekt obrazu - całe okno", FULL_WINDOW );
    #else
   
    glutAddMenuEntry( "Aspekt obrazu - cale okno", FULL_WINDOW );
    #endif
   
    glutAddMenuEntry( "Aspekt obrazu 1:1", ASPECT_1_1 );
   
    // menu główne
    glutCreateMenu( Menu );
   
    #ifdef WIN32
    glutAddSubMenu( "Aspekt obrazu", MenuAspect );
    glutAddMenuEntry( "Wyjście", EXIT );
    #else
    glutAddSubMenu( "Aspekt obrazu", MenuAspect );
    glutAddMenuEntry( "Wyjscie", EXIT );
    #endif
   
    // określenie przycisku myszki obsługującej menu podręczne
    glutAttachMenu( GLUT_RIGHT_BUTTON );
   
    // funkcja bezczynności
    glutIdleFunc( Display );
   
    // wczytanie pliku OBJ
    if( !load_obj( argv[ 1 ], OBJECT_LIST ) )
    {
        printf( "Niepoprawny odczyt pliku %s", argv[ 1 ] );
        return 0;
    }
   
    // wprowadzenie programu do obsługi pętli komunikatów
    glutMainLoop();
    return 0;
}