OpenGL Rectangle Wonder wird nicht rendern

Question

Ich lerne OpenGL API und ich habe einige Herausforderungen. Mein Rechteck wird nicht geladen. Der Würfel enthält die Daten für den Scheitelpunkt. und der VAO, EBO und BAO.Ich kann nicht lokalisieren, wo mein Fehler ist. Mein Laptop unterstützt GLSL 1.2 als höchste Version.

#include "cube.h" 
Cube::Cube(std::vector<GLfloat> vertices, std::vector<GLfloat> indices) 
{ 
glGenVertexArrays(1,&VAO); 
glGenBuffers(1,&BAO); 
glGenBuffers(1,&EAO); 
this->vertices=vertices; 
this->indices=indices; 
} 
void Cube::setupshader(){ 
glBindVertexArray(VAO); 
glBindBuffer(GL_ARRAY_BUFFER,BAO); 
glBufferData(GL_ARRAY_BUFFER,vertices.size()*sizeof(GLfloat),&vertices[0],GL_ STATIC_DRAW); 
glBindBuffer(GL_ARRAY_BUFFER,EAO); 
glBufferData(GL_ELEMENT_ARRAY_BUFFER,vertices.size()*sizeof(GLfloat),&vertices[0],GL_STATIC_DRAW); 

glEnableVertexAttribArray(0); 
glVertexAttribPointer(0,3,GL_FLOAT,GL_FALSE,3*sizeof(GLfloat), (GLvoid*)0); 


} 

Die Shader-Klasse kompiliert die Shader und verknüpft das Programm. und gibt das Programm zurück.

#include "shader.h" 

shader::shader(GLchar* vertexShader,GLchar* fragmentShader):vertexShader(vertexShader),fragmentShader(fragmentShader) 
{ 

} 

GLuint shader::processShaders(){ 
GLuint vertexObject=glCreateShader(GL_VERTEX_SHADER); 
GLuint fragmentObject=glCreateShader(GL_FRAGMENT_SHADER); 
glShaderSource(vertexObject,1,&vertexShader,NULL); 
glShaderSource(fragmentObject,1,&fragmentShader,NULL); 
glCompileShader(vertexObject); 
GLint success; 
GLchar log[512]; 
glGetShaderiv(vertexObject,GL_COMPILE_STATUS,&success); 
if(!success){ 
    glGetShaderInfoLog(vertexObject,512,NULL,log); 
    std::cout<<"error: "<<log<<std::flush; 

} 
else{ 
    std::cout<<"vertex shader compiles success"<<std::endl; 
} 
glCompileShader(fragmentObject); 
glGetShaderiv(fragmentObject,GL_COMPILE_STATUS,&success); 
if(!success){ 
    std::fill_n(log,512,0); 
    glGetShaderInfoLog(fragmentObject,512,NULL,log); 
    std::cout<<"error "<<log<<std::endl; 
}else{ 
    std::cout<<"fragment shader compiles success\n"; 
} 
GLuint program=glCreateProgram(); 
glAttachShader(program,vertexObject); 
glAttachShader(program,fragmentObject); 
/*glBindAttribLocation(program,0,"position"); 
glBindAttribLocation(program,1,"normals"); 
glBindAttribLocation(program,2,"TextureCoord"); 
glBindAttribLocation(program,3,"MVPmatrix");*/ 
glLinkProgram(program); 
glGetProgramiv(program,GL_LINK_STATUS,&success); 
if(!success){ 
    std::fill_n(log,512,0); 
    glGetProgramInfoLog(program,512,NULL,log); 
    std::cout<<"program link error: "<<log<<std::flush; 
} 
else{ 
    glUseProgram(program); 
    return program; 
} 
} 

Die Klassenschublade zeichnet das Rechteck aus den angegebenen Daten.

#include "drawer.h" 

drawer::drawer() 
{ 

} 

void drawer::addCubes(Cube object){ 
this->cubes.push_back(object); 
} 
void drawer::addShaders(shader object){ 
this->shaders.push_back(object); 
} 
void drawer::draw_cubes(){ 

for(int i=0;i<this->cubes.size();i++){ 
    shaders.at(i).processShaders(); 
    cubes.at(i).setupshader(); 

    //std::cout<<"program number:"<<program<<std::endl; 
    //glUseProgram(program); 
    glBindVertexArray(cubes.at(i).VAO); 

    glDrawElements(GL_TRIANGLES,6,GL_UNSIGNED_INT,0); 

    } 
    } 

