Qt OpenGL纹理垃圾_Qt_Opengl_Texturing

Qt OpenGL纹理垃圾

qt opengl

Qt OpenGL纹理垃圾,qt,opengl,texturing,Qt,Opengl,Texturing,我有一个问题，纹理-它加载正确的图像，但渲染垃圾的几何体。几何体本身绘制得很好（一个简单的三角形），但无论我加载哪个纹理，它都只是在三角形上吐出随机图案我在MacOSX上使用g++4.2.1，使用Qt4.7和OpenGL 首先，这里是控制台输出： BallGLWidget::initializeGL called Image format is GL_RGB Checking textures... glGetError enum value: GL_NO_ERROR 此外，我的着色器初始

我有一个问题，纹理-它加载正确的图像，但渲染垃圾的几何体。几何体本身绘制得很好（一个简单的三角形），但无论我加载哪个纹理，它都只是在三角形上吐出随机图案

我在MacOSX上使用g++4.2.1，使用Qt4.7和OpenGL

首先，这里是控制台输出：

BallGLWidget::initializeGL called
Image format is GL_RGB
Checking textures...
glGetError enum value:  GL_NO_ERROR

此外，我的着色器初始化日志代码没有注册任何错误

OpenGL初始化函数：

void BallGLWidget::initializeGL()
{

    cout << "BallGLWidget::initializeGL called" << endl;

    glClearColor(0.0f, 0.0f, 0.0f, 0.0f);

    initializeShaders();



    checkOpenGLError();

    glEnableVertexAttribArray(VERTEX_POS_NUM);
    glEnableVertexAttribArray(TEX_POS_NUM);

    glBindAttribLocation(programHandle, VERTEX_POS_NUM, VERTEX_POS_ATTRIB_NAME);
    glBindAttribLocation(programHandle, TEX_POS_NUM, TEX_COORD_ATTRIB_NAME);

    //this MUST be called AFTER glBindAttribLocation
    glLinkProgram(programHandle);
//FIXME:-----------DEBUG-----------
printProgramInfoLog(programHandle);
//-----------END-DEBUG-----------
glUseProgram(programHandle);
//FIXME:-----------DEBUG-----------
printProgramInfoLog(programHandle);
//-----------END-DEBUG-----------


    checkOpenGLError();

    samplerUniformLocation = 
                glGetUniformLocation(programHandle, BALL_SAMPLER_NAME);

    glUniform1f(samplerUniformLocation, 0);
    glActiveTexture(GL_TEXTURE0);


    ball_texture_handle = loadTexture(BALL_IMAGE_PATH);




    //bind it in initialization because we're only using
    //1 texture in the program
    glBindTexture(GL_TEXTURE_2D, ball_texture_handle);
}

GLuint BallGLWidget::loadTexture(const char* filenamePtr)
{
    //create & prepare a temporary texture handle that will be copied to 
    //DesktopMain::ball_texture_handle after this function returns
    GLuint texHandle;
    glGenTextures(1, &texHandle);
    glBindTexture(GL_TEXTURE_2D, texHandle);

    QImage* img = new QImage();
    if(!img->load(filenamePtr))
    {
        //error loading image, handle error
        cerr << "ERROR LOADING TEXTURE" << endl;
    }


    //This is the Qt way- its commented out for conventional OpenGL code
    //bind the texture to the current context
    //GLuint texHandle = bindTexture(*img);

    GLenum openglImageFormat;
    QImage::Format imgFormat = img->format();
    switch(imgFormat)
    {
    case QImage::Format_RGB32:
        openglImageFormat = GL_RGB;

        cout << "Image format is GL_RGB" << endl;
        break;
    case QImage::Format_ARGB32:
        openglImageFormat = GL_RGBA;

        cout << "Image format is GL_RGBA" << endl;
        break;
    //handle this case the same as ARGB32
    case QImage::Format_ARGB32_Premultiplied:
        openglImageFormat = GL_RGBA;

        cout << "Image format is GL_RGBA (premultiplied)" << endl;
        break;
    case QImage::Format_Invalid:
        cerr << "ERROR:  INVALID IMAGE FORMAT" << endl;
        return -1;
        break;
    default:
        cerr << "ERROR:  UNRECOGNIZED IMAGE FORMT" << endl;
        return -1;
        break;
    }

    //use tightly packed pixel values
    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);

    //use linear filtering
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 
            img->width(), img->height(), 0, openglImageFormat,
            GL_UNSIGNED_BYTE, img->bits());

    cerr << "Checking textures..." << endl;
    checkOpenGLError();

    delete img;

    return texHandle;
}

