Использование буфера индексов, наложение текстуры

#include <iostream>
#include <windows.h>
#include <GL/gl.h>
#include <GL/glut.h>
#include <cmath>
float zzz = 1.0f;
float xxx = 0.0f;
float yyy = 0.0f;
GLfloat rtri = 0.0f;
GLfloat rtri2 = -240.0f;
 
GLsizei width = 800, height = 600;
void *font = GLUT_STROKE_ROMAN;
char s[50] = { 'A', ' ', 'G', 'R', 'E', 'B', 'N', 'E', 'V', '\0' };
void renderBitmapString(
    float x,
    float y,
    float z,
    void *font,
    char *string) {
    glColor3f(1.0f, 0.0f, 0.0f);
    char *c;
    glRasterPos3f(x, y, z);
    for (c = string; *c != '\0'; c++) {
        glutBitmapCharacter(font, *c);
    }
}
 
void setOrthographicProjection()
{
    //выбрать режим проекции
    glMatrixMode(GL_PROJECTION);
    //Сохраняем предыдущую матрицу, которая содерж
    //параметры перспективной проекции
    glPushMatrix();
    //обнуляем матрицу
    glLoadIdentity();
    //устанавливаем 2D ортогональную проекцию
    gluOrtho2D(0, width, height, 0);
    //выбираем режим обзора модели
    glMatrixMode(GL_MODELVIEW);
}
 
void setOrthographicProjection2()
{
    GLfloat aspect;
 
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    aspect = (GLfloat)width / (GLfloat)height;
    /*if(width <= height)
        glOrtho(-100.0, 100.0, -100.0/aspect, 100.0/aspect, 1.0, -1.0);
    else
        glOrtho(-100.0 * aspect, 100.0 * aspect, -100.0, 100.0, 1.0, -1.0);*/
    double ratio = width * 1.0 / height;
    gluPerspective(45.0f, aspect, 0.1, 1000.0f);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
}
 
 
void RenderScene()
{
    glClearColor(1.0f, 0.6f, 0.4f, 1.0f);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    //Код для отображения строки (кадров в секунду) с растровых шрифтов
    setOrthographicProjection();
    glPushMatrix();
    glLoadIdentity();
    renderBitmapString(450, 500, 0, GLUT_BITMAP_HELVETICA_18, s);
    glPopMatrix();
 
 
 
 
 
    setOrthographicProjection2();
    glColor3f(0.0f, 0.0f, 1.0f);
    glTranslated(0.0f, 0.0f, rtri2);
    glRotatef(rtri, 0.0f, 1.0, 0.0f);
    glBegin(GL_TRIANGLES);
    glVertex2f(-20.0f, 0.0f);
 
    glVertex2f(20.0f, 0.0f);
    glVertex2f(0.0f, 40.0f);
    glVertex2f(-20.0f, 0.0f);
    glVertex2f(-60.0f, -20.0f);
    glVertex2f(-20.0f, -40.0f);
    glVertex2f(-20.0f, -40.0f);
    glVertex2f(0.0f, -80.0f);
    glVertex2f(20.0f, -40.0f);
    glVertex2f(20.0f, -40.0f);
    glVertex2f(60.0f, -20.0f);
 
    //квадрат по центре
    glVertex2f(20.0f, 0.0f);
    glVertex2f(-20.0f, 0.0f);
    glVertex2f(-20.0f, -40.0f);
    glVertex2f(20.0f, 0.0f);
    glVertex2f(-20.0f, -40.0f);
    glVertex2f(20.0f, -40.0f);
    glVertex2f(20.0f, 0.0f);
    glEnd();
 
    glFlush();
    glutSwapBuffers();
}
 
 
void ChangeSize(GLsizei w, GLsizei h)
{
    width = w;
    height = h;
    GLfloat aspect;
    //убераем деление на ноль
    if (h == 0)
        h = 1;
    glViewport(0, 0, w, h);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    aspect = (GLfloat)w / (GLfloat)h;
    if (w <= h)
        glOrtho(-100.0, 100.0, -100.0 / aspect, 100.0 / aspect, 1.0, -1.0);
    else
        glOrtho(-100.0 * aspect, 100.0 * aspect, -100.0, 100.0, 1.0, -1.0);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
}
 
 
int temp = 0;
void TimerFunction(int value)
{
    rtri += 1.0f;
 
    rtri2 -= 0.2f;
 
    std::cout << rtri2 << "\n";
    glutPostRedisplay();
    glutTimerFunc(10, TimerFunction, 1);
}
 
