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

SMH

Browse Source
This commit is contained in:
Ben
2019-02-22 21:55:53 +00:00
parent 8efb410bcd
commit a170621eea
41 changed files with 462671 additions and 462656 deletions
Download Patch File Download Diff File Expand all files Collapse all files

358
src/display.cpp
View File

@@ -1,179 +1,179 @@
#include "display.h"
Display::Display(std::string name, Logger& logger, int w, int h,
SMH_VSYNC_DISPLAY_MODE vsyncMode,
SMH_MXAA_MODE mxaaMode)
: logger(logger) {
MXAAMode = mxaaMode;
VSyncMode = vsyncMode;
logger << LOGGER_INFO << "Initializing display" << LOGGER_ENDL;
SDL_Init(SDL_INIT_EVERYTHING);
SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_BUFFER_SIZE, 32);
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
// MXAA
if (mxaaMode != MXAA_DEFAULT || mxaaMode != MXAA_DISABLED) {
int mxaaLevel = 1;
std::string smxaaLevel = "1";
switch (mxaaMode) {
case MXAA_ENABLED:
case MXAA_2X:
mxaaLevel = 2;
smxaaLevel = "2";
break;
case MXAA_4X:
mxaaLevel = 4;
smxaaLevel = "4";
break;
case MXAA_8X:
mxaaLevel = 8;
smxaaLevel = "8";
break;
default:
mxaaLevel = 2;
smxaaLevel = "2";
break;
}
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1);
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, mxaaLevel);
SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, smxaaLevel.c_str());
logger << LOGGER_INFO << "MXAA set to " << mxaaLevel << "xMSAA" << LOGGER_ENDL;
} else {
logger << LOGGER_INFO << "MXAA disabled" << LOGGER_ENDL;
}
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 4);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 5);
// Create GL window
logger << LOGGER_INFO << "Creating window" << LOGGER_ENDL;
window = SDL_CreateWindow(name.c_str(),
SDL_WINDOWPOS_CENTERED,
SDL_WINDOWPOS_CENTERED, w, h,
SDL_WINDOW_OPENGL);
// Create GL context
logger << LOGGER_INFO << "Creating OpenGL context" << LOGGER_ENDL;
glContext = SDL_GL_CreateContext(window);
// Set VSYNC swap interval
if (vsyncMode == VSYNC_DEFAULT || vsyncMode == VSYNC_ENABLED) {
SDL_GL_SetSwapInterval(1);
logger << LOGGER_INFO << "VSync enabled" << LOGGER_ENDL;
}
if (vsyncMode == VSYNC_DISABLED) {
SDL_GL_SetSwapInterval(0);
logger << LOGGER_INFO << "VSync disabled" << LOGGER_ENDL;
}
logger << LOGGER_INFO << "Display set up" << LOGGER_ENDL;
// Load OpenGL
gladLoadGLLoader(SDL_GL_GetProcAddress);
logger << LOGGER_INFO << "Loaded OpenGL" << LOGGER_ENDL;
logger << LOGGER_ENDL;
isClosed = false;
}
Display::Display(std::string name, Logger& logger, int w, int h,
SMH_MXAA_MODE mxaaMode,
SMH_VSYNC_DISPLAY_MODE vsyncMode)
: logger(logger) {
MXAAMode = mxaaMode;
VSyncMode = vsyncMode;
logger << LOGGER_INFO << "Initializing display" << LOGGER_ENDL;
SDL_Init(SDL_INIT_EVERYTHING);
SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_BUFFER_SIZE, 32);
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
// MXAA
if (mxaaMode != MXAA_DEFAULT || mxaaMode != MXAA_DISABLED) {
int mxaaLevel = 1;
std::string smxaaLevel = "1";
switch (mxaaMode) {
case MXAA_ENABLED:
case MXAA_2X:
mxaaLevel = 2;
smxaaLevel = "2";
break;
case MXAA_4X:
mxaaLevel = 4;
smxaaLevel = "4";
break;
case MXAA_8X:
mxaaLevel = 8;
smxaaLevel = "8";
break;
default:
mxaaLevel = 2;
smxaaLevel = "2";
break;
}
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1);
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, mxaaLevel);
SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, smxaaLevel.c_str());
logger << LOGGER_INFO << "MXAA set to " << mxaaLevel << "xMSAA" << LOGGER_ENDL;
} else {
logger << LOGGER_INFO << "MXAA disabled" << LOGGER_ENDL;
}
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 4);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 5);
// Create GL window
logger << LOGGER_INFO << "Creating window" << LOGGER_ENDL;
window = SDL_CreateWindow(name.c_str(),
SDL_WINDOWPOS_CENTERED,
SDL_WINDOWPOS_CENTERED, w, h,
SDL_WINDOW_OPENGL);
// Create GL context
logger << LOGGER_INFO << "Creating OpenGL context" << LOGGER_ENDL;
glContext = SDL_GL_CreateContext(window);
// Set VSYNC swap interval
if (vsyncMode == VSYNC_DEFAULT || vsyncMode == VSYNC_ENABLED) {
SDL_GL_SetSwapInterval(1);
logger << LOGGER_INFO << "VSync enabled" << LOGGER_ENDL;
}
if (vsyncMode == VSYNC_DISABLED) {
SDL_GL_SetSwapInterval(0);
logger << LOGGER_INFO << "VSync disabled" << LOGGER_ENDL;
}
logger << LOGGER_INFO << "Display set up" << LOGGER_ENDL;
// Load OpenGL
gladLoadGLLoader(SDL_GL_GetProcAddress);
logger << LOGGER_INFO << "Loaded OpenGL" << LOGGER_ENDL;
logger << LOGGER_ENDL;
isClosed = false;
}
void Display::setName(std::string name) {
SDL_SetWindowTitle(window, name.c_str());
}
Display::~Display() {
SDL_DestroyWindow(window);
}
#include "display.h"
Display::Display(std::string name, Logger& logger, int w, int h,
SMH_VSYNC_DISPLAY_MODE vsyncMode,
SMH_MXAA_MODE mxaaMode)
: logger(logger) {
MXAAMode = mxaaMode;
VSyncMode = vsyncMode;
logger << LOGGER_INFO << "Initializing display" << LOGGER_ENDL;
SDL_Init(SDL_INIT_EVERYTHING);
SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_BUFFER_SIZE, 32);
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
// MXAA
if (mxaaMode != MXAA_DEFAULT || mxaaMode != MXAA_DISABLED) {
int mxaaLevel = 1;
std::string smxaaLevel = "1";
switch (mxaaMode) {
case MXAA_ENABLED:
case MXAA_2X:
mxaaLevel = 2;
smxaaLevel = "2";
break;
case MXAA_4X:
mxaaLevel = 4;
smxaaLevel = "4";
break;
case MXAA_8X:
mxaaLevel = 8;
smxaaLevel = "8";
break;
default:
mxaaLevel = 2;
smxaaLevel = "2";
break;
}
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1);
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, mxaaLevel);
SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, smxaaLevel.c_str());
logger << LOGGER_INFO << "MXAA set to " << mxaaLevel << "xMSAA" << LOGGER_ENDL;
} else {
logger << LOGGER_INFO << "MXAA disabled" << LOGGER_ENDL;
}
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 4);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 5);
// Create GL window
logger << LOGGER_INFO << "Creating window" << LOGGER_ENDL;
window = SDL_CreateWindow(name.c_str(),
SDL_WINDOWPOS_CENTERED,
SDL_WINDOWPOS_CENTERED, w, h,
SDL_WINDOW_OPENGL);
// Create GL context
logger << LOGGER_INFO << "Creating OpenGL context" << LOGGER_ENDL;
glContext = SDL_GL_CreateContext(window);
// Set VSYNC swap interval
if (vsyncMode == VSYNC_DEFAULT || vsyncMode == VSYNC_ENABLED) {
SDL_GL_SetSwapInterval(1);
logger << LOGGER_INFO << "VSync enabled" << LOGGER_ENDL;
}
if (vsyncMode == VSYNC_DISABLED) {
SDL_GL_SetSwapInterval(0);
logger << LOGGER_INFO << "VSync disabled" << LOGGER_ENDL;
}
logger << LOGGER_INFO << "Display set up" << LOGGER_ENDL;
// Load OpenGL
gladLoadGLLoader(SDL_GL_GetProcAddress);
logger << LOGGER_INFO << "Loaded OpenGL" << LOGGER_ENDL;
logger << LOGGER_ENDL;
isClosed = false;
}
Display::Display(std::string name, Logger& logger, int w, int h,
SMH_MXAA_MODE mxaaMode,
SMH_VSYNC_DISPLAY_MODE vsyncMode)
: logger(logger) {
MXAAMode = mxaaMode;
VSyncMode = vsyncMode;
logger << LOGGER_INFO << "Initializing display" << LOGGER_ENDL;
SDL_Init(SDL_INIT_EVERYTHING);
SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_BUFFER_SIZE, 32);
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
// MXAA
if (mxaaMode != MXAA_DEFAULT || mxaaMode != MXAA_DISABLED) {
int mxaaLevel = 1;
std::string smxaaLevel = "1";
switch (mxaaMode) {
case MXAA_ENABLED:
case MXAA_2X:
mxaaLevel = 2;
smxaaLevel = "2";
break;
case MXAA_4X:
mxaaLevel = 4;
smxaaLevel = "4";
break;
case MXAA_8X:
mxaaLevel = 8;
smxaaLevel = "8";
break;
default:
mxaaLevel = 2;
smxaaLevel = "2";
break;
}
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1);
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, mxaaLevel);
SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, smxaaLevel.c_str());
logger << LOGGER_INFO << "MXAA set to " << mxaaLevel << "xMSAA" << LOGGER_ENDL;
} else {
logger << LOGGER_INFO << "MXAA disabled" << LOGGER_ENDL;
}
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 4);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 5);
// Create GL window
logger << LOGGER_INFO << "Creating window" << LOGGER_ENDL;
window = SDL_CreateWindow(name.c_str(),
SDL_WINDOWPOS_CENTERED,
SDL_WINDOWPOS_CENTERED, w, h,
SDL_WINDOW_OPENGL);
// Create GL context
logger << LOGGER_INFO << "Creating OpenGL context" << LOGGER_ENDL;
glContext = SDL_GL_CreateContext(window);
// Set VSYNC swap interval
if (vsyncMode == VSYNC_DEFAULT || vsyncMode == VSYNC_ENABLED) {
SDL_GL_SetSwapInterval(1);
logger << LOGGER_INFO << "VSync enabled" << LOGGER_ENDL;
}
if (vsyncMode == VSYNC_DISABLED) {
SDL_GL_SetSwapInterval(0);
logger << LOGGER_INFO << "VSync disabled" << LOGGER_ENDL;
}
logger << LOGGER_INFO << "Display set up" << LOGGER_ENDL;
// Load OpenGL
gladLoadGLLoader(SDL_GL_GetProcAddress);
logger << LOGGER_INFO << "Loaded OpenGL" << LOGGER_ENDL;
logger << LOGGER_ENDL;
isClosed = false;
}
void Display::setName(std::string name) {
SDL_SetWindowTitle(window, name.c_str());
}
Display::~Display() {
SDL_DestroyWindow(window);
}