片段着色器：

varying vec2 tex_coord_output;

uniform sampler2D ballsampler;

void main()
{
    gl_FragColor = texture2D(ballsampler, tex_coord_output);
}

编辑：

按要求提供程序的屏幕截图

编辑：

属性位置已关闭，因为只有在链接程序对象之前调用GLBindAttriblLocation时，GLBindAttriblLocation才会起作用(http://www.opengl.org/sdk/docs/man/xhtml/glBindAttribLocation.xml). 我相应地修改了上面的代码，但程序仍然如下所示（纹理仍然存在问题…）：

我得到以下结果：

分解它，尝试一些简单的方法：

垂直glsl

#version 120

uniform mat4 projection;
uniform mat4 modelview;

attribute vec2 position;
attribute vec2 texcoord;

varying vec2 fragTexCoord;

void main(void)
{
    fragTexCoord = texcoord;
    gl_Position = projection * modelview * vec4( position, 0.0, 1.0 );
}

frag.glsl

#version 120

uniform sampler2D texture;

varying vec2 fragTexCoord;

void main(void)  
{     
    gl_FragColor = texture2D( texture, fragTexCoord );    
}

main.cpp

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

#include <cstdlib>
#include <stdexcept>
#include <iostream>
#include <fstream>
#include <sstream>
#include <vector>

using namespace std;


GLuint CreateShader( const GLenum& aShaderType, const string& aShaderSource )
{
    GLuint shader = glCreateShader( aShaderType );

    const GLchar* shaderString = aShaderSource.c_str();
    GLint shaderLength = aShaderSource.size();
    glShaderSource( shader, 1, &shaderString, &shaderLength );

    glCompileShader( shader );

    GLint compiled;
    glGetShaderiv( shader, GL_COMPILE_STATUS, &compiled );    
    if( GL_FALSE == compiled )
    {
        // compile failure, dump log
        GLint loglen;
        glGetShaderiv( shader, GL_INFO_LOG_LENGTH , &loglen);

        vector< char > log( loglen );
        glGetShaderInfoLog( shader, loglen, NULL, &log[0] );

        string type;
        switch( aShaderType )
        {
            case GL_VERTEX_SHADER:      type = "GL_VERTEX_SHADER";      break;
            case GL_FRAGMENT_SHADER:    type = "GL_FRAGMENT_SHADER";    break;
            default:                    type = "UNKNOWN SHADER";        break;
        }

        stringstream err;
        err << "*** " << type << " ***" << endl;
        err << aShaderSource;
        err << "*** Compilation Log ***" << endl;
        err << string( log.begin(), log.end() );

        throw std::logic_error( err.str() );         
    }

    return shader;
}


GLuint CreateProgram( const string& aVertexShader, const string& aFragmentShader )
{
    GLuint vert = CreateShader( GL_VERTEX_SHADER, aVertexShader );
    GLuint frag = CreateShader( GL_FRAGMENT_SHADER, aFragmentShader );

    GLuint program = glCreateProgram();
    glAttachShader( program, vert );
    glAttachShader( program, frag );
    glLinkProgram( program );

    glDeleteShader( vert );
    glDeleteShader( frag );

    GLint linked;
    glGetProgramiv( program, GL_LINK_STATUS, &linked );    
    if( GL_FALSE == linked )
    {
        // link failure, dump log
        GLint loglen;
        glGetProgramiv( program, GL_INFO_LOG_LENGTH , &loglen);

        vector< char > log( loglen );
        glGetProgramInfoLog( program, loglen, NULL, &log[0] );

        stringstream err;
        err << "*** Link log ***" << endl;
        err << string( log.begin(), log.end() );
        throw std::logic_error( err.str() );         
    }

    return program;
}


string LoadFile( const string& filename )
{
    ifstream infile(filename.c_str(), ios::binary);
    istreambuf_iterator<char> begin(infile), end;
    return string(begin, end);
}


GLuint prog = 0;
GLuint tex = 0;
void init()
{
    GLenum glewError = glewInit();
    if( GLEW_OK != glewError )
    {
        stringstream err;
        err << "GLEW error: " << glewGetErrorString(glewError) << endl;
        throw std::logic_error( err.str() );      
    }    

    cout << "GLEW_VERSION : " << glewGetString(GLEW_VERSION) << endl;
    cout << "GL_VERSION   : " << glGetString(GL_VERSION) << endl;
    cout << "GLSL VERSION : " << glGetString(GL_SHADING_LANGUAGE_VERSION) << endl;
    cout << "GL_VENDOR    : " << glGetString(GL_VENDOR) << endl;
    cout << "GL_RENDERER  : " << glGetString(GL_RENDERER) << endl;    

    if( !GLEW_VERSION_2_1 )
    {
        stringstream err;
        err << "OpenGL 2.1 or better required for GLSL support." << endl;
        throw std::logic_error( err.str() ); 
    }

    // load shaders
    string vert = LoadFile( "vert.glsl" );
    string frag = LoadFile( "frag.glsl" );
    prog = CreateProgram( vert, frag );

    // create random texture
    const unsigned int width = 32;
    const unsigned int height = 32;
    const unsigned int channels = 3;
    unsigned char buffer[ width * height * channels ];
    for( unsigned int i = 0; i < width * height; ++i )
    {
        buffer[i*channels + 0] = rand()%255;
        buffer[i*channels + 1] = rand()%255;
        buffer[i*channels + 2] = rand()%255;
    }

    // upload texture data
    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
    glGenTextures(1, &tex);
    glBindTexture(GL_TEXTURE_2D, tex);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); 
    glTexImage2D(GL_TEXTURE_2D, 0, channels, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, buffer);
}