int main(int argc, char** argv)
{
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA);
    glutInitWindowSize(800, 600);
    glutCreateWindow("GLRect");
    glutDisplayFunc(RenderScene);
    glutReshapeFunc(ChangeSize);
    glutTimerFunc(10, TimerFunction, 1);
    glutMainLoop();
    return 0;
}

#include <windows.h>
#include <GL/glut.h>
 
 
#include "lodepng.h"
#include <iostream>
#include <vector>
#include <sstream>
#include <iomanip>
using std::stringstream;
using std::cout;
using std::endl;
using std::ends;
using std::vector;
 
 
GLfloat vertecs_star[] =
{
    -1,1,0,
1,-1,-0,
-1,-1,-0,
-1,1,0,
0,3.98391,0.476721,
1,1,0,
1,-1,-0,
0,-3.96197,0.476721,
-1,-1,-0,
1,1,0,
4.00585,0,0.476721,
1,-1,-0,
-1,-1,-0,
-3.94003,0,0.476721,
-1,1,0,
1,-1,0.953442,
-1,1,0.953442,
-1,-1,0.953442,
-1,1,0.953442,
1,1,0.953442,
0,3.98391,0.476721,
1,-1,0.953442,
-1,-1,0.953442,
0,-3.96197,0.476721,
1,1,0.953442,
1,-1,0.953442,
4.00585,0,0.476721,
-1,-1,0.953442,
-1,1,0.953442,
-3.94003,0,0.476721,
-3.94003,0,0.476721,
-1,-1,-0,
-1,-1,0.953442,
0,3.98391,0.476721,
-1,1,0,
-1,1,0.953442,
-1,1,0,
-3.94003,0,0.476721,
-1,1,0.953442,
1,1,0,
0,3.98391,0.476721,
1,1,0.953442,
0,-3.96197,0.476721,
1,-1,-0,
1,-1,0.953442,
-1,-1,-0,
0,-3.96197,0.476721,
-1,-1,0.953442,
4.00585,0,0.476721,
1,1,0,
1,1,0.953442,
1,-1,-0,
4.00585,0,0.476721,
1,-1,0.953442,
-1,1,0,
1,1,0,
1,-1,-0,
1,-1,0.953442,
1,1,0.953442,
-1,1,0.953442
};
 
GLfloat uv_star[] =
{
0.140969,0.747455,
0.377947,0.746818,
0.25914,0.628647,
0.140969,0.747455,
0.021831,0.986043,
0.259776,0.865625,
0.377947,0.746818,
0.495805,0.509516,
0.25914,0.628647,
0.259776,0.865625,
0.499652,0.986043,
0.377947,0.746818,
0.25914,0.628647,
0.023125,0.512069,
0.140969,0.747455,
0.378615,0.263319,
0.141637,0.262682,
0.259808,0.38149,
0.141637,0.262682,
0.260444,0.144512,
0.022499,0.024094,
0.378615,0.263319,
0.259808,0.38149,
0.496472,0.500621,
0.260444,0.144512,
0.378615,0.263319,
0.50032,0.024094,
0.259808,0.38149,
0.141637,0.262682,
0.023792,0.498068,
0.512264,0.875897,
0.760786,0.789119,
0.723313,0.718569,
0.97894,0.114558,
0.712259,0.114558,
0.724224,0.193541,
0.712259,0.114558,
0.460988,0.193019,
0.724224,0.193541,
0.722014,0.627771,
0.93806,0.47143,
0.685404,0.55677,
0.47587,0.341818,
0.740827,0.342337,
0.728939,0.263343,
0.760786,0.789119,
0.973372,0.630975,
0.723313,0.718569,
0.467808,0.71391,
0.722014,0.627771,
0.685404,0.55677,
0.740827,0.342337,
0.997343,0.263343,
0.728939,0.263343,
0.140969,0.747455,
0.259776,0.865625,
0.377947,0.746818,
0.378615,0.263319,
0.260444,0.144512,
0.141637,0.262682
};
 
 
GLubyte indices_star[]  =
{
0,
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,
31,
32,
33,
34,
35,
36,
37,
38,
39,
40,
41,
42,
43,
44,
45,
46,
47,
48,
49,
50,
51,
52,
53,
54,
55,
56,
57,
58,
59
};
 
 
// GLUT CALLBACK functions
void displayCB();
void reshapeCB(int w, int h);
void timerCB(int millisec);
void keyboardCB(unsigned char key, int x, int y);
void mouseCB(int button, int stat, int x, int y);
void mouseMotionCB(int x, int y);
 