118
src/display.h
View File

@@ -1,59 +1,59 @@
#ifndef SMHENGINE_SRC_DISPLAY_H_
#define SMHENGINE_SRC_DISPLAY_H_
#include <string>
#include <glad/glad.hpp>
// SDL includes different on windows
// the way i have it set up so i gotta
// do it like this unfortunately
#if _WIN32
#include <SDL.h>
#else
#include <SDL2/SDL.h>
#endif
#include <logger.h>
typedef enum {
VSYNC_DEFAULT,
VSYNC_DISABLED,
VSYNC_ENABLED,
} SMH_VSYNC_DISPLAY_MODE;
typedef enum {
MXAA_DEFAULT,
MXAA_DISABLED,
MXAA_ENABLED,
MXAA_2X,
MXAA_4X,
MXAA_8X
} SMH_MXAA_MODE;
class Display {
public:
Display(std::string name, Logger& logger, int w, int h,
SMH_VSYNC_DISPLAY_MODE vsyncMode = VSYNC_DEFAULT,
SMH_MXAA_MODE mxaaMode = MXAA_DEFAULT);
Display(std::string name, Logger& logger, int w, int h,
SMH_MXAA_MODE mxaaMode = MXAA_DEFAULT,
SMH_VSYNC_DISPLAY_MODE vsyncMode = VSYNC_DEFAULT);
void setName(std::string name);
bool isClosed = true;
SDL_Window* window;
SDL_GLContext glContext;
SMH_VSYNC_DISPLAY_MODE VSyncMode = VSYNC_DEFAULT;
SMH_MXAA_MODE MXAAMode = MXAA_DEFAULT;
virtual ~Display();
private:
Logger& logger;
};
#endif
#ifndef SMHENGINE_SRC_DISPLAY_H_
#define SMHENGINE_SRC_DISPLAY_H_
#include <string>
#include <glad/glad.hpp>
// SDL includes different on windows
// the way i have it set up so i gotta
// do it like this unfortunately
#if _WIN32
#include <SDL.h>
#else
#include <SDL2/SDL.h>
#endif
#include <logger.h>
typedef enum {
VSYNC_DEFAULT,
VSYNC_DISABLED,
VSYNC_ENABLED,
} SMH_VSYNC_DISPLAY_MODE;
typedef enum {
MXAA_DEFAULT,
MXAA_DISABLED,
MXAA_ENABLED,
MXAA_2X,
MXAA_4X,
MXAA_8X
} SMH_MXAA_MODE;
class Display {
public:
Display(std::string name, Logger& logger, int w, int h,
SMH_VSYNC_DISPLAY_MODE vsyncMode = VSYNC_DEFAULT,
SMH_MXAA_MODE mxaaMode = MXAA_DEFAULT);
Display(std::string name, Logger& logger, int w, int h,
SMH_MXAA_MODE mxaaMode = MXAA_DEFAULT,
SMH_VSYNC_DISPLAY_MODE vsyncMode = VSYNC_DEFAULT);
void setName(std::string name);
bool isClosed = true;
SDL_Window* window;
SDL_GLContext glContext;
SMH_VSYNC_DISPLAY_MODE VSyncMode = VSYNC_DEFAULT;
SMH_MXAA_MODE MXAAMode = MXAA_DEFAULT;
virtual ~Display();
private:
Logger& logger;
};
#endif

