Perspektivprojektion funktioniert nicht ordnungsgemäß OpenGL C ++ ⇐ C++

[Anonymous]

Ich versuche, einen 3D -Cude im Fenster zu rendern und die Perspektivprojektion zu beobachten. Wenn ich die Perspektivprojektionsmatrix multipliziere, scheint der Würfel zu vergrößert zu sein oder nur ein schwarzes Fenster erscheint. CPP unter; < /p>

Code: Select all

//Vertex Shader
#version 420 core

layout (location = 0) in vec3 pos;

out vec4 col;

uniform mat4 model;
uniform mat4 projection;

void main(){
gl_Position = model *projection* vec4(pos,1.0f);
col = vec4(clamp(pos, 0.1f, 100.0f), 1.0f);
}
< /code>
#include 
#include 
#include 

#include 
#include 

#include 
#include 
#include 

#include "Window.h"
#include "Shader.h"
#include "Buffers.h"
#include "Camera.h"
Window window;
std::vector bufferList;
std::vector shaderList;

static const char* vShader = "Shaders/shader.vert";
static const char* fShader = "Shaders/shader.frag";

void CreateObjects() {

GLfloat Cubevertices[] = {
1.0f,1.0f,1.0f,      //0
-1.0f,1.0f,1.0f,     //1
1.0f,-1.0f,1.0f,     //2
-1.0f,-1.0f,1.0f,    //3
1.0f,1.0f,-1.0f,     //4
-1.0f,1.0f,-1.0f,    //5
-1.0f,-1.0f,-1.0f,   //6
1.0f,-1.0f,-1.0f,    //7
};

unsigned int Cubeindices[] = {
0,1,3,
3,0,2,
3,2,6,
6,7,2,
1,3,5,
5,6,3,
0,1,4,
4,5,1,
2,0,7,
7,4,0,
5,6,4,
4,7,6
};

Buffers* obj1 = new Buffers();
obj1->CreateBuffer(Cubevertices, Cubeindices, 24, 36);  //24 36
bufferList.push_back(obj1);

}

void CreateShaders() {
Shader* shader1 = new Shader();
shader1->createFromFiles(vShader, fShader);
shaderList.push_back(*shader1);
}

GLfloat toRad = 3.14159265359f/180.0f;

GLfloat r_angle = 0.0f;

bool direction = true;
float offset = 0.0f;
float maxoffset = 0.7f;
float inc = 0.0005f;

float cursize = 0.5f;
bool sizedir = true;

int main() {
window = Window(500, 500, "Cube");
window.Initialize();

CreateObjects();
CreateShaders();

GLuint u_model = 0, u_project = 0, u_view = 0;
glm::mat4 projection = glm::perspective(glm::radians(10.0f), (GLfloat)window.getBufferWidth() / window.getBufferHeight(), 1.0f, 100.0f);

while (!window.windowClose()) {
glfwPollEvents();
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);

glEnable(GL_DEPTH_TEST);
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);

shaderList[0].UseShader();
u_model = shaderList[0].getUniformModelLocation();
u_project = shaderList[0].getProjectionModelLocation();

glm::mat4 model(1.0f);

//TRANSLATION
if (direction) {
offset += inc;
}
else {
offset -= inc;
}
if (abs(offset) >= maxoffset) {
direction = !direction;
}

model = glm::scale(model, glm::vec3(0.3f, 0.3f, 0.3f));
model = glm::translate(model, glm::vec3(0.0f, offset, 0.0f));
model = glm::rotate(model, toRad*45.0f, glm::vec3(1.0f, 1.0f, 1.0f));
glUniformMatrix4fv(u_project, 1, GL_FALSE, glm::value_ptr(projection));
glUniformMatrix4fv(u_model, 1, GL_FALSE, glm::value_ptr(model));
bufferList[0]->Render();
window.swapBuffers();

}
return 0;
}