void initGL();
int  initGLUT(int argc, char **argv);
bool initSharedMem();
void initLights();
void setCamera(float posX, float posY, float posZ, float targetX, float targetY, float targetZ);
void drawString(const char *str, int x, int y, float color[4], void *font);
void drawString3D(const char *str, float pos[3], float color[4], void *font);
void toOrtho();
void toPerspective();
void draw();
unsigned int LoadeTexturePng(std::string filename);
 
// constants
const int   SCREEN_WIDTH    = 800;
const int   SCREEN_HEIGHT   = 600;
const float CAMERA_DISTANCE = 10.0f;
const int   TEXT_WIDTH      = 8;
const int   TEXT_HEIGHT     = 13;
 
 
// global variables
void *font = GLUT_BITMAP_8_BY_13;
int screenWidth;
int screenHeight;
bool mouseLeftDown;
bool mouseRightDown;
bool mouseMiddleDown;
float mouseX, mouseY;
float cameraAngleX;
float cameraAngleY;
float cameraDistance;
int drawMode;
int maxVertices;
int maxIndices;
 
unsigned int Star_texture;
 
void draw()
{
    // enable and specify pointers to vertex arrays
    //glEnableClientState(GL_NORMAL_ARRAY);
    glEnableClientState(GL_VERTEX_ARRAY);
    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
    //glNormalPointer(GL_FLOAT, 3 * sizeof(GLfloat), normal);
 
    glVertexPointer(3, GL_FLOAT, 3 * sizeof(GLfloat), vertecs_star);
    glTexCoordPointer( 2, GL_FLOAT, 2 * sizeof(GLfloat), uv_star );
 
    //glColor3f(0.0f, 0.0f, 1.0f);
    glPushMatrix();
        //glTranslatef(-2, -2, 0);                // move to bottom-left
        glBindTexture(GL_TEXTURE_2D, Star_texture);
        glDrawElements(GL_TRIANGLES, 60, GL_UNSIGNED_BYTE, indices_star);
    glPopMatrix();
 
    glDisableClientState(GL_VERTEX_ARRAY);  // disable vertex arrays
    glDisableClientState(GL_TEXTURE_COORD_ARRAY);
    //glDisableClientState(GL_NORMAL_ARRAY);
}
 
 
 
 
 
 
///////////////////////////////////////////////////////////////////////////////
int main(int argc, char **argv)
{
    // init global vars
    initSharedMem();
 
    // init GLUT and GL
    initGLUT(argc, argv);
    initGL();
 
 
    // check max of elements vertices and elements indices that your video card supports
    // Use these values to determine the range of glDrawRangeElements()
    // The constants are defined in glext.h
    //glGetIntegerv(GL_MAX_ELEMENTS_VERTICES, &maxVertices);
    //glGetIntegerv(GL_MAX_ELEMENTS_INDICES, &maxIndices);
/*
#ifdef _WIN32
    // get function pointer to glDrawRangeElements
    glDrawRangeElements = (PFNGLDRAWRANGEELEMENTSPROC)wglGetProcAddress("glDrawRangeElements");
#endif*/
 
    // the last GLUT call (LOOP)
    // window will be shown and display callback is triggered by events
    // NOTE: this call never return main().
    glutMainLoop(); /* Start GLUT event-processing loop */
 
    return 0;
}
 
 
 
///////////////////////////////////////////////////////////////////////////////
// initialize GLUT for windowing
///////////////////////////////////////////////////////////////////////////////
int initGLUT(int argc, char **argv)
{
    // GLUT stuff for windowing
    // initialization openGL window.
    // it is called before any other GLUT routine
    glutInit(&argc, argv);
 
    glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH | GLUT_STENCIL);   // display mode
 
    glutInitWindowSize(screenWidth, screenHeight);  // window size
 
    glutInitWindowPosition(100, 100);               // window location
 
    // finally, create a window with openGL context
    // Window will not displayed until glutMainLoop() is called
    // it returns a unique ID
    int handle = glutCreateWindow(/*argv[0]*/"SuperStar");     // param is the title of window
 
    // register GLUT callback functions
    glutDisplayFunc(displayCB);
    glutTimerFunc(33, timerCB, 33);             // redraw only every given millisec
    glutReshapeFunc(reshapeCB);
    glutKeyboardFunc(keyboardCB);
    glutMouseFunc(mouseCB);
    glutMotionFunc(mouseMotionCB);
 
    return handle;
}
 
 
 