3682
src/glad.cpp
View File

File diff suppressed because it is too large Load Diff

76
src/main.cpp
View File

@@ -1,38 +1,38 @@
// General includes
#include <chrono>
#include <vector>
// #include <glm/glm.hpp>
// #include <glm/gtc/matrix_transform.hpp>
// #include <glm/gtc/type_ptr.hpp>
// Custom includes
#define LOGGER_DEFINITION
#include <logger.h>
#include "display.h"
int main (int argc, char** argv) {
std::cout << "-----------------------------\n"
<< "----- SMH Render Engine -----\n"
<< "-------- Version 0.0 --------\n"
<< "----- ©Benjamin Kyd 2019 ----\n"
<< "-----------------------------\n\n";
Logger logger;
Display display {"SMH Engine", logger, 1280, 720, MXAA_4X, VSYNC_ENABLED};
SDL_Event e;
while (!display.isClosed) {
while (SDL_PollEvent(&e))
if (e.type == SDL_QUIT || e.key.keysym.sym == SDLK_ESCAPE)
display.isClosed = true;
SDL_GL_SwapWindow(display.window);
}
return 0;
}
// General includes
#include <chrono>
#include <vector>
// #include <glm/glm.hpp>
// #include <glm/gtc/matrix_transform.hpp>
// #include <glm/gtc/type_ptr.hpp>
// Custom includes
#define LOGGER_DEFINITION
#include <logger.h>
#include "display.h"
int main (int argc, char** argv) {
std::cout << "-----------------------------\n"
<< "----- SMH Render Engine -----\n"
<< "-------- Version 0.0 --------\n"
<< "----- ©Benjamin Kyd 2019 ----\n"
<< "-----------------------------\n\n";
Logger logger;
Display display {"SMH Engine", logger, 1280, 720, MXAA_4X, VSYNC_ENABLED};
SDL_Event e;
while (!display.isClosed) {
while (SDL_PollEvent(&e))
if (e.type == SDL_QUIT || e.key.keysym.sym == SDLK_ESCAPE)
display.isClosed = true;
SDL_GL_SwapWindow(display.window);
}
return 0;
}

