benkyd/SMH-Engine
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Rendering works but somthing's wrong with the indexing

Browse Source
This commit is contained in:
Benjamin Kyd
2019-02-24 18:34:10 +00:00
parent 7a30da9fcc
commit d4876bbba5
10 changed files with 351 additions and 171 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
src/display.cpp
View File

@@ -37,6 +37,10 @@ Display::Display(std::string name, Logger& logger, int w, int h,
mxaaLevel = 8;
smxaaLevel = "8";
break;
case MXAA_16X:
mxaaLevel = 16;
smxaaLevel = "16";
break;
default:
mxaaLevel = 2;
smxaaLevel = "2";
@@ -78,6 +82,7 @@ Display::Display(std::string name, Logger& logger, int w, int h,
// Load OpenGL
gladLoadGLLoader(SDL_GL_GetProcAddress);
glEnable(GL_MULTISAMPLE);
logger << LOGGER_INFO << "Loaded OpenGL" << LOGGER_ENDL;
logger << LOGGER_ENDL;
isClosed = false;
@@ -124,6 +129,10 @@ Display::Display(std::string name, Logger& logger, int w, int h,
mxaaLevel = 8;
smxaaLevel = "8";
break;
case MXAA_16X:
mxaaLevel = 16;
smxaaLevel = "16";
break;
default:
mxaaLevel = 2;
smxaaLevel = "2";
@@ -165,6 +174,7 @@ Display::Display(std::string name, Logger& logger, int w, int h,
// Load OpenGL
gladLoadGLLoader(SDL_GL_GetProcAddress);
glEnable(GL_MULTISAMPLE);
logger << LOGGER_INFO << "Loaded OpenGL" << LOGGER_ENDL;
logger << LOGGER_ENDL;
isClosed = false;
@@ -174,6 +184,14 @@ void Display::setName(std::string name) {
SDL_SetWindowTitle(window, name.c_str());
}
void Display::update() {
SDL_GL_SwapWindow(window);
glClear(GL_DEPTH_BUFFER_BIT);
const float clear[] = { 0.1f, 0.45f, 0.9f, 1.0f };
glClearBufferfv(GL_COLOR, 0, clear);
}
Display::~Display() {
SDL_DestroyWindow(window);
}

14
src/display.h
View File

@@ -23,12 +23,13 @@ typedef enum {
} SMH_VSYNC_DISPLAY_MODE;
typedef enum {
MXAA_DEFAULT,
MXAA_DISABLED,
MXAA_ENABLED,
MXAA_2X,
MXAA_4X,
MXAA_8X
MXAA_DEFAULT,
MXAA_DISABLED,
MXAA_ENABLED,
MXAA_2X,
MXAA_4X,
MXAA_8X,
MXAA_16X
} SMH_MXAA_MODE;
class Display {
@@ -42,6 +43,7 @@ public:
SMH_VSYNC_DISPLAY_MODE vsyncMode = VSYNC_DEFAULT);
void setName(std::string name);
void update();
bool isClosed = true;

16
src/main.cpp
View File

@@ -7,11 +7,12 @@
// #include <glm/gtc/type_ptr.hpp>
// Custom includes
#define OBJL_DEFINITION
#define OBJL_IMPLIMENTATION
#define LOGGER_DEFINITION
#include <logger.h>
#include "display.h"
#include "shader.h"
#include "model.h"
int main (int argc, char** argv) {
@@ -24,7 +25,13 @@ int main (int argc, char** argv) {
Logger logger;
Display display {"SMH Engine", logger, 1280, 720, MXAA_4X, VSYNC_ENABLED};
Display display{"SMH Engine", logger, 1280, 720, MXAA_16X, VSYNC_ENABLED};
Shader shader;
shader.load("./resources/shaders/phong").attatch().link().use();
Mesh mesh{ "./resources/dragon.obj" };
mesh.setup();
SDL_Event e;
while (!display.isClosed) {
@@ -32,8 +39,11 @@ int main (int argc, char** argv) {
if (e.type == SDL_QUIT || e.key.keysym.sym == SDLK_ESCAPE)
display.isClosed = true;
mesh.bind();
mesh.render(shader);
mesh.unbind();
SDL_GL_SwapWindow(display.window);
display.update();
}
return 0;

51
src/mesh.cpp
View File

@@ -14,20 +14,29 @@ Mesh::Mesh(std::string objPath) {
return;
}
OBJLtoGLM(loader.LoadedMeshes[0].Vertices, vertices, normals, texCoords);
logger << LOGGER_INFO << "Loaded: " << objPath << LOGGER_ENDL;
loadFromObj(loader.LoadedMeshes[0]);
}
Mesh::Mesh(objl::Mesh objMesh) {
OBJLtoGLM(objMesh.Vertices, vertices, normals, texCoords);
UintToGLuint(objMesh.Indices, indices);
loadFromObj(objMesh);
}
void Mesh::loadFromObj(objl::Mesh objMesh) {
OBJLtoGLM(objMesh.Vertices, vertices, normals, texCoords);
UintToGLuint(objMesh.Indices, indices);
name = objMesh.MeshName;
Logger logger;
for (int i = 0; i < 100; i++) {
logger << LOGGER_DEBUG << normals[i].x << " " << normals[i].y << " " << normals[i].z << LOGGER_ENDL;
}
}
void Mesh::setup() {
Logger logger;
glGenVertexArrays(1, &VAOid);
glGenBuffers(1, &vertexBuffer);
glGenBuffers(1, &indexBuffer);
@@ -42,7 +51,7 @@ void Mesh::setup() {
toGpu.insert(toGpu.end(), texCoords.begin(), texCoords.end());
glBufferData(GL_ARRAY_BUFFER, toGpu.size() * sizeof(glm::vec3),
&vertices[0], GL_STATIC_DRAW);
&toGpu[0], GL_STATIC_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBuffer);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices.size() * sizeof(GLuint),
@@ -63,6 +72,8 @@ void Mesh::setup() {
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 0,
(const void*)((vertices.size() + texCoords.size()) * sizeof(glm::vec3)));
logger << LOGGER_INFO << "Mesh " << name << " setup" << LOGGER_ENDL;
glBindVertexArray(0);
}
@@ -71,6 +82,38 @@ void Mesh::bind() {
}
void Mesh::render(Shader& shader) {
// Model matrice
glm::mat4 model = glm::mat4(1.0f);
model = glm::translate(model, { -17.0f, -17.0f, -17.0f });
model = glm::rotate(model, glm::radians(-160.0f), glm::vec3(0.0f, 1.0f, 0.0f));
// Gets uniform for model matrice, to be used later
GLint uniTrans = glGetUniformLocation(shader.getProgram(), "model");
glUniformMatrix4fv(uniTrans, 1, GL_FALSE, glm::value_ptr(model));
// View matrice
glm::mat4 view = glm::lookAt(
glm::vec3(1.0f, 1.0f, 1.0f),
glm::vec3(0.0f, 0.4f, 0.0f),
glm::vec3(0.0f, 1.0f, 0.0f)
);
// Get uniform and send it to the GPU
GLint uniView = glGetUniformLocation(shader.getProgram(), "view");
glUniformMatrix4fv(uniView, 1, GL_FALSE, glm::value_ptr(view));
// Projection matrice
glm::mat4 proj = glm::perspective(glm::radians(45.0f), 1280.0f / 720.0f, 1.0f, 1000.0f);//camera.perspective;
// Get uniform and send it to the GPU
GLint uniProj = glGetUniformLocation(shader.getProgram(), "proj");
glUniformMatrix4fv(uniProj, 1, GL_FALSE, glm::value_ptr(proj));
glm::vec3 lightPos = { -2.0f, 4.0f, -1.0f };
GLint uniLight = glGetUniformLocation(shader.getProgram(), "lightpos");
glUniformMatrix3fv(uniLight, 1, GL_FALSE, glm::value_ptr(lightPos));
glDrawElements(GL_TRIANGLES, indices.size(), GL_UNSIGNED_INT, 0);
}

4
src/mesh.h
View File

@@ -13,10 +13,9 @@
#include <OBJLoader.h>
#include <logger.h>
#include "shader.h"
#include "./util/util.h"
class Shader;
class Mesh {
public:
Mesh();
@@ -32,6 +31,7 @@ public:
GLuint VAOid;
std::string name;
std::vector<glm::vec3> vertices;
std::vector<glm::vec3> normals;
// This is a vec3 so it can all pop into

165
src/shader.cpp
View File

@@ -1,3 +1,168 @@
#include "shader.h"
#include <iostream>
#include <fstream>
Shader::Shader()
: logger(*new Logger) {
m_program = glCreateProgram();
}
Shader& Shader::use() {
glUseProgram(m_program);
return *this;
}
Shader& Shader::link() {
glLinkProgram(m_program);
return *this;
}
Shader& Shader::attatch() {
glAttachShader(m_program, m_vert);
glAttachShader(m_program, m_frag);
return *this;
}
std::string readShader(std::string source) {
std::ifstream t(source);
std::string shaderCode((std::istreambuf_iterator<char>(t)),
std::istreambuf_iterator<char>());
return shaderCode;
}
Shader& Shader::load(GLenum type, std::string sourceLoc) {
const char* source = readShader(sourceLoc).c_str();
if (type == GL_VERTEX_SHADER) {
m_vertLoc = sourceLoc;
m_vertSource = (std::string)source;
m_vert = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(m_vert, 1, &source, NULL);
glCompileShader(m_vert);
glGetShaderiv(m_vert, GL_COMPILE_STATUS, &m_status);
if (m_status == GL_FALSE) {
char buf[512];
glGetShaderInfoLog(m_vert, 512, NULL, buf);
logger << LOGGER_ERROR << buf << LOGGER_ENDL;
}
logger << LOGGER_INFO << "Vertex shader at '" << sourceLoc << "' compiled..." << LOGGER_ENDL;
}
else if (type == GL_FRAGMENT_SHADER) {
m_fragLoc = sourceLoc;
m_fragSource = (std::string)source;
m_frag = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(m_frag, 1, &source, NULL);
glCompileShader(m_frag);
glGetShaderiv(m_frag, GL_COMPILE_STATUS, &m_status);
if (m_status == GL_FALSE) {
char buf[512];
glGetShaderInfoLog(m_frag, 512, NULL, buf);
logger << LOGGER_ERROR << buf << LOGGER_ENDL;
}
logger << LOGGER_INFO << "Vertex shader at '" << sourceLoc << "' compiled..." << LOGGER_ENDL;
}
return *this;
}
Shader& Shader::load(std::string sourceLoc) {
m_vertLoc = sourceLoc + ".vert";
m_fragLoc = sourceLoc + ".frag";
m_vertSource = readShader(m_vertLoc);
m_fragSource = readShader(m_fragLoc);
m_vert = glCreateShader(GL_VERTEX_SHADER);
m_frag = glCreateShader(GL_FRAGMENT_SHADER);
const char* vertSource = m_vertSource.c_str();
glShaderSource(m_vert, 1, &vertSource, NULL);
glCompileShader(m_vert);
const char* fragSource = m_fragSource.c_str();
glShaderSource(m_frag, 1, &fragSource, NULL);
glCompileShader(m_frag);
glGetShaderiv(m_vert, GL_COMPILE_STATUS, &m_status);
if (m_status == GL_FALSE) {
char buf[512];
glGetShaderInfoLog(m_vert, 512, NULL, buf);
logger << LOGGER_ERROR << buf << LOGGER_ENDL;
}
glGetShaderiv(m_frag, GL_COMPILE_STATUS, &m_status);
if (m_status == GL_FALSE) {
char buf[512];
glGetShaderInfoLog(m_frag, 512, NULL, buf);
logger << LOGGER_ERROR << buf << LOGGER_ENDL;
}
logger << LOGGER_INFO << "Vertex shader at '" << m_vertLoc << "' compiled..." << LOGGER_ENDL;
logger << LOGGER_INFO << "Fragment shader at '" << m_fragLoc << "' compiled..." << LOGGER_ENDL;
return *this;
}
Shader& Shader::reload() {
glDeleteProgram(m_program);
glDeleteShader(m_vert);
glDeleteShader(m_frag);
m_vertSource = readShader(m_vertLoc);
m_fragSource = readShader(m_fragLoc);
m_vert = glCreateShader(GL_VERTEX_SHADER);
m_frag = glCreateShader(GL_FRAGMENT_SHADER);
const char* vertSource = m_vertSource.c_str();
glShaderSource(m_vert, 1, &vertSource, NULL);
glCompileShader(m_vert);
const char* fragSource = m_fragSource.c_str();
glShaderSource(m_frag, 1, &fragSource, NULL);
glCompileShader(m_frag);
glGetShaderiv(m_vert, GL_COMPILE_STATUS, &m_status);
if (m_status == GL_FALSE) {
char buf[512];
glGetShaderInfoLog(m_vert, 512, NULL, buf);
logger << LOGGER_ERROR << buf << LOGGER_ENDL;
}
glGetShaderiv(m_frag, GL_COMPILE_STATUS, &m_status);
if (m_status == GL_FALSE) {
char buf[512];
glGetShaderInfoLog(m_frag, 512, NULL, buf);
logger << LOGGER_ERROR << buf << LOGGER_ENDL;
}
logger << LOGGER_INFO << "Vertex shader at '" << m_vertLoc << "' compiled..." << LOGGER_ENDL;
logger << LOGGER_INFO << "Fragment shader at '" << m_fragLoc << "' compiled..." << LOGGER_ENDL;
link();
attatch();
return *this;
}
GLuint Shader::getProgram() {
return m_program;
}
GLuint Shader::getVertex() {
return m_vert;
}
GLuint Shader::getFragment() {
return m_frag;
}
Shader::~Shader() {
glDeleteProgram(m_program);
glDeleteShader(m_vert);
glDeleteShader(m_frag);
}

33
src/shader.h
View File

@@ -1,9 +1,42 @@
#ifndef SMHENGINE_SRC_SHADER_H_
#define SMHENGINE_SRC_SHADER_H_
#include <glad/glad.hpp>
#include <string>
#include <logger.h>
class Shader {
public:
Shader();
Shader& use();
Shader& link();
Shader& attatch();
Shader& load(GLenum type, std::string sourceLoc);
Shader& load(std::string sourceLoc);
Shader& reload();
GLuint getProgram();
GLuint getVertex();
GLuint getFragment();
virtual ~Shader();
private:
Shader(Shader const &) = delete;
Shader & operator=(Shader const &) = delete;
GLuint m_program;
GLuint m_vert;
GLuint m_frag;
std::string m_vertSource;
std::string m_fragSource;
std::string m_vertLoc;
std::string m_fragLoc;
Logger& logger;
GLint m_status;
};
#endif

8
src/util/util.cpp
View File

@@ -1,13 +1,15 @@
#include "util.h"
#include <logger.h>
void OBJLtoGLM(std::vector<objl::Vertex>& inVertArr,
std::vector<glm::vec3>& outVert,
std::vector<glm::vec3>& outNorm,
std::vector<glm::vec3>& outTexCoord) {
for (int i = 0; i < inVertArr.size(); i++) {
glm::vec3 tempVert {inVertArr[i].Position.X, inVertArr[i].Position.Y, inVertArr[i].Position.Z};
for (int i = 0; i < inVertArr.size() - 1; i++) {
glm::vec3 tempVert {inVertArr[i].Position.X, inVertArr[i].Position.Y, inVertArr[i].Position.Z};
outVert.push_back(tempVert);
glm::vec3 tempNorm {inVertArr[i].Normal.X, inVertArr[i].Normal.Y, inVertArr[i].Normal.Z};