///////////////////////////////////////////////////////////////////////////////
// initialize OpenGL
// disable unused features
///////////////////////////////////////////////////////////////////////////////
void initGL()
{
    glShadeModel(GL_SMOOTH);                    // shading mathod: GL_SMOOTH or GL_FLAT
    glPixelStorei(GL_UNPACK_ALIGNMENT, 4);      // 4-byte pixel alignment
 
    // enable /disable features
    glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
    //glHint(GL_LINE_SMOOTH_HINT, GL_NICEST);
    //glHint(GL_POLYGON_SMOOTH_HINT, GL_NICEST);
    glEnable(GL_DEPTH_TEST);
    glEnable(GL_LIGHTING);
    glEnable(GL_TEXTURE_2D);
    glEnable(GL_CULL_FACE);
    glEnable(GL_TEXTURE_2D);
 
    //Star_texture = LoadeTexturePng("Star.png");
    Star_texture = LoadeTexturePng("Texture2.png");
     // track material ambient and diffuse from surface color, call it before glEnable(GL_COLOR_MATERIAL)
    glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
    glEnable(GL_COLOR_MATERIAL);
 
    glClearColor(0, 0, 0, 0);                   // background color
    glClearStencil(0);                          // clear stencil buffer
    glClearDepth(1.0f);                         // 0 is near, 1 is far
    glDepthFunc(GL_LEQUAL);
 
    initLights();
}
 
 
 
///////////////////////////////////////////////////////////////////////////////
// write 2d text using GLUT
// The projection matrix must be set to orthogonal before call this function.
///////////////////////////////////////////////////////////////////////////////
void drawString(const char *str, int x, int y, float color[4], void *font)
{
    glPushAttrib(GL_LIGHTING_BIT | GL_CURRENT_BIT); // lighting and color mask
    glDisable(GL_LIGHTING);     // need to disable lighting for proper text color
    glDisable(GL_TEXTURE_2D);
 
    glColor4fv(color);          // set text color
    glRasterPos2i(x, y);        // place text position
 
    // loop all characters in the string
    while(*str)
    {
        glutBitmapCharacter(font, *str);
        ++str;
    }
 
    glEnable(GL_TEXTURE_2D);
    glEnable(GL_LIGHTING);
    glPopAttrib();
}
 
 
 
///////////////////////////////////////////////////////////////////////////////
// draw a string in 3D space
///////////////////////////////////////////////////////////////////////////////
void drawString3D(const char *str, float pos[3], float color[4], void *font)
{
    glPushAttrib(GL_LIGHTING_BIT | GL_CURRENT_BIT); // lighting and color mask
    glDisable(GL_LIGHTING);     // need to disable lighting for proper text color
    glDisable(GL_TEXTURE_2D);
 
    glColor4fv(color);          // set text color
    glRasterPos3fv(pos);        // place text position
 
    // loop all characters in the string
    while(*str)
    {
        glutBitmapCharacter(font, *str);
        ++str;
    }
 
    glEnable(GL_TEXTURE_2D);
    glEnable(GL_LIGHTING);
    glPopAttrib();
}
 
 
 
///////////////////////////////////////////////////////////////////////////////
// initialize global variables
///////////////////////////////////////////////////////////////////////////////
bool initSharedMem()
{
    screenWidth = SCREEN_WIDTH;
    screenHeight = SCREEN_HEIGHT;
 
    mouseLeftDown = mouseRightDown = mouseMiddleDown = false;
    mouseX = mouseY = 0;
 
    cameraAngleX = cameraAngleY = 0.0f;
    cameraDistance = CAMERA_DISTANCE;
 
    drawMode = 0; // 0:fill, 1: wireframe, 2:points
    maxVertices = maxIndices = 0;
 
    return true;
}
 
 
///////////////////////////////////////////////////////////////////////////////
// initialize lights
///////////////////////////////////////////////////////////////////////////////
void initLights()
{
    // set up light colors (ambient, diffuse, specular)
    GLfloat lightKa[] = {.2f, .2f, .2f, 1.0f};  // ambient light
    GLfloat lightKd[] = {.7f, .7f, .7f, 1.0f};  // diffuse light
    GLfloat lightKs[] = {1, 1, 1, 1};           // specular light
    glLightfv(GL_LIGHT0, GL_AMBIENT, lightKa);
    glLightfv(GL_LIGHT0, GL_DIFFUSE, lightKd);
    glLightfv(GL_LIGHT0, GL_SPECULAR, lightKs);
 
    // position the light
    float lightPos[4] = {0, 0, 20, 1}; // positional light
    glLightfv(GL_LIGHT0, GL_POSITION, lightPos);
 
    glEnable(GL_LIGHT0);                        // MUST enable each light source after configuration
}
 
 
 