6
src/material.cpp
View File

@@ -1,3 +1,3 @@
#include "material.h"
#include "material.h"

18
src/material.h
View File

@@ -1,9 +1,9 @@
#ifndef SMHENGINE_SRC_MATERIAL_H_
#define SMHENGINE_SRC_MATERIAL_H_
class Material {
};
#endif
#ifndef SMHENGINE_SRC_MATERIAL_H_
#define SMHENGINE_SRC_MATERIAL_H_
class Material {
};
#endif

68
src/mesh.cpp
View File

@@ -1,33 +1,35 @@
#include "mesh.h"
Mesh::Mesh() {
}
Mesh::Mesh(std::string objPath) {
}
Mesh::Mesh(objl::Mesh objMesh) {
}
void Mesh::loadFromObj(objl::Mesh objmesh) {
}
void Mesh::settup() {
}
void Mesh::bind() {
}
void Mesh::render(Shader& shader) {
}
void Mesh::unbind() {
}
#include "mesh.h"
Mesh::Mesh() {
}
Mesh::Mesh(std::string objPath) {
}
Mesh::Mesh(objl::Mesh objMesh) {
OBJLtoGLM(objMesh.Vertices, vertices);
// objMesh.Vertices includes normals, positions and texcoords
// it must convert them to the neccesary GLM shit
}
void Mesh::loadFromObj(objl::Mesh objmesh) {
}
void Mesh::settup() {
}
void Mesh::bind() {
}
void Mesh::render(Shader& shader) {
}
void Mesh::unbind() {
}