struct Vertex
{
    Vertex() : x(0), y(0), s(0), t(0) {}
    Vertex( float _x, float _y, float _s, float _t ) : x(_x), y(_y), s(_s), t(_t) {}
    float x, y;
    float s, t;
};

void display()
{
    static float currentTime = glutGet(GLUT_ELAPSED_TIME) / 1000.0f;
    float newTime = glutGet(GLUT_ELAPSED_TIME) / 1000.0f;
    float frameTime = newTime - currentTime;
    currentTime = newTime;

    vector< Vertex > verts;
    verts.push_back( Vertex( -1, -1, 0, 0 ) );
    verts.push_back( Vertex(  1, -1, 1, 0 ) );
    verts.push_back( Vertex(  1,  1, 1, 1 ) );
    verts.push_back( Vertex( -1,  1, 0, 1 ) );

    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();

    static float angle = 0;
    angle += 60 * frameTime;
    glRotatef( angle, 0, 0, 1 );
    glScalef( 5, 5, 5 );

    glUseProgram( prog );

    // load uniforms
    GLfloat projection[16];
    glGetFloatv( GL_PROJECTION_MATRIX, projection );
    GLint projection_loc = glGetUniformLocation( prog, "projection" );
    glUniformMatrix4fv( projection_loc, 1, GL_FALSE, projection );

    GLfloat modelview[16];
    glGetFloatv( GL_MODELVIEW_MATRIX, modelview );
    GLint modelview_loc = glGetUniformLocation( prog, "modelview" );
    glUniformMatrix4fv( modelview_loc, 1, GL_FALSE, modelview );

    GLint texture_loc = glGetUniformLocation( prog, "texture" );
    glUniform1i( texture_loc, 0 );    
    glActiveTexture( GL_TEXTURE0 );
    glBindTexture( GL_TEXTURE_2D, tex );

    // load attributes
    GLint position_loc = glGetAttribLocation( prog, "position" );
    glVertexAttribPointer( position_loc, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), &verts[0].x );
    glEnableVertexAttribArray( position_loc );

    GLint texcoord_loc = glGetAttribLocation( prog, "texcoord" );
    glVertexAttribPointer( texcoord_loc, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), &verts[0].s );
    glEnableVertexAttribArray( texcoord_loc );

    // render
    glDrawArrays( GL_QUADS, 0, verts.size() );

    glDisableVertexAttribArray( position_loc );
    glDisableVertexAttribArray( texcoord_loc );

    glutSwapBuffers();
}