///////////////////////////////////////////////////////////////////////////////
// set camera position and lookat direction
///////////////////////////////////////////////////////////////////////////////
void setCamera(float posX, float posY, float posZ, float targetX, float targetY, float targetZ)
{
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    gluLookAt(posX, posY, posZ, targetX, targetY, targetZ, 0, 1, 0); // eye(x,y,z), focal(x,y,z), up(x,y,z)
}
 
 
 
///////////////////////////////////////////////////////////////////////////////
// display info messages
///////////////////////////////////////////////////////////////////////////////
void showInfo()
{
    // backup current model-view matrix
    glPushMatrix();                     // save current modelview matrix
    glLoadIdentity();                   // reset modelview matrix
 
    // set to 2D orthogonal projection
    glMatrixMode(GL_PROJECTION);        // switch to projection matrix
    glPushMatrix();                     // save current projection matrix
    glLoadIdentity();                   // reset projection matrix
    gluOrtho2D(0, screenWidth, 0, screenHeight); // set to orthogonal projection
 
    float color[4] = {1, 1, 1, 1};
 
    stringstream ss;
    ss << std::fixed << std::setprecision(3);
 
 
 
    ss << "Author: Antikl" << ends;
    drawString(ss.str().c_str(), 1, screenHeight-TEXT_HEIGHT, color, font);
    ss.str("");
 
    ss << "Created at 9:55 p.m., Feb 18, 2020" << ends;
    drawString(ss.str().c_str(), 1, screenHeight-(2*TEXT_HEIGHT), color, font);
    ss.str("");
 
    // unset floating format
    ss << std::resetiosflags(std::ios_base::fixed | std::ios_base::floatfield);
 
    // restore projection matrix
    glPopMatrix();                   // restore to previous projection matrix
 
    // restore modelview matrix
    glMatrixMode(GL_MODELVIEW);      // switch to modelview matrix
    glPopMatrix();                   // restore to previous modelview matrix
}
 
 
 
///////////////////////////////////////////////////////////////////////////////
// set projection matrix as orthogonal
///////////////////////////////////////////////////////////////////////////////
void toOrtho()
{
    // set viewport to be the entire window
    glViewport(0, 0, (GLsizei)screenWidth, (GLsizei)screenHeight);
 
    // set orthographic viewing frustum
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glOrtho(0, screenWidth, 0, screenHeight, -1, 1);
 
    // switch to modelview matrix in order to set scene
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
}
 
 
 
///////////////////////////////////////////////////////////////////////////////
// set the projection matrix as perspective
///////////////////////////////////////////////////////////////////////////////
void toPerspective()
{
    // set viewport to be the entire window
    glViewport(0, 0, (GLsizei)screenWidth, (GLsizei)screenHeight);
 
    // set perspective viewing frustum
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluPerspective(60.0f, (float)(screenWidth)/screenHeight, 1.0f, 1000.0f); // FOV, AspectRatio, NearClip, FarClip
 
    // switch to modelview matrix in order to set scene
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
}
 
 
 
 
 
 
 
 
 
//=============================================================================
// CALLBACKS
//=============================================================================
 