85
src/mesh.h
View File

@@ -1,42 +1,43 @@
#ifndef SMHENGINE_SRC_MESH_H_
#define SMHENGINE_SRC_MESH_H_
#include <string>
#include <vector>
#include <OBJLoader.h>
#include <glad/glad.hpp>
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>
class Shader;
class Mesh {
public:
Mesh();
Mesh(std::string objPath);
Mesh(objl::Mesh objMesh);
void loadFromObj(objl::Mesh objMesh);
void settup();
void bind();
void render(Shader& shader);
void unbind();
GLuint VAOid;
std::vector<glm::vec3> vertices;
std::vector<glm::vec4> colours;
std::vector<glm::vec2> texCoords;
std::vector<glm::vec3> normals;
std::vector<GLuint> indices;
private:
GLuint vertexBuffer;
GLuint indexBuffer;
};
#endif
#ifndef SMHENGINE_SRC_MESH_H_
#define SMHENGINE_SRC_MESH_H_
#include <string>
#include <vector>
#include <OBJLoader.h>
#include <glad/glad.hpp>
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>
#include "./util/util.h"
class Shader;
class Mesh {
public:
Mesh();
Mesh(std::string objPath);
Mesh(objl::Mesh objMesh);
void loadFromObj(objl::Mesh objMesh);
void settup();
void bind();
void render(Shader& shader);
void unbind();
GLuint VAOid;
std::vector<glm::vec3> vertices;
std::vector<glm::vec2> texCoords;
std::vector<glm::vec3> normals;
std::vector<GLuint> indices;
private:
GLuint vertexBuffer;
GLuint indexBuffer;
};
#endif

6
src/shader.cpp
View File

@@ -1,3 +1,3 @@
#include "shader.h"
#include "shader.h"

18
src/shader.h
View File

@@ -1,9 +1,9 @@
#ifndef SMHENGINE_SRC_SHADER_H_
#define SMHENGINE_SRC_SHADER_H_
class Shader {
};
#endif
#ifndef SMHENGINE_SRC_SHADER_H_
#define SMHENGINE_SRC_SHADER_H_
class Shader {
};
#endif

3
src/util/util.cpp Normal file
View File

@@ -0,0 +1,3 @@
#include "util.h"

9
src/util/util.h Normal file
View File

@@ -0,0 +1,9 @@
#ifndef SMHENGINE_SRC_UTIL_UTIL_H_
#define SMHENGINE_SRC_UTIL_UTUL_H_
template <typename T, typename P>
void OBJLtoGLM(T& inVec, P& outVec) {
}
#endif