void reshape(int w, int h)
{
    glViewport(0, 0, w, h);

    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    double aspect = (double)w / (double)h;
    glOrtho(-10*aspect, 10*aspect, -10, 10, -1, 1);
}


int main(int argc, char **argv)
{
    glutInit(&argc, argv);
    glutInitWindowSize(800,600);
    glutInitDisplayMode(GLUT_RGBA | GLUT_DEPTH | GLUT_DOUBLE);
    glutCreateWindow("GLSL");

    try
    {
        init();
    }
    catch( std::exception& e )
    {
        cout << "Init failure: " << endl << e.what() << endl;
        return EXIT_FAILURE;
    }

    glutDisplayFunc(display);
    glutIdleFunc(display);
    glutReshapeFunc(reshape);
    glutMainLoop();
    return EXIT_SUCCESS;
}

#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
使用名称空间std；
GLuint CreateShader（常量GLenum和aShaderType、常量字符串和aShaderSource）
{
GLuint着色器=glCreateShader（aShaderType）；
const GLchar*shaderString=aShaderSource.c_str（）；
GLint shaderLength=aShaderSource.size（）；
glShaderSource（着色器，1，&shaderString，&shaderLength）；
glCompileShader（着色器）；
闪烁编译；
glGetShaderiv（着色器、GL\u编译状态和编译状态）；
如果（GL_FALSE==已编译）
{
//编译失败，转储日志
闪烁loglen；
glGetShaderiv（着色器、GL\u INFO\u LOG\u LENGTH和loglen）；
向量log（loglen）；
glGetShaderInfoLog（着色器、loglen、NULL和log[0]）；
字符串类型；
开关（aShaderType）
{
案例GL_顶点着色器：type=“GL_顶点着色器”中断；
案例GL\u FRAGMENT\u着色器：type=“GL\u FRAGMENT\u着色器”中断；
默认值：type=“UNKNOWN SHADER”中断；
}
弦乐；
err您对GLTEXAGE2D（）的调用指定内部格式为GL_RGB，但上面的代码表示该格式可能是RGBA图像。这两个图像必须匹配。如果您的图像有4个通道，则内部格式需要为GL_RGBA（或另一个4通道格式）.谢谢-这可能是解决方案的一部分，但没有解决。我仍然遇到顶点/碎片着色器有助于理解的相同问题。它们编译的事实没有多大帮助。此外，问题的屏幕截图也有助于确定解决方案。纹理大小如何？请显示纹理本身。我正在尝试的纹理render是一个非常简单的红色圆圈。这里：你能解释一下我自己的代码中到底有什么问题，或者到底要修改什么吗？
#include <GL/glew.h>
#include <GL/glut.h>

#include <cstdlib>
#include <stdexcept>
#include <iostream>
#include <fstream>
#include <sstream>
#include <vector>

using namespace std;


GLuint CreateShader( const GLenum& aShaderType, const string& aShaderSource )
{
    GLuint shader = glCreateShader( aShaderType );

    const GLchar* shaderString = aShaderSource.c_str();
    GLint shaderLength = aShaderSource.size();
    glShaderSource( shader, 1, &shaderString, &shaderLength );

    glCompileShader( shader );

    GLint compiled;
    glGetShaderiv( shader, GL_COMPILE_STATUS, &compiled );    
    if( GL_FALSE == compiled )
    {
        // compile failure, dump log
        GLint loglen;
        glGetShaderiv( shader, GL_INFO_LOG_LENGTH , &loglen);

        vector< char > log( loglen );
        glGetShaderInfoLog( shader, loglen, NULL, &log[0] );

        string type;
        switch( aShaderType )
        {
            case GL_VERTEX_SHADER:      type = "GL_VERTEX_SHADER";      break;
            case GL_FRAGMENT_SHADER:    type = "GL_FRAGMENT_SHADER";    break;
            default:                    type = "UNKNOWN SHADER";        break;
        }

        stringstream err;
        err << "*** " << type << " ***" << endl;
        err << aShaderSource;
        err << "*** Compilation Log ***" << endl;
        err << string( log.begin(), log.end() );

        throw std::logic_error( err.str() );         
    }

    return shader;
}


GLuint CreateProgram( const string& aVertexShader, const string& aFragmentShader )
{
    GLuint vert = CreateShader( GL_VERTEX_SHADER, aVertexShader );
    GLuint frag = CreateShader( GL_FRAGMENT_SHADER, aFragmentShader );

    GLuint program = glCreateProgram();
    glAttachShader( program, vert );
    glAttachShader( program, frag );
    glLinkProgram( program );

    glDeleteShader( vert );
    glDeleteShader( frag );

    GLint linked;
    glGetProgramiv( program, GL_LINK_STATUS, &linked );    
    if( GL_FALSE == linked )
    {
        // link failure, dump log
        GLint loglen;
        glGetProgramiv( program, GL_INFO_LOG_LENGTH , &loglen);

        vector< char > log( loglen );
        glGetProgramInfoLog( program, loglen, NULL, &log[0] );

        stringstream err;
        err << "*** Link log ***" << endl;
        err << string( log.begin(), log.end() );
        throw std::logic_error( err.str() );         
    }

    return program;
}


string LoadFile( const string& filename )
{
    ifstream infile(filename.c_str(), ios::binary);
    istreambuf_iterator<char> begin(infile), end;
    return string(begin, end);
}


GLuint prog = 0;
GLuint tex = 0;
void init()
{
    GLenum glewError = glewInit();
    if( GLEW_OK != glewError )
    {
        stringstream err;
        err << "GLEW error: " << glewGetErrorString(glewError) << endl;
        throw std::logic_error( err.str() );      
    }    

    cout << "GLEW_VERSION : " << glewGetString(GLEW_VERSION) << endl;
    cout << "GL_VERSION   : " << glGetString(GL_VERSION) << endl;
    cout << "GLSL VERSION : " << glGetString(GL_SHADING_LANGUAGE_VERSION) << endl;
    cout << "GL_VENDOR    : " << glGetString(GL_VENDOR) << endl;
    cout << "GL_RENDERER  : " << glGetString(GL_RENDERER) << endl;    

    if( !GLEW_VERSION_2_1 )
    {
        stringstream err;
        err << "OpenGL 2.1 or better required for GLSL support." << endl;
        throw std::logic_error( err.str() ); 
    }

    // load shaders
    string vert = LoadFile( "vert.glsl" );
    string frag = LoadFile( "frag.glsl" );
    prog = CreateProgram( vert, frag );

    // create random texture
    const unsigned int width = 32;
    const unsigned int height = 32;
    const unsigned int channels = 3;
    unsigned char buffer[ width * height * channels ];
    for( unsigned int i = 0; i < width * height; ++i )
    {
        buffer[i*channels + 0] = rand()%255;
        buffer[i*channels + 1] = rand()%255;
        buffer[i*channels + 2] = rand()%255;
    }

    // upload texture data
    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
    glGenTextures(1, &tex);
    glBindTexture(GL_TEXTURE_2D, tex);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); 
    glTexImage2D(GL_TEXTURE_2D, 0, channels, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, buffer);
}


struct Vertex
{
    Vertex() : x(0), y(0), s(0), t(0) {}
    Vertex( float _x, float _y, float _s, float _t ) : x(_x), y(_y), s(_s), t(_t) {}
    float x, y;
    float s, t;
};

void display()
{
    static float currentTime = glutGet(GLUT_ELAPSED_TIME) / 1000.0f;
    float newTime = glutGet(GLUT_ELAPSED_TIME) / 1000.0f;
    float frameTime = newTime - currentTime;
    currentTime = newTime;

    vector< Vertex > verts;
    verts.push_back( Vertex( -1, -1, 0, 0 ) );
    verts.push_back( Vertex(  1, -1, 1, 0 ) );
    verts.push_back( Vertex(  1,  1, 1, 1 ) );
    verts.push_back( Vertex( -1,  1, 0, 1 ) );

    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();

    static float angle = 0;
    angle += 60 * frameTime;
    glRotatef( angle, 0, 0, 1 );
    glScalef( 5, 5, 5 );

    glUseProgram( prog );

    // load uniforms
    GLfloat projection[16];
    glGetFloatv( GL_PROJECTION_MATRIX, projection );
    GLint projection_loc = glGetUniformLocation( prog, "projection" );
    glUniformMatrix4fv( projection_loc, 1, GL_FALSE, projection );

    GLfloat modelview[16];
    glGetFloatv( GL_MODELVIEW_MATRIX, modelview );
    GLint modelview_loc = glGetUniformLocation( prog, "modelview" );
    glUniformMatrix4fv( modelview_loc, 1, GL_FALSE, modelview );

    GLint texture_loc = glGetUniformLocation( prog, "texture" );
    glUniform1i( texture_loc, 0 );    
    glActiveTexture( GL_TEXTURE0 );
    glBindTexture( GL_TEXTURE_2D, tex );

    // load attributes
    GLint position_loc = glGetAttribLocation( prog, "position" );
    glVertexAttribPointer( position_loc, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), &verts[0].x );
    glEnableVertexAttribArray( position_loc );

    GLint texcoord_loc = glGetAttribLocation( prog, "texcoord" );
    glVertexAttribPointer( texcoord_loc, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), &verts[0].s );
    glEnableVertexAttribArray( texcoord_loc );

    // render
    glDrawArrays( GL_QUADS, 0, verts.size() );

    glDisableVertexAttribArray( position_loc );
    glDisableVertexAttribArray( texcoord_loc );

    glutSwapBuffers();
}


void reshape(int w, int h)
{
    glViewport(0, 0, w, h);

    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    double aspect = (double)w / (double)h;
    glOrtho(-10*aspect, 10*aspect, -10, 10, -1, 1);
}


int main(int argc, char **argv)
{
    glutInit(&argc, argv);
    glutInitWindowSize(800,600);
    glutInitDisplayMode(GLUT_RGBA | GLUT_DEPTH | GLUT_DOUBLE);
    glutCreateWindow("GLSL");

    try
    {
        init();
    }
    catch( std::exception& e )
    {
        cout << "Init failure: " << endl << e.what() << endl;
        return EXIT_FAILURE;
    }

    glutDisplayFunc(display);
    glutIdleFunc(display);
    glutReshapeFunc(reshape);
    glutMainLoop();
    return EXIT_SUCCESS;
}