dies ist die Hauptroutine:

#include <iostream> 

// GLEW 
#define GLEW_STATIC 
#include <GL/glew.h> 

// GLFW 
#include <GLFW/glfw3.h> 
#include<cube.h> 
#include<shader.h> 
#include<drawer.h> 

// Function prototypes 
void key_callback(GLFWwindow* window, int key, int scancode, int action, int mode); 

// Window dimensions 
const GLuint WIDTH = 800, HEIGHT = 600; 

// The MAIN function, from here we start the application and run the game loop 
int main() 
{ 
std::cout << "Starting GLFW context, OpenGL 3.3" << std::endl; 
// Init GLFW 
glewExperimental=GL_TRUE; 
glfwInit(); 
// Set all the required options for GLFW 



glfwWindowHint(GLFW_RESIZABLE, GL_TRUE); 

// Create a GLFWwindow object that we can use for GLFW's functions 
GLFWwindow* window = glfwCreateWindow(WIDTH, HEIGHT, "LearnOpenGL", NULL, NULL); 
if (window == nullptr) 
{ 
    std::cout << "Failed to create GLFW window" << std::endl; 
    glfwTerminate(); 
    return -1; 
} 
glfwMakeContextCurrent(window); 
glfwSwapInterval(1); 
// Set the required callback functions 
glfwSetKeyCallback(window, key_callback); 

// Set this to true so GLEW knows to use a modern approach to retrieving  function pointers and extensions 
    glewExperimental = GL_TRUE; 
    // Initialize GLEW to setup the OpenGL Function pointers 
    if (glewInit() != GLEW_OK) 
    { 
    std::cout << "Failed to initialize GLEW" << std::endl; 
    return -1; 
    } 

    // Define the viewport dimensions 
    glViewport(0, 0, WIDTH, HEIGHT); 


    //MYVARIABLES 

std::vector<GLfloat> vertices{0.5f, 0.5f, 0.0f, 
          0.5f, -0.5f, 0.0f, 
          -0.5f, -0.5f, 0.0f, 
          -0.5f, 0.5f, 0.0f }; 



std::vector<GLfloat> indices{0, 1, 3, 
         1, 2, 3 }; 
Cube mycube(vertices,indices); 

GLchar* vertexShader={"#version 120\n" 
        "attribute vec3 position;" 
        "attribute vec3 normals;" 
        "attribute vec2 TextureCoord;" 
        "uniform mat4 MVPmatrix;" 
        "void main(){" 
        "gl_Position=vec4(position,1.0);" 
        "}"}; 
GLchar* fragmentShader={"#version 120\n" 
        "void main(){" 
        "gl_FragColor=vec4(1.0,0.0,1.0,1.0);" 
        "}"}; 
shader myshader(vertexShader,fragmentShader); 
drawer mychalk; 
mychalk.addCubes(mycube); 
mychalk.addShaders(myshader); 




//ENDOFMYVARIABLES 

// Game loop 
while (!glfwWindowShouldClose(window)) 
{ 
    // Check if any events have been activated (key pressed, mouse moved etc.) and call corresponding response functions 
    glfwPollEvents(); 

    // Render 
    // Clear the colorbuffer 
    glClearColor(0.2f, 0.3f, 0.3f, 1.0f); 
    glClear(GL_COLOR_BUFFER_BIT); 
    mychalk.draw_cubes(); 
    // Swap the screen buffers 
    glfwSwapBuffers(window); 

} 

// Terminate GLFW, clearing any resources allocated by GLFW. 
glfwTerminate(); 
return 0; 
} 

// Is called whenever a key is pressed/released via GLFW 
void key_callback(GLFWwindow* window, int key, int scancode, int action,  int mode) 
{ 
std::cout << key << std::endl; 
if (key == GLFW_KEY_ESCAPE && action == GLFW_PRESS) 
    glfwSetWindowShouldClose(window, GL_TRUE); 
} 

Answer 1

ich die Funktion glDrawArrays verwenden entschieden() anstelle von glDrawElements und vorgesehen, um das BAO Objekt mit allen Eckpunkten; alle Scheitelpunkte unabhängig davon, ob sie wiederholt werden und dadurch die Notwendigkeit für das EBO beseitigt wird. Mit der kleinen Änderung funktionierte der Code einwandfrei.