void displayCB()
{
    // clear buffer
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
 
    // save the initial ModelView matrix before modifying ModelView matrix
    glPushMatrix();
 
    // tramsform camera
    glTranslatef(0, 0, -cameraDistance);
    glRotatef(cameraAngleX, 1, 0, 0);   // pitch
    glRotatef(cameraAngleY, 0, 1, 0);   // heading
 
    draw();        // with glDrawElements() with interleave vertex array
 
 
    // print 2D text
    float pos[4] = {-4.0f,3.5f,0,1};
    float color[4] = {1,1,1,1};
    pos[0] = -5.0f; pos[1] = -2.0f;
    drawString3D("glDrawElements()", pos, color, font);
 
    showInfo();     // print max range of glDrawRangeElements
 
    glPopMatrix();
 
    glutSwapBuffers();
}
 
 
void reshapeCB(int w, int h)
{
    screenWidth = w;
    screenHeight = h;
    toPerspective();
}
 
 
void timerCB(int millisec)
{
    glutTimerFunc(millisec, timerCB, millisec);
    glutPostRedisplay();
}
 
 
void keyboardCB(unsigned char key, int x, int y)
{
    switch(key)
    {
    case 27: // ESCAPE
        exit(0);
        break;
 
    case 'd': // switch rendering modes (fill -> wire -> point)
    case 'D':
        drawMode = ++drawMode % 3;
        if(drawMode == 0)        // fill mode
        {
            glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
            glEnable(GL_DEPTH_TEST);
            glEnable(GL_CULL_FACE);
        }
        else if(drawMode == 1)  // wireframe mode
        {
            glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
            glDisable(GL_DEPTH_TEST);
            glDisable(GL_CULL_FACE);
        }
        else                    // point mode
        {
            glPolygonMode(GL_FRONT_AND_BACK, GL_POINT);
            glDisable(GL_DEPTH_TEST);
            glDisable(GL_CULL_FACE);
        }
        break;
 
    default:
        ;
    }
}
 
 
void mouseCB(int button, int state, int x, int y)
{
    mouseX = x;
    mouseY = y;
 
    if(button == GLUT_LEFT_BUTTON)
    {
        if(state == GLUT_DOWN)
        {
            mouseLeftDown = true;
        }
        else if(state == GLUT_UP)
            mouseLeftDown = false;
    }
 
    else if(button == GLUT_RIGHT_BUTTON)
    {
        if(state == GLUT_DOWN)
        {
            mouseRightDown = true;
        }
        else if(state == GLUT_UP)
            mouseRightDown = false;
    }
 
    else if(button == GLUT_MIDDLE_BUTTON)
    {
        if(state == GLUT_DOWN)
        {
            mouseMiddleDown = true;
        }
        else if(state == GLUT_UP)
            mouseMiddleDown = false;
    }
}
 
 
void mouseMotionCB(int x, int y)
{
    if(mouseLeftDown)
    {
        cameraAngleY += (x - mouseX);
        cameraAngleX += (y - mouseY);
        mouseX = x;
        mouseY = y;
    }
    if(mouseRightDown)
    {
        cameraDistance -= (y - mouseY) * 0.2f;
        mouseY = y;
    }
}
 
//Loaded texture png
unsigned int LoadeTexturePng(std::string filename)
{
 
    unsigned int texture2;
    std::vector<unsigned char> image;
    unsigned width_imag, height_imag;
    unsigned error = lodepng::decode(image, width_imag, height_imag, filename.c_str());
 
    // If there's an error, display it.
    if(error != 0) {
        std::cout << "error " << error << ": " << lodepng_error_text(error) << std::endl;
    }
 
 
    // Texture size must be power of two for the primitive OpenGL version this is written for. Find next power of two.
    size_t u2 = 1; while(u2 < width_imag) u2 *= 2;
    size_t v2 = 1; while(v2 < height_imag) v2 *= 2;
    // Ratio for power of two version compared to actual version, to render the non power of two image with proper size.
    //double u3 = (double)width_imag / u2;
    //double v3 = (double)height_imag / v2;
      // Make power of two version of the image.
 
    std::vector<unsigned char> image2(u2 * v2 * 4);
    //std::cout<<"fffAAA"<<u2 * v2 * 4;
    for(size_t y = 0; y < height_imag; y++)
    for(size_t x = 0; x < width_imag; x++)
    for(size_t c = 0; c < 4; c++) {
        image2[4 * u2 * y + 4 * x + c] = image[4 * width_imag * y + 4 * x + c];
    }
 
      // Enable the texture for OpenGL.
 
    glGenTextures(1, &texture2);
    glBindTexture(GL_TEXTURE_2D, texture2);
    //glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); //GL_NEAREST = no smoothing
    //glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,     GL_REPEAT);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,     GL_REPEAT);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexImage2D(GL_TEXTURE_2D, 0, 4, u2, v2, 0, GL_RGBA, GL_UNSIGNED_BYTE, &image2[0]);
    return texture2;
}