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

ITS REWRITE TIME

Browse Source
This commit is contained in:
Ben
2019-10-04 17:30:57 +01:00
parent b32024ec68
commit b315cc8951
44 changed files with 313404 additions and 306738 deletions
Download Patch File Download Diff File Expand all files Collapse all files

282
legacy/include/KHR/khrplatform.h Normal file
View File

@@ -0,0 +1,282 @@
#ifndef __khrplatform_h_
#define __khrplatform_h_
/*
** Copyright (c) 2008-2018 The Khronos Group Inc.
**
** Permission is hereby granted, free of charge, to any person obtaining a
** copy of this software and/or associated documentation files (the
** "Materials"), to deal in the Materials without restriction, including
** without limitation the rights to use, copy, modify, merge, publish,
** distribute, sublicense, and/or sell copies of the Materials, and to
** permit persons to whom the Materials are furnished to do so, subject to
** the following conditions:
**
** The above copyright notice and this permission notice shall be included
** in all copies or substantial portions of the Materials.
**
** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
*/
/* Khronos platform-specific types and definitions.
*
* The master copy of khrplatform.h is maintained in the Khronos EGL
* Registry repository at https://github.com/KhronosGroup/EGL-Registry
* The last semantic modification to khrplatform.h was at commit ID:
* 67a3e0864c2d75ea5287b9f3d2eb74a745936692
*
* Adopters may modify this file to suit their platform. Adopters are
* encouraged to submit platform specific modifications to the Khronos
* group so that they can be included in future versions of this file.
* Please submit changes by filing pull requests or issues on
* the EGL Registry repository linked above.
*
*
* See the Implementer's Guidelines for information about where this file
* should be located on your system and for more details of its use:
* http://www.khronos.org/registry/implementers_guide.pdf
*
* This file should be included as
* #include <KHR/khrplatform.h>
* by Khronos client API header files that use its types and defines.
*
* The types in khrplatform.h should only be used to define API-specific types.
*
* Types defined in khrplatform.h:
* khronos_int8_t signed 8 bit
* khronos_uint8_t unsigned 8 bit
* khronos_int16_t signed 16 bit
* khronos_uint16_t unsigned 16 bit
* khronos_int32_t signed 32 bit
* khronos_uint32_t unsigned 32 bit
* khronos_int64_t signed 64 bit
* khronos_uint64_t unsigned 64 bit
* khronos_intptr_t signed same number of bits as a pointer
* khronos_uintptr_t unsigned same number of bits as a pointer
* khronos_ssize_t signed size
* khronos_usize_t unsigned size
* khronos_float_t signed 32 bit floating point
* khronos_time_ns_t unsigned 64 bit time in nanoseconds
* khronos_utime_nanoseconds_t unsigned time interval or absolute time in
* nanoseconds
* khronos_stime_nanoseconds_t signed time interval in nanoseconds
* khronos_boolean_enum_t enumerated boolean type. This should
* only be used as a base type when a client API's boolean type is
* an enum. Client APIs which use an integer or other type for
* booleans cannot use this as the base type for their boolean.
*
* Tokens defined in khrplatform.h:
*
* KHRONOS_FALSE, KHRONOS_TRUE Enumerated boolean false/true values.
*
* KHRONOS_SUPPORT_INT64 is 1 if 64 bit integers are supported; otherwise 0.
* KHRONOS_SUPPORT_FLOAT is 1 if floats are supported; otherwise 0.
*
* Calling convention macros defined in this file:
* KHRONOS_APICALL
* KHRONOS_APIENTRY
* KHRONOS_APIATTRIBUTES
*
* These may be used in function prototypes as:
*
* KHRONOS_APICALL void KHRONOS_APIENTRY funcname(
* int arg1,
* int arg2) KHRONOS_APIATTRIBUTES;
*/
/*-------------------------------------------------------------------------
* Definition of KHRONOS_APICALL
*-------------------------------------------------------------------------
* This precedes the return type of the function in the function prototype.
*/
#if defined(_WIN32) && !defined(__SCITECH_SNAP__)
# define KHRONOS_APICALL __declspec(dllimport)
#elif defined (__SYMBIAN32__)
# define KHRONOS_APICALL IMPORT_C
#elif defined(__ANDROID__)
# define KHRONOS_APICALL __attribute__((visibility("default")))
#else
# define KHRONOS_APICALL
#endif
/*-------------------------------------------------------------------------
* Definition of KHRONOS_APIENTRY
*-------------------------------------------------------------------------
* This follows the return type of the function and precedes the function
* name in the function prototype.
*/
#if defined(_WIN32) && !defined(_WIN32_WCE) && !defined(__SCITECH_SNAP__)
/* Win32 but not WinCE */
# define KHRONOS_APIENTRY __stdcall
#else
# define KHRONOS_APIENTRY
#endif
/*-------------------------------------------------------------------------
* Definition of KHRONOS_APIATTRIBUTES
*-------------------------------------------------------------------------
* This follows the closing parenthesis of the function prototype arguments.
*/
#if defined (__ARMCC_2__)
#define KHRONOS_APIATTRIBUTES __softfp
#else
#define KHRONOS_APIATTRIBUTES
#endif
/*-------------------------------------------------------------------------
* basic type definitions
*-----------------------------------------------------------------------*/
#if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || defined(__GNUC__) || defined(__SCO__) || defined(__USLC__)
/*
* Using <stdint.h>
*/
#include <stdint.h>
typedef int32_t khronos_int32_t;
typedef uint32_t khronos_uint32_t;
typedef int64_t khronos_int64_t;
typedef uint64_t khronos_uint64_t;
#define KHRONOS_SUPPORT_INT64 1
#define KHRONOS_SUPPORT_FLOAT 1
#elif defined(__VMS ) || defined(__sgi)
/*
* Using <inttypes.h>
*/
#include <inttypes.h>
typedef int32_t khronos_int32_t;
typedef uint32_t khronos_uint32_t;
typedef int64_t khronos_int64_t;
typedef uint64_t khronos_uint64_t;
#define KHRONOS_SUPPORT_INT64 1
#define KHRONOS_SUPPORT_FLOAT 1
#elif defined(_WIN32) && !defined(__SCITECH_SNAP__)
/*
* Win32
*/
typedef __int32 khronos_int32_t;
typedef unsigned __int32 khronos_uint32_t;
typedef __int64 khronos_int64_t;
typedef unsigned __int64 khronos_uint64_t;
#define KHRONOS_SUPPORT_INT64 1
#define KHRONOS_SUPPORT_FLOAT 1
#elif defined(__sun__) || defined(__digital__)
/*
* Sun or Digital
*/
typedef int khronos_int32_t;
typedef unsigned int khronos_uint32_t;
#if defined(__arch64__) || defined(_LP64)
typedef long int khronos_int64_t;
typedef unsigned long int khronos_uint64_t;
#else
typedef long long int khronos_int64_t;
typedef unsigned long long int khronos_uint64_t;
#endif /* __arch64__ */
#define KHRONOS_SUPPORT_INT64 1
#define KHRONOS_SUPPORT_FLOAT 1
#elif 0
/*
* Hypothetical platform with no float or int64 support
*/
typedef int khronos_int32_t;
typedef unsigned int khronos_uint32_t;
#define KHRONOS_SUPPORT_INT64 0
#define KHRONOS_SUPPORT_FLOAT 0
#else
/*
* Generic fallback
*/
#include <stdint.h>
typedef int32_t khronos_int32_t;
typedef uint32_t khronos_uint32_t;
typedef int64_t khronos_int64_t;
typedef uint64_t khronos_uint64_t;
#define KHRONOS_SUPPORT_INT64 1
#define KHRONOS_SUPPORT_FLOAT 1
#endif
/*
* Types that are (so far) the same on all platforms
*/
typedef signed char khronos_int8_t;
typedef unsigned char khronos_uint8_t;
typedef signed short int khronos_int16_t;
typedef unsigned short int khronos_uint16_t;
/*
* Types that differ between LLP64 and LP64 architectures - in LLP64,
* pointers are 64 bits, but 'long' is still 32 bits. Win64 appears
* to be the only LLP64 architecture in current use.
*/
#ifdef _WIN64
typedef signed long long int khronos_intptr_t;
typedef unsigned long long int khronos_uintptr_t;
typedef signed long long int khronos_ssize_t;
typedef unsigned long long int khronos_usize_t;
#else
typedef signed long int khronos_intptr_t;
typedef unsigned long int khronos_uintptr_t;
typedef signed long int khronos_ssize_t;
typedef unsigned long int khronos_usize_t;
#endif
#if KHRONOS_SUPPORT_FLOAT
/*
* Float type
*/
typedef float khronos_float_t;
#endif
#if KHRONOS_SUPPORT_INT64
/* Time types
*
* These types can be used to represent a time interval in nanoseconds or
* an absolute Unadjusted System Time. Unadjusted System Time is the number
* of nanoseconds since some arbitrary system event (e.g. since the last
* time the system booted). The Unadjusted System Time is an unsigned
* 64 bit value that wraps back to 0 every 584 years. Time intervals
* may be either signed or unsigned.
*/
typedef khronos_uint64_t khronos_utime_nanoseconds_t;
typedef khronos_int64_t khronos_stime_nanoseconds_t;
#endif
/*
* Dummy value used to pad enum types to 32 bits.
*/
#ifndef KHRONOS_MAX_ENUM
#define KHRONOS_MAX_ENUM 0x7FFFFFFF
#endif
/*
* Enumerated boolean type
*
* Values other than zero should be considered to be true. Therefore
* comparisons should not be made against KHRONOS_TRUE.
*/
typedef enum {
KHRONOS_FALSE = 0,
KHRONOS_TRUE = 1,
KHRONOS_BOOLEAN_ENUM_FORCE_SIZE = KHRONOS_MAX_ENUM
} khronos_boolean_enum_t;
#endif /* __khrplatform_h_ */

3617
legacy/include/glad/glad.hpp Normal file
View File

File diff suppressed because it is too large Load Diff

154
legacy/include/logger.h Normal file
View File

@@ -0,0 +1,154 @@
#ifndef INCLUDE_LOGGER_H_
#define INCLUDE_LOGGER_H_
#include <iostream>
#include <string>
#include <sstream>
#include <map>
#ifdef _WIN32
#include <Windows.h>
typedef enum {
CONSOLE_COLOUR_FG_BLACK = 0,
CONSOLE_COLOUR_FG_BLUE = FOREGROUND_BLUE,
CONSOLE_COLOUR_FG_GREEN = FOREGROUND_GREEN,
CONSOLE_COLOUR_FG_CYAN = FOREGROUND_GREEN | FOREGROUND_BLUE,
CONSOLE_COLOUR_FG_RED = FOREGROUND_RED,
CONSOLE_COLOUR_FG_MAGENTA = FOREGROUND_RED | FOREGROUND_BLUE,
CONSOLE_COLOUR_FG_YELLOW = FOREGROUND_RED | FOREGROUND_GREEN,
CONSOLE_COLOUR_FG_GRAY = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE,
CONSOLE_COLOUR_FG_LIGHT_GRAY = FOREGROUND_INTENSITY,
CONSOLE_COLOUR_FG_LIGHT_BLUE = FOREGROUND_INTENSITY | FOREGROUND_BLUE,
CONSOLE_COLOUR_FG_LIGHT_GREEN = FOREGROUND_INTENSITY | FOREGROUND_GREEN,
CONSOLE_COLOUR_FG_LIGHT_CYAN = FOREGROUND_INTENSITY | FOREGROUND_GREEN | FOREGROUND_BLUE,
CONSOLE_COLOUR_FG_LIGHT_RED = FOREGROUND_INTENSITY | FOREGROUND_RED,
CONSOLE_COLOUR_FG_LIGHT_MAGENTA = FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_BLUE,
CONSOLE_COLOUR_FG_LIGHT_YELLOW = FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN,
CONSOLE_COLOUR_FG_WHITE = FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE,
CONSOLE_COLOUR_FG_DEFAULT = FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE,
CONSOLE_COLOUR_BG_DEFAULT = 0
} ConsoleColour;
#ifdef _WIN32
static HANDLE h = GetStdHandle(STD_OUTPUT_HANDLE);
static WORD wOldColorAttrs;
static CONSOLE_SCREEN_BUFFER_INFO csbiInfo;
#endif
#else
typedef enum {
CONSOLE_COLOUR_FG_DEFAULT = 39,
CONSOLE_COLOUR_FG_BLACK = 30,
CONSOLE_COLOUR_FG_RED = 31,
CONSOLE_COLOUR_FG_GREEN = 32,
CONSOLE_COLOUR_FG_YELLOW = 33,
CONSOLE_COLOUR_FG_BLUE = 34,
CONSOLE_COLOUR_FG_MAGENTA = 35,
CONSOLE_COLOUR_FG_CYAN = 36,
CONSOLE_COLOUR_FG_LIGHT_GRAY = 37,
CONSOLE_COLOUR_FG_DARK_GRAY = 90,
CONSOLE_COLOUR_FG_LIGHT_RED = 91,
CONSOLE_COLOUR_FG_LIGHT_GREEN = 92,
CONSOLE_COLOUR_FG_LIGHT_YELLOW = 93,
CONSOLE_COLOUR_FG_LIGHT_BLUE = 94,
CONSOLE_COLOUR_FG_LIGHT_MAGENTA = 95,
CONSOLE_COLOUR_FG_LIGHT_CYAN = 96,
CONSOLE_COLOUR_FG_WHITE = 97,
CONSOLE_COLOUR_BG_RED = 41,
CONSOLE_COLOUR_BG_GREEN = 42,
CONSOLE_COLOUR_BG_BLUE = 44,
CONSOLE_COLOUR_BG_DEFAULT = 49
} ConsoleColour;
#endif
class Colour {
public:
static void resetColour();
template<typename T>
static void consoleColour(T colour) {
#ifdef _WIN32
SetConsoleTextAttribute(h, colour);
#else
std::cout << "\033[" << colour << "m";
#endif
}
};
typedef enum {
LOGGER_INFO = CONSOLE_COLOUR_FG_GREEN,
LOGGER_WARN = CONSOLE_COLOUR_FG_YELLOW,
LOGGER_ERROR = CONSOLE_COLOUR_FG_LIGHT_RED,
LOGGER_PANIC = CONSOLE_COLOUR_FG_RED,
LOGGER_DEBUG = CONSOLE_COLOUR_FG_BLUE
} LogType;
typedef enum {
LOGGER_EXIT,
LOGGER_ENDL
} LogAction;
class Logger {
public:
std::stringstream outStream;
std::map<LogType, std::string> lookupTable;
Logger();
Logger& operator<< (const LogType type) {
std::cout << "[";
Colour::consoleColour(type);
std::cout << lookupTable[type];
Colour::consoleColour(CONSOLE_COLOUR_FG_DEFAULT);
std::cout << "] ";
return *this;
}
Logger& operator<< (const LogAction action) {
if (action == LOGGER_ENDL) {
std::cout << outStream.str() << std::endl;
outStream.str(std::string());;
outStream.flush();
}
if (action == LOGGER_EXIT)
exit(0);
return *this;
}
template<typename T>
Logger& operator<< (const T& data) {
outStream << data;
return *this;
}
};
#endif
#ifdef LOGGER_DEFINITION
#undef LOGGER_DEFINITION
void Colour::resetColour() {
#ifdef _WIN32
SetConsoleTextAttribute(h, CONSOLE_COLOUR_BG_DEFAULT);
SetConsoleTextAttribute(h, CONSOLE_COLOUR_FG_DEFAULT);
#else
std::cout
<< "\033[" << CONSOLE_COLOUR_BG_DEFAULT << "m"
<< "\033[" << CONSOLE_COLOUR_FG_DEFAULT << "m";
#endif
}
Logger::Logger() {
#ifdef _WIN32
GetConsoleScreenBufferInfo(h, &csbiInfo);
wOldColorAttrs = csbiInfo.wAttributes;
#endif
lookupTable[LOGGER_INFO] = "INFO";
lookupTable[LOGGER_WARN] = "WARN";
lookupTable[LOGGER_ERROR] = "ERROR";
lookupTable[LOGGER_PANIC] = "PANIC";
lookupTable[LOGGER_DEBUG] = "DEBUG";
}
#endif

2607
legacy/include/tiny_obj_loader.h Normal file
View File

File diff suppressed because it is too large Load Diff

3682
legacy/glad.cpp → legacy/really-legacy/glad.cpp
View File

File diff suppressed because it is too large Load Diff

474
legacy/main.cpp → legacy/really-legacy/main.cpp
View File

@@ -1,237 +1,237 @@
// General includes // General includes
#include <chrono> #include <chrono>
#include <vector> #include <vector>
// GL includes // GL includes
#include <glad/glad.hpp> #include <glad/glad.hpp>
// SDL includes different on windows // SDL includes different on windows
// the way i have it set up so i gotta // the way i have it set up so i gotta
// do it like this unfortunately // do it like this unfortunately
#if _WIN32 #if _WIN32
#include <SDL.h> #include <SDL.h>
#else #else
#include <SDL2/SDL.h> #include <SDL2/SDL.h>
#endif #endif
#include <glm/glm.hpp> #include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp> #include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp> #include <glm/gtc/type_ptr.hpp>
// Custom includes // Custom includes
// #define LOGGER_DEFINITION // #define LOGGER_DEFINITION
#include <logger.h> #include <logger.h>
#include "timers.h" #include "timers.h"
#include "object.h" #include "object.h"
#include "shader.h" #include "shader.h"
int main(int argc, char** argv) { int main(int argc, char** argv) {
std::cout << "-----------------------------" << std::endl; std::cout << "-----------------------------" << std::endl;
std::cout << "----- OpenGL Playground -----" << std::endl; std::cout << "----- OpenGL Playground -----" << std::endl;
std::cout << "-------- Version 1.0 --------" << std::endl; std::cout << "-------- Version 1.0 --------" << std::endl;
std::cout << "----- ©Benjamin Kyd 2019 ----" << std::endl; std::cout << "----- ©Benjamin Kyd 2019 ----" << std::endl;
std::cout << "-----------------------------" << std::endl; std::cout << "-----------------------------" << std::endl;
std::cout << std::endl; std::cout << std::endl;
// Get global variables ready // Get global variables ready
Logger logger; Logger logger;
SDL_Window* window = nullptr; SDL_Window* window = nullptr;
SDL_GLContext glContext; SDL_GLContext glContext;
bool isWindowOpen = false; bool isWindowOpen = false;
// Initialize SDL and OpenGL // Initialize SDL and OpenGL
// isWindowOpen = init(logger, window, glContext); // isWindowOpen = init(logger, window, glContext);
SDL_Init(SDL_INIT_EVERYTHING); SDL_Init(SDL_INIT_EVERYTHING);
SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8); SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8); SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8); SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8); SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_BUFFER_SIZE, 32); SDL_GL_SetAttribute(SDL_GL_BUFFER_SIZE, 32);
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1); SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
// MXAA // MXAA
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1); SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1);
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, 4); SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, 4);
SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "4"); SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "4");
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 4); SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 4);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 5); SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 5);
window = SDL_CreateWindow("OpenGL Playground V1.0", window = SDL_CreateWindow("OpenGL Playground V1.0",
SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
// 640, 480, // 640, 480,
1280, 720, 1280, 720,
SDL_WINDOW_OPENGL); SDL_WINDOW_OPENGL);
glContext = SDL_GL_CreateContext(window); glContext = SDL_GL_CreateContext(window);
SDL_GL_SetSwapInterval(1); SDL_GL_SetSwapInterval(1);
gladLoadGLLoader(SDL_GL_GetProcAddress); gladLoadGLLoader(SDL_GL_GetProcAddress);
// SDL_SetRelativeMouseMode(SDL_TRUE); // SDL_SetRelativeMouseMode(SDL_TRUE);
// SDL_WarpMouseInWindow(window, 0, 0); // SDL_WarpMouseInWindow(window, 0, 0);
isWindowOpen = true; isWindowOpen = true;
logger << LOGGER_INFO << "OpenGL and SDL initialized" << LOGGER_ENDL; logger << LOGGER_INFO << "OpenGL and SDL initialized" << LOGGER_ENDL;
// Load an object into system memory // Load an object into system memory
std::vector<glm::vec3> vertices; std::vector<glm::vec3> vertices;
std::vector<glm::vec3> normals; std::vector<glm::vec3> normals;
std::vector<GLushort> elements; std::vector<GLushort> elements;
// LoadOBJ(logger, "./resources/dragon.obj", vertices, normals, elements); // LoadOBJ(logger, "./resources/dragon.obj", vertices, normals, elements);
LoadOBJ(logger, "./resources/lucy.obj", vertices, normals, elements); LoadOBJ(logger, "./resources/lucy.obj", vertices, normals, elements);
// LoadOBJ(logger, "./resources/donut.obj", vertices, normals, elements); // LoadOBJ(logger, "./resources/donut.obj", vertices, normals, elements);
std::vector<glm::vec3> toGPU; std::vector<glm::vec3> toGPU;
toGPU.insert(toGPU.end(), vertices.begin(), vertices.end()); toGPU.insert(toGPU.end(), vertices.begin(), vertices.end());
toGPU.insert(toGPU.end(), normals.begin(), normals.end()); toGPU.insert(toGPU.end(), normals.begin(), normals.end());
// Generate a vertex array object // Generate a vertex array object
GLuint vao; GLuint vao;
glGenVertexArrays(1, &vao); glGenVertexArrays(1, &vao);
// Bind array to GPU // Bind array to GPU
glBindVertexArray(vao); glBindVertexArray(vao);
// Generate a vertex buffer object // Generate a vertex buffer object
GLuint vbo; GLuint vbo;
glGenBuffers(1, &vbo); glGenBuffers(1, &vbo);
// Bind buffer to the GPU // Bind buffer to the GPU
glBindBuffer(GL_ARRAY_BUFFER, vbo); glBindBuffer(GL_ARRAY_BUFFER, vbo);
// Copy vertex data to the vertex buffer already on the GPU // Copy vertex data to the vertex buffer already on the GPU
glBufferData(GL_ARRAY_BUFFER, toGPU.size() * sizeof(glm::vec3), &toGPU[0], GL_STATIC_DRAW); glBufferData(GL_ARRAY_BUFFER, toGPU.size() * sizeof(glm::vec3), &toGPU[0], GL_STATIC_DRAW);
// Generate another vertex buffer for the element array buffer // Generate another vertex buffer for the element array buffer
GLuint ebo; GLuint ebo;
glGenBuffers(1, &ebo); glGenBuffers(1, &ebo);
// Bind buffer to the GPU // Bind buffer to the GPU
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo);
// Copy buffer data to the buffer already on the GPU // Copy buffer data to the buffer already on the GPU
glBufferData(GL_ELEMENT_ARRAY_BUFFER, elements.size() * sizeof(GLushort), &elements[0], GL_STATIC_DRAW); glBufferData(GL_ELEMENT_ARRAY_BUFFER, elements.size() * sizeof(GLushort), &elements[0], GL_STATIC_DRAW);
// Load, compile, apply and link shader programs // Load, compile, apply and link shader programs
Shader simpleShader{ logger }; Shader simpleShader{ logger };
simpleShader.load("./resources/shaders/phong").attatch().link().use(); simpleShader.load("./resources/shaders/phong").attatch().link().use();
GLint posAttrib = glGetAttribLocation(simpleShader.getProgram(), "position"); GLint posAttrib = glGetAttribLocation(simpleShader.getProgram(), "position");
glEnableVertexAttribArray(posAttrib); glEnableVertexAttribArray(posAttrib);
glVertexAttribPointer(posAttrib, 3, GL_FLOAT, GL_FALSE, 0, 0); glVertexAttribPointer(posAttrib, 3, GL_FLOAT, GL_FALSE, 0, 0);
GLint normalAttrib = glGetAttribLocation(simpleShader.getProgram(), "normal"); GLint normalAttrib = glGetAttribLocation(simpleShader.getProgram(), "normal");
glEnableVertexAttribArray(normalAttrib); glEnableVertexAttribArray(normalAttrib);
glVertexAttribPointer(normalAttrib, 3, GL_FLOAT, GL_FALSE, 0, (const void*)(vertices.size() * sizeof(glm::vec3))); glVertexAttribPointer(normalAttrib, 3, GL_FLOAT, GL_FALSE, 0, (const void*)(vertices.size() * sizeof(glm::vec3)));
// Set up camera // Set up camera
// Camera camera(glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(0.0f, -90.0f, 0.0f), 45.0f, 640.0f / 480.0f, 0.1f, 1000.0f); // Camera camera(glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(0.0f, -90.0f, 0.0f), 45.0f, 640.0f / 480.0f, 0.1f, 1000.0f);
// Model matrice // Model matrice
glm::mat4 model = glm::mat4(1.0f); glm::mat4 model = glm::mat4(1.0f);
model = glm::translate(model, { -170.0f, -170.0f, -170.0f }); model = glm::translate(model, { -170.0f, -170.0f, -170.0f });
model = glm::rotate(model, glm::radians(-160.0f), glm::vec3(0.0f, 1.0f, 0.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 // Gets uniform for model matrice, to be used later
GLint uniTrans = glGetUniformLocation(simpleShader.getProgram(), "model"); GLint uniTrans = glGetUniformLocation(simpleShader.getProgram(), "model");
glUniformMatrix4fv(uniTrans, 1, GL_FALSE, glm::value_ptr(model)); glUniformMatrix4fv(uniTrans, 1, GL_FALSE, glm::value_ptr(model));
// View matrice // View matrice
glm::mat4 view = glm::lookAt( glm::mat4 view = glm::lookAt(
glm::vec3(1.0f, 1.0f, 1.0f), glm::vec3(1.0f, 1.0f, 1.0f),
glm::vec3(0.0f, 0.4f, 0.0f), glm::vec3(0.0f, 0.4f, 0.0f),
glm::vec3(0.0f, 1.0f, 0.0f) glm::vec3(0.0f, 1.0f, 0.0f)
); );
// Get uniform and send it to the GPU // Get uniform and send it to the GPU
GLint uniView = glGetUniformLocation(simpleShader.getProgram(), "view"); GLint uniView = glGetUniformLocation(simpleShader.getProgram(), "view");
glUniformMatrix4fv(uniView, 1, GL_FALSE, glm::value_ptr(view)); glUniformMatrix4fv(uniView, 1, GL_FALSE, glm::value_ptr(view));
// Projection matrice // Projection matrice
glm::mat4 proj = glm::perspective(glm::radians(45.0f), 1280.0f / 720.0f, 1.0f, 1000.0f);//camera.perspective; 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 // Get uniform and send it to the GPU
GLint uniProj = glGetUniformLocation(simpleShader.getProgram(), "proj"); GLint uniProj = glGetUniformLocation(simpleShader.getProgram(), "proj");
glUniformMatrix4fv(uniProj, 1, GL_FALSE, glm::value_ptr(proj)); glUniformMatrix4fv(uniProj, 1, GL_FALSE, glm::value_ptr(proj));
glm::vec3 lightPos = { -2.0f, 4.0f, -1.0f }; glm::vec3 lightPos = { -2.0f, 4.0f, -1.0f };
GLint uniLight = glGetUniformLocation(simpleShader.getProgram(), "lightpos"); GLint uniLight = glGetUniformLocation(simpleShader.getProgram(), "lightpos");
glUniformMatrix3fv(uniLight, 1, GL_FALSE, glm::value_ptr(lightPos)); glUniformMatrix3fv(uniLight, 1, GL_FALSE, glm::value_ptr(lightPos));
simpleShader.use(); simpleShader.use();
glEnable(GL_DEPTH_TEST); glEnable(GL_DEPTH_TEST);
glEnable(GL_MULTISAMPLE); glEnable(GL_MULTISAMPLE);
SDL_Event event; SDL_Event event;
logger << LOGGER_ENDL; logger << LOGGER_ENDL;
while (isWindowOpen) { while (isWindowOpen) {
FPSCount(logger); FPSCount(logger);
// Update tick (60ups) // Update tick (60ups)
if (UPSTimer()) { if (UPSTimer()) {
const Uint8 *state = SDL_GetKeyboardState(NULL); const Uint8 *state = SDL_GetKeyboardState(NULL);
if (state[SDL_SCANCODE_Q]) { if (state[SDL_SCANCODE_Q]) {
model = glm::rotate(model, glm::radians(-1.5f), glm::vec3(0.0f, 1.0f, 0.0f)); model = glm::rotate(model, glm::radians(-1.5f), glm::vec3(0.0f, 1.0f, 0.0f));
glUniformMatrix4fv(uniTrans, 1, GL_FALSE, glm::value_ptr(model)); glUniformMatrix4fv(uniTrans, 1, GL_FALSE, glm::value_ptr(model));
} }
if (state[SDL_SCANCODE_E]) { if (state[SDL_SCANCODE_E]) {
model = glm::rotate(model, glm::radians(1.5f), glm::vec3(0.0f, 1.0f, 0.0f)); model = glm::rotate(model, glm::radians(1.5f), glm::vec3(0.0f, 1.0f, 0.0f));
glUniformMatrix4fv(uniTrans, 1, GL_FALSE, glm::value_ptr(model)); glUniformMatrix4fv(uniTrans, 1, GL_FALSE, glm::value_ptr(model));
} }
UpdateClock = SDL_GetTicks(); UpdateClock = SDL_GetTicks();
} }
// Handle events // Handle events
while (SDL_PollEvent(&event) != 0) { while (SDL_PollEvent(&event) != 0) {
if (event.type == SDL_QUIT || event.key.keysym.sym == SDLK_ESCAPE) if (event.type == SDL_QUIT || event.key.keysym.sym == SDLK_ESCAPE)
isWindowOpen = false; isWindowOpen = false;
if (event.key.keysym.sym == SDLK_r) { if (event.key.keysym.sym == SDLK_r) {
simpleShader.reload(); simpleShader.reload();
posAttrib = glGetAttribLocation(simpleShader.getProgram(), "position"); posAttrib = glGetAttribLocation(simpleShader.getProgram(), "position");
glEnableVertexAttribArray(posAttrib); glEnableVertexAttribArray(posAttrib);
glVertexAttribPointer(posAttrib, 3, GL_FLOAT, GL_FALSE, 0, 0); glVertexAttribPointer(posAttrib, 3, GL_FLOAT, GL_FALSE, 0, 0);
normalAttrib = glGetAttribLocation(simpleShader.getProgram(), "normal"); normalAttrib = glGetAttribLocation(simpleShader.getProgram(), "normal");
glEnableVertexAttribArray(normalAttrib); glEnableVertexAttribArray(normalAttrib);
glVertexAttribPointer(normalAttrib, 3, GL_FLOAT, GL_FALSE, 0, (const void*)(vertices.size() * sizeof(glm::vec3))); glVertexAttribPointer(normalAttrib, 3, GL_FLOAT, GL_FALSE, 0, (const void*)(vertices.size() * sizeof(glm::vec3)));
uniTrans = glGetUniformLocation(simpleShader.getProgram(), "model"); uniTrans = glGetUniformLocation(simpleShader.getProgram(), "model");
glUniformMatrix4fv(uniTrans, 1, GL_FALSE, glm::value_ptr(model)); glUniformMatrix4fv(uniTrans, 1, GL_FALSE, glm::value_ptr(model));
uniView = glGetUniformLocation(simpleShader.getProgram(), "view"); uniView = glGetUniformLocation(simpleShader.getProgram(), "view");
glUniformMatrix4fv(uniView, 1, GL_FALSE, glm::value_ptr(view)); glUniformMatrix4fv(uniView, 1, GL_FALSE, glm::value_ptr(view));
uniProj = glGetUniformLocation(simpleShader.getProgram(), "proj"); uniProj = glGetUniformLocation(simpleShader.getProgram(), "proj");
glUniformMatrix4fv(uniProj, 1, GL_FALSE, glm::value_ptr(proj)); glUniformMatrix4fv(uniProj, 1, GL_FALSE, glm::value_ptr(proj));
uniLight = glGetUniformLocation(simpleShader.getProgram(), "lightpos"); uniLight = glGetUniformLocation(simpleShader.getProgram(), "lightpos");
glUniformMatrix3fv(uniLight, 1, GL_FALSE, glm::value_ptr(lightPos)); glUniformMatrix3fv(uniLight, 1, GL_FALSE, glm::value_ptr(lightPos));
} }
if (event.type == SDL_MOUSEMOTION) { if (event.type == SDL_MOUSEMOTION) {
int mouseX = event.motion.xrel; int mouseX = event.motion.xrel;
int mouseY = event.motion.yrel; int mouseY = event.motion.yrel;
// camera.rot.y += mouseX * 0.5f; // camera.rot.y += mouseX * 0.5f;
// camera.rot.x += mouseY * -0.5f; // camera.rot.x += mouseY * -0.5f;
} }
} }
glViewport(0, 0, 1280, 720); glViewport(0, 0, 1280, 720);
glBindFramebuffer(GL_FRAMEBUFFER, 0); glBindFramebuffer(GL_FRAMEBUFFER, 0);
glClear(GL_DEPTH_BUFFER_BIT); glClear(GL_DEPTH_BUFFER_BIT);
const float clear[] = {0.1f, 0.45f, 0.9f, 1.0f}; const float clear[] = {0.1f, 0.45f, 0.9f, 1.0f};
glClearBufferfv(GL_COLOR, 0, clear); glClearBufferfv(GL_COLOR, 0, clear);
simpleShader.use(); simpleShader.use();
glDrawElements(GL_TRIANGLES, elements.size(), GL_UNSIGNED_SHORT, 0); glDrawElements(GL_TRIANGLES, elements.size(), GL_UNSIGNED_SHORT, 0);
// Swap // Swap
SDL_GL_SwapWindow(window); SDL_GL_SwapWindow(window);
} }
return 0; return 0;
} }

116
legacy/object.cpp → legacy/really-legacy/object.cpp
View File

@@ -1,58 +1,58 @@
#include "object.h" #include "object.h"
#include <fstream> #include <fstream>
// https://en.wikibooks.org/wiki/OpenGL_Programming/Modern_OpenGL_Tutorial_Load_OBJ // https://en.wikibooks.org/wiki/OpenGL_Programming/Modern_OpenGL_Tutorial_Load_OBJ
void LoadOBJ(Logger& logger, std::string file, std::vector<glm::vec3>& vertices, std::vector<glm::vec3>& normals, std::vector<GLushort>& elements) { void LoadOBJ(Logger& logger, std::string file, std::vector<glm::vec3>& vertices, std::vector<glm::vec3>& normals, std::vector<GLushort>& elements) {
std::ifstream in(file, std::ios::in); std::ifstream in(file, std::ios::in);
if (!in) { if (!in) {
logger << LOGGER_ERROR << "Cannot open " << file << LOGGER_ENDL; logger << LOGGER_ERROR << "Cannot open " << file << LOGGER_ENDL;
return; return;
} }
std::string line; std::string line;
while (getline(in, line)) { while (getline(in, line)) {
if (line.substr(0,2) == "v ") { if (line.substr(0,2) == "v ") {
std::istringstream s(line.substr(2)); std::istringstream s(line.substr(2));
glm::vec3 v; s >> v.x; s >> v.y; s >> v.z; glm::vec3 v; s >> v.x; s >> v.y; s >> v.z;
vertices.push_back(v); vertices.push_back(v);
} else if (line.substr(0,2) == "f ") { } else if (line.substr(0,2) == "f ") {
std::istringstream s(line.substr(2)); std::istringstream s(line.substr(2));
GLushort a,b,c; GLushort a,b,c;
s >> a; s >> b; s >> c; s >> a; s >> b; s >> c;
a--; b--; c--; a--; b--; c--;
elements.push_back(a); elements.push_back(b); elements.push_back(c); elements.push_back(a); elements.push_back(b); elements.push_back(c);
} else if (line[0] == '#') { } } else if (line[0] == '#') { }
else {} else {}
} }
normals.resize(vertices.size(), glm::vec3(0.0, 0.0, 0.0)); normals.resize(vertices.size(), glm::vec3(0.0, 0.0, 0.0));
for (int i = 0; i < elements.size(); i += 3) { for (int i = 0; i < elements.size(); i += 3) {
GLushort ia = elements[i]; GLushort ia = elements[i];
GLushort ib = elements[i+1]; GLushort ib = elements[i+1];
GLushort ic = elements[i+2]; GLushort ic = elements[i+2];
glm::vec3 normal = glm::normalize(glm::cross( glm::vec3 normal = glm::normalize(glm::cross(
glm::vec3(vertices[ib]) - glm::vec3(vertices[ia]), glm::vec3(vertices[ib]) - glm::vec3(vertices[ia]),
glm::vec3(vertices[ic]) - glm::vec3(vertices[ia]))); glm::vec3(vertices[ic]) - glm::vec3(vertices[ia])));
normals[ia] = normals[ib] = normals[ic] = normal; normals[ia] = normals[ib] = normals[ic] = normal;
} }
logger << LOGGER_INFO << "Loaded OBJ: " << file << LOGGER_ENDL; logger << LOGGER_INFO << "Loaded OBJ: " << file << LOGGER_ENDL;
} }
void FlatShade(std::vector<glm::vec3>& vertices, std::vector<glm::vec3>& normals, std::vector<GLushort>& elements) { void FlatShade(std::vector<glm::vec3>& vertices, std::vector<glm::vec3>& normals, std::vector<GLushort>& elements) {
std::vector<glm::vec3> shared_vertices; std::vector<glm::vec3> shared_vertices;
for (int i = 0; i < elements.size(); i++) { for (int i = 0; i < elements.size(); i++) {
vertices.push_back(shared_vertices[elements[i]]); vertices.push_back(shared_vertices[elements[i]]);
if ((i % 3) == 2) { if ((i % 3) == 2) {
GLushort ia = elements[i-2]; GLushort ia = elements[i-2];
GLushort ib = elements[i-1]; GLushort ib = elements[i-1];
GLushort ic = elements[i]; GLushort ic = elements[i];
glm::vec3 normal = glm::normalize(glm::cross( glm::vec3 normal = glm::normalize(glm::cross(
shared_vertices[ic] - shared_vertices[ia], shared_vertices[ic] - shared_vertices[ia],
shared_vertices[ib] - shared_vertices[ia])); shared_vertices[ib] - shared_vertices[ia]));
for (int n = 0; n < 3; n++) for (int n = 0; n < 3; n++)
normals.push_back(normal); normals.push_back(normal);
} }
} }
} }

66
legacy/object.h → legacy/really-legacy/object.h
View File

@@ -1,33 +1,33 @@
#ifndef SRC_OBJECT_H_ #ifndef SRC_OBJECT_H_
#define SRC_OBJECT_H_ #define SRC_OBJECT_H_
// General includes // General includes
#include <vector> #include <vector>
// GL includes // GL includes
#include <glad/glad.hpp> #include <glad/glad.hpp>
#if _WIN32 #if _WIN32
#include <SDL.h> #include <SDL.h>
#else #else
#include <SDL2/SDL.h> #include <SDL2/SDL.h>
#endif #endif
#include <glm/glm.hpp> #include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp> #include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp> #include <glm/gtc/type_ptr.hpp>
// Custom includes // Custom includes
#include <logger.h> #include <logger.h>
void LoadOBJ(Logger& logger, void LoadOBJ(Logger& logger,
std::string file, std::string file,
std::vector<glm::vec3>& vertices, std::vector<glm::vec3>& vertices,
std::vector<glm::vec3>& normals, std::vector<glm::vec3>& normals,
std::vector<GLushort>& elements); std::vector<GLushort>& elements);
void FlatShade(std::vector<glm::vec3>& vertices, void FlatShade(std::vector<glm::vec3>& vertices,
std::vector<glm::vec3>& normals, std::vector<glm::vec3>& normals,
std::vector<GLushort>& elements); std::vector<GLushort>& elements);
#endif #endif

2312
legacy/resources/donut.obj → legacy/really-legacy/resources/donut.obj
View File

File diff suppressed because it is too large Load Diff

300032
legacy/resources/dragon.obj → legacy/really-legacy/resources/dragon.obj
View File

File diff suppressed because it is too large Load Diff

300156
legacy/resources/lucy.obj → legacy/really-legacy/resources/lucy.obj
View File

File diff suppressed because it is too large Load Diff

78
legacy/resources/shaders/phong.frag → legacy/really-legacy/resources/shaders/phong.frag
View File

@@ -1,39 +1,39 @@
#version 330 #version 330
in vec3 Normal; in vec3 Normal;
in vec3 FragPos; in vec3 FragPos;
// in vec4 FragPosLightSpace; // in vec4 FragPosLightSpace;
uniform vec3 lightPos; uniform vec3 lightPos;
out vec4 outColour; out vec4 outColour;
vec3 viewPos = vec3(0.0, 0.0, 0.0); vec3 viewPos = vec3(0.0, 0.0, 0.0);
vec3 objectColour = vec3(1.0, 1.0, 1.0); vec3 objectColour = vec3(1.0, 1.0, 1.0);
vec3 lightColour = vec3(0.7, 0.0, 0.65); vec3 lightColour = vec3(0.7, 0.0, 0.65);
// vec3 lightColour = vec3(0.3, 0.85, 1.0); // vec3 lightColour = vec3(0.3, 0.85, 1.0);
void main() { void main() {
vec3 normal = normalize(Normal); vec3 normal = normalize(Normal);
vec3 lightDir = normalize(lightPos - FragPos); vec3 lightDir = normalize(lightPos - FragPos);
float diff = max(dot(normal, lightDir), 0.0); float diff = max(dot(normal, lightDir), 0.0);
vec3 diffuse = diff * lightColour; vec3 diffuse = diff * lightColour;
float specularStrength = 0; float specularStrength = 0;
vec3 viewDir = normalize(viewPos - FragPos); vec3 viewDir = normalize(viewPos - FragPos);
vec3 reflectDir = reflect(-lightDir, normal); vec3 reflectDir = reflect(-lightDir, normal);
float spec = pow(max(dot(viewDir, reflectDir), 0.0), 32); float spec = pow(max(dot(viewDir, reflectDir), 0.0), 32);
vec3 specular = specularStrength * spec * lightColour; vec3 specular = specularStrength * spec * lightColour;
float ambientStrength = 0.4; float ambientStrength = 0.4;
vec3 ambient = ambientStrength * lightColour; vec3 ambient = ambientStrength * lightColour;
vec3 result = (ambient + diffuse + specular) * objectColour; vec3 result = (ambient + diffuse + specular) * objectColour;
outColour = vec4(result, 1.0); outColour = vec4(result, 1.0);
} }

36
legacy/resources/shaders/phong.vert → legacy/really-legacy/resources/shaders/phong.vert
View File

@@ -1,18 +1,18 @@
#version 330 #version 330
layout(location = 0) in vec3 position; layout(location = 0) in vec3 position;
layout(location = 1) in vec3 normal; layout(location = 1) in vec3 normal;
layout(location = 2) in vec3 texCoord; layout(location = 2) in vec3 texCoord;
out vec3 Normal; out vec3 Normal;
out vec3 FragPos; out vec3 FragPos;
uniform mat4 model; uniform mat4 model;
uniform mat4 view; uniform mat4 view;
uniform mat4 proj; uniform mat4 proj;
void main() { void main() {
gl_Position = proj * view * model * vec4(position, 1.0); gl_Position = proj * view * model * vec4(position, 1.0);
FragPos = vec3(model * vec4(position, 1.0)); FragPos = vec3(model * vec4(position, 1.0));
Normal = mat3(model) * normal; Normal = mat3(model) * normal;
} }

14
legacy/resources/shaders/shadowmap.frag → legacy/really-legacy/resources/shaders/shadowmap.frag
View File

@@ -1,7 +1,7 @@
#version 330 #version 330
out float fragdepth; out float fragdepth;
void main(){ void main(){
gl_FragDepth = gl_FragCoord.z; gl_FragDepth = gl_FragCoord.z;
} }

20
legacy/resources/shaders/shadowmap.vert → legacy/really-legacy/resources/shaders/shadowmap.vert
View File

@@ -1,10 +1,10 @@
#version 330 #version 330
in vec3 vertPos; in vec3 vertPos;
uniform mat4 lightSpaceMatrix; uniform mat4 lightSpaceMatrix;
uniform mat4 model; uniform mat4 model;
void main() { void main() {
gl_Position = lightSpaceMatrix * model * vec4(vertPos, 1.0); gl_Position = lightSpaceMatrix * model * vec4(vertPos, 1.0);
} }

14
legacy/resources/shaders/simple.frag → legacy/really-legacy/resources/shaders/simple.frag
View File

@@ -1,7 +1,7 @@
#version 330 #version 330
out vec4 outColour; out vec4 outColour;
void main() { void main() {
outColour = vec4(0.58, 0.61, 0.627, 1.0); outColour = vec4(0.58, 0.61, 0.627, 1.0);
} }

22
legacy/resources/shaders/simple.vert → legacy/really-legacy/resources/shaders/simple.vert
View File

@@ -1,11 +1,11 @@
#version 330 #version 330
in vec3 position; in vec3 position;
uniform mat4 model; uniform mat4 model;
uniform mat4 view; uniform mat4 view;
uniform mat4 proj; uniform mat4 proj;
void main() { void main() {
gl_Position = proj * view * model * vec4(position, 1.0); gl_Position = proj * view * model * vec4(position, 1.0);
} }

0
legacy/resources/stanford_dragon.zip → legacy/really-legacy/resources/stanford_dragon.zip
View File

334
legacy/shader.cpp → legacy/really-legacy/shader.cpp
View File

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

84
legacy/shader.h → legacy/really-legacy/shader.h
View File

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

72
legacy/timers.h → legacy/really-legacy/timers.h
View File

@@ -1,36 +1,36 @@
#ifndef SRC_TIMERS_H_ #ifndef SRC_TIMERS_H_
#define SRC_TIMERS_H_ #define SRC_TIMERS_H_
// General includes // General includes
#include <chrono> #include <chrono>
// GL includes // GL includes
#if _WIN32 #if _WIN32
#include <SDL.h> #include <SDL.h>
#else #else
#include <SDL2/SDL.h> #include <SDL2/SDL.h>
#endif #endif
// Custom includes // Custom includes
#include <logger.h> #include <logger.h>
std::chrono::high_resolution_clock timer; std::chrono::high_resolution_clock timer;
auto FPSCalculateLast = timer.now(); auto FPSCalculateLast = timer.now();
auto FPSClock = SDL_GetTicks(); auto FPSClock = SDL_GetTicks();
auto UpdateClock = SDL_GetTicks(); auto UpdateClock = SDL_GetTicks();
void FPSCount(Logger& logger) { void FPSCount(Logger& logger) {
if (SDL_GetTicks() - FPSClock >= 1000) { if (SDL_GetTicks() - FPSClock >= 1000) {
auto deltaTime = std::chrono::duration_cast<std::chrono::nanoseconds>(timer.now() - FPSCalculateLast).count(); auto deltaTime = std::chrono::duration_cast<std::chrono::nanoseconds>(timer.now() - FPSCalculateLast).count();
logger << LOGGER_INFO << "FPS: " << (int)(1 / ((float)deltaTime * 1e-9)) << LOGGER_ENDL; logger << LOGGER_INFO << "FPS: " << (int)(1 / ((float)deltaTime * 1e-9)) << LOGGER_ENDL;
FPSClock = SDL_GetTicks(); FPSClock = SDL_GetTicks();
} }
FPSCalculateLast = timer.now(); FPSCalculateLast = timer.now();
} }
bool UPSTimer() { bool UPSTimer() {
return (SDL_GetTicks() - UpdateClock >= 10); return (SDL_GetTicks() - UpdateClock >= 10);
} }
#endif #endif

176
src/camera.cpp → legacy/src/camera.cpp
View File

@@ -1,88 +1,88 @@
#include "camera.h" #include "camera.h"
Camera::Camera() { Camera::Camera() {
} }
void Camera::updateView() { void Camera::updateView() {
//roll can be removed from here. because is not actually used in FPS camera //roll can be removed from here. because is not actually used in FPS camera
glm::mat4 matRoll = glm::mat4(1.0f);//identity matrix; glm::mat4 matRoll = glm::mat4(1.0f);//identity matrix;
glm::mat4 matPitch = glm::mat4(1.0f);//identity matrix glm::mat4 matPitch = glm::mat4(1.0f);//identity matrix
glm::mat4 matYaw = glm::mat4(1.0f);//identity matrix glm::mat4 matYaw = glm::mat4(1.0f);//identity matrix
//roll, pitch and yaw are used to store our angles in our class //roll, pitch and yaw are used to store our angles in our class
matRoll = glm::rotate(matRoll, roll, glm::vec3(0.0f, 0.0f, 1.0f)); matRoll = glm::rotate(matRoll, roll, glm::vec3(0.0f, 0.0f, 1.0f));
matPitch = glm::rotate(matPitch, pitch, glm::vec3(1.0f, 0.0f, 0.0f)); matPitch = glm::rotate(matPitch, pitch, glm::vec3(1.0f, 0.0f, 0.0f));
matYaw = glm::rotate(matYaw, yaw, glm::vec3(0.0f, 1.0f, 0.0f)); matYaw = glm::rotate(matYaw, yaw, glm::vec3(0.0f, 1.0f, 0.0f));
//order matters //order matters
glm::mat4 rotate = matRoll * matPitch * matYaw; glm::mat4 rotate = matRoll * matPitch * matYaw;
glm::mat4 translate = glm::mat4(1.0f); glm::mat4 translate = glm::mat4(1.0f);
translate = glm::translate(translate, -eyeVector); translate = glm::translate(translate, -eyeVector);
viewMatrix = rotate * translate; viewMatrix = rotate * translate;
} }
glm::mat4 Camera::getViewMatrix() { glm::mat4 Camera::getViewMatrix() {
return viewMatrix; return viewMatrix;
} }
glm::vec3 Camera::getPos() { glm::vec3 Camera::getPos() {
return eyeVector; return eyeVector;
} }
void Camera::handleMouse(SDL_Event e) { void Camera::handleMouse(SDL_Event e) {
if (e.type != SDL_MOUSEMOTION) if (e.type != SDL_MOUSEMOTION)
return; return;
float mouseDX = e.motion.xrel; float mouseDX = e.motion.xrel;
float mouseDY = e.motion.yrel; float mouseDY = e.motion.yrel;
glm::vec2 mouseDelta {mouseDX, mouseDY}; glm::vec2 mouseDelta {mouseDX, mouseDY};
mouseMoved(mouseDelta); mouseMoved(mouseDelta);
} }
void Camera::moveCamera() { void Camera::moveCamera() {
float dx = 0; //how much we strafe on x float dx = 0; //how much we strafe on x
float dz = 0; //how much we walk on z float dz = 0; //how much we walk on z
const Uint8* state = SDL_GetKeyboardState(NULL); const Uint8* state = SDL_GetKeyboardState(NULL);
if (state[SDL_SCANCODE_W]) if (state[SDL_SCANCODE_W])
dz += 2; dz += 2;
if (state[SDL_SCANCODE_S]) if (state[SDL_SCANCODE_S])
dz += -2; dz += -2;
if (state[SDL_SCANCODE_A]) if (state[SDL_SCANCODE_A])
dx += -2; dx += -2;
if (state[SDL_SCANCODE_D]) if (state[SDL_SCANCODE_D])
dx += 2; dx += 2;
// if (state[SDL_SCANCODE_Z]) // if (state[SDL_SCANCODE_Z])
// if (state[SDL_SCANCODE_LSHIFT]) // if (state[SDL_SCANCODE_LSHIFT])
//get current view matrix //get current view matrix
glm::mat4 mat = getViewMatrix(); glm::mat4 mat = getViewMatrix();
//row major //row major
glm::vec3 forward(mat[0][2], mat[1][2], mat[2][2]); glm::vec3 forward(mat[0][2], mat[1][2], mat[2][2]);
glm::vec3 strafe (mat[0][0], mat[1][0], mat[2][0]); glm::vec3 strafe (mat[0][0], mat[1][0], mat[2][0]);
//forward vector must be negative to look forward. //forward vector must be negative to look forward.
//read :http://in2gpu.com/2015/05/17/view-matrix/ //read :http://in2gpu.com/2015/05/17/view-matrix/
eyeVector += (-dz * forward + dx * strafe) * cameraSpeed; eyeVector += (-dz * forward + dx * strafe) * cameraSpeed;
//update the view matrix //update the view matrix
updateView(); updateView();
} }
void Camera::mouseMoved(glm::vec2 mouseDelta) { void Camera::mouseMoved(glm::vec2 mouseDelta) {
//note that yaw and pitch must be converted to radians. //note that yaw and pitch must be converted to radians.
//this is done in UpdateView() by glm::rotate //this is done in UpdateView() by glm::rotate
yaw += mouseSensitivity * mouseDelta.x; yaw += mouseSensitivity * mouseDelta.x;
pitch += mouseSensitivity * mouseDelta.y; pitch += mouseSensitivity * mouseDelta.y;
updateView(); updateView();
} }

70
src/camera.h → legacy/src/camera.h
View File

@@ -1,35 +1,35 @@
#ifndef SMHENGINE_SRC_CAMERA_H_ #ifndef SMHENGINE_SRC_CAMERA_H_
#define SMHENGINE_SRC_CAMERA_H_ #define SMHENGINE_SRC_CAMERA_H_
#if _WIN32 #if _WIN32
#include <SDL.h> #include <SDL.h>
#else #else
#include <SDL2/SDL.h> #include <SDL2/SDL.h>
#endif #endif
#include <glm/glm.hpp> #include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp> #include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp> #include <glm/gtc/type_ptr.hpp>
class Camera { class Camera {
public: public:
Camera(); Camera();
void updateView(); void updateView();
glm::mat4 getViewMatrix(); glm::mat4 getViewMatrix();
glm::vec3 getPos(); glm::vec3 getPos();
void handleMouse(SDL_Event e); void handleMouse(SDL_Event e);
void moveCamera(); void moveCamera();
void mouseMoved(glm::vec2 mouseDelta); void mouseMoved(glm::vec2 mouseDelta);
float mouseSensitivity = 0.0025f; float mouseSensitivity = 0.0025f;
float cameraSpeed = 1.12f; float cameraSpeed = 1.12f;
private: private:
float roll, pitch, yaw; float roll, pitch, yaw;
glm::vec3 eyeVector; glm::vec3 eyeVector;
glm::mat4 viewMatrix; glm::mat4 viewMatrix;
}; };
#endif #endif

418
src/display.cpp → legacy/src/display.cpp
View File

@@ -1,209 +1,209 @@
#include "display.h" #include "display.h"
Display::Display(std::string name, Logger& logger, int w, int h, Display::Display(std::string name, Logger& logger, int w, int h,
SMH_VSYNC_DISPLAY_MODE vsyncMode, SMH_VSYNC_DISPLAY_MODE vsyncMode,
SMH_MXAA_MODE mxaaMode) SMH_MXAA_MODE mxaaMode)
: logger(logger) { : logger(logger) {
MXAAMode = mxaaMode; MXAAMode = mxaaMode;
VSyncMode = vsyncMode; VSyncMode = vsyncMode;
logger << LOGGER_INFO << "Initializing display" << LOGGER_ENDL; logger << LOGGER_INFO << "Initializing display" << LOGGER_ENDL;
SDL_Init(SDL_INIT_EVERYTHING); SDL_Init(SDL_INIT_EVERYTHING);
SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8); SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8); SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8); SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8); SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_BUFFER_SIZE, 32); SDL_GL_SetAttribute(SDL_GL_BUFFER_SIZE, 32);
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1); SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
// MXAA // MXAA
if (mxaaMode != MXAA_DEFAULT || mxaaMode != MXAA_DISABLED) { if (mxaaMode != MXAA_DEFAULT || mxaaMode != MXAA_DISABLED) {
int mxaaLevel = 1; int mxaaLevel = 1;
std::string smxaaLevel = "1"; std::string smxaaLevel = "1";
switch (mxaaMode) { switch (mxaaMode) {
case MXAA_ENABLED: case MXAA_ENABLED:
case MXAA_2X: case MXAA_2X:
mxaaLevel = 2; mxaaLevel = 2;
smxaaLevel = "2"; smxaaLevel = "2";
break; break;
case MXAA_4X: case MXAA_4X:
mxaaLevel = 4; mxaaLevel = 4;
smxaaLevel = "4"; smxaaLevel = "4";
break; break;
case MXAA_8X: case MXAA_8X:
mxaaLevel = 8; mxaaLevel = 8;
smxaaLevel = "8"; smxaaLevel = "8";
break; break;
case MXAA_16X: case MXAA_16X:
mxaaLevel = 16; mxaaLevel = 16;
smxaaLevel = "16"; smxaaLevel = "16";
break; break;
default: default:
mxaaLevel = 2; mxaaLevel = 2;
smxaaLevel = "2"; smxaaLevel = "2";
break; break;
} }
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1); SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1);
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, mxaaLevel); SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, mxaaLevel);
SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, smxaaLevel.c_str()); SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, smxaaLevel.c_str());
logger << LOGGER_INFO << "MXAA set to " << mxaaLevel << "xMSAA" << LOGGER_ENDL; logger << LOGGER_INFO << "MXAA set to " << mxaaLevel << "xMSAA" << LOGGER_ENDL;
} else { } else {
logger << LOGGER_INFO << "MXAA disabled" << LOGGER_ENDL; logger << LOGGER_INFO << "MXAA disabled" << LOGGER_ENDL;
} }
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 4); SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 4);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 5); SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 5);
// Create GL window // Create GL window
logger << LOGGER_INFO << "Creating window" << LOGGER_ENDL; logger << LOGGER_INFO << "Creating window" << LOGGER_ENDL;
window = SDL_CreateWindow(name.c_str(), window = SDL_CreateWindow(name.c_str(),
SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
SDL_WINDOWPOS_CENTERED, w, h, SDL_WINDOWPOS_CENTERED, w, h,
SDL_WINDOW_OPENGL); SDL_WINDOW_OPENGL);
// Create GL context // Create GL context
logger << LOGGER_INFO << "Creating OpenGL context" << LOGGER_ENDL; logger << LOGGER_INFO << "Creating OpenGL context" << LOGGER_ENDL;
glContext = SDL_GL_CreateContext(window); glContext = SDL_GL_CreateContext(window);
// SDL_WarpMouseInWindow(window, w / 2, h / 2); // SDL_WarpMouseInWindow(window, w / 2, h / 2);
// SDL_SetRelativeMouseMode(SDL_TRUE); // SDL_SetRelativeMouseMode(SDL_TRUE);
// Set VSYNC swap interval // Set VSYNC swap interval
if (vsyncMode == VSYNC_DEFAULT || vsyncMode == VSYNC_ENABLED) { if (vsyncMode == VSYNC_DEFAULT || vsyncMode == VSYNC_ENABLED) {
SDL_GL_SetSwapInterval(1); SDL_GL_SetSwapInterval(1);
logger << LOGGER_INFO << "VSync enabled" << LOGGER_ENDL; logger << LOGGER_INFO << "VSync enabled" << LOGGER_ENDL;
} }
if (vsyncMode == VSYNC_DISABLED) { if (vsyncMode == VSYNC_DISABLED) {
SDL_GL_SetSwapInterval(0); SDL_GL_SetSwapInterval(0);
logger << LOGGER_INFO << "VSync disabled" << LOGGER_ENDL; logger << LOGGER_INFO << "VSync disabled" << LOGGER_ENDL;
} }
logger << LOGGER_INFO << "Display set up" << LOGGER_ENDL; logger << LOGGER_INFO << "Display set up" << LOGGER_ENDL;
// Load OpenGL // Load OpenGL
gladLoadGLLoader(SDL_GL_GetProcAddress); gladLoadGLLoader(SDL_GL_GetProcAddress);
glEnable(GL_MULTISAMPLE); glEnable(GL_MULTISAMPLE);
glEnable(GL_DEPTH_TEST); glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE); glEnable(GL_CULL_FACE);
glCullFace(GL_BACK); glCullFace(GL_BACK);
logger << LOGGER_INFO << "Loaded OpenGL" << LOGGER_ENDL; logger << LOGGER_INFO << "Loaded OpenGL" << LOGGER_ENDL;
logger << LOGGER_ENDL; logger << LOGGER_ENDL;
isClosed = false; isClosed = false;
} }
Display::Display(std::string name, Logger& logger, int w, int h, Display::Display(std::string name, Logger& logger, int w, int h,
SMH_MXAA_MODE mxaaMode, SMH_MXAA_MODE mxaaMode,
SMH_VSYNC_DISPLAY_MODE vsyncMode) SMH_VSYNC_DISPLAY_MODE vsyncMode)
: logger(logger) { : logger(logger) {
MXAAMode = mxaaMode; MXAAMode = mxaaMode;
VSyncMode = vsyncMode; VSyncMode = vsyncMode;
logger << LOGGER_INFO << "Initializing display" << LOGGER_ENDL; logger << LOGGER_INFO << "Initializing display" << LOGGER_ENDL;
SDL_Init(SDL_INIT_EVERYTHING); SDL_Init(SDL_INIT_EVERYTHING);
SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8); SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8); SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8); SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8); SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_BUFFER_SIZE, 32); SDL_GL_SetAttribute(SDL_GL_BUFFER_SIZE, 32);
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1); SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
// MXAA // MXAA
if (mxaaMode != MXAA_DEFAULT || mxaaMode != MXAA_DISABLED) { if (mxaaMode != MXAA_DEFAULT || mxaaMode != MXAA_DISABLED) {
int mxaaLevel = 1; int mxaaLevel = 1;
std::string smxaaLevel = "1"; std::string smxaaLevel = "1";
switch (mxaaMode) { switch (mxaaMode) {
case MXAA_ENABLED: case MXAA_ENABLED:
case MXAA_2X: case MXAA_2X:
mxaaLevel = 2; mxaaLevel = 2;
smxaaLevel = "2"; smxaaLevel = "2";
break; break;
case MXAA_4X: case MXAA_4X:
mxaaLevel = 4; mxaaLevel = 4;
smxaaLevel = "4"; smxaaLevel = "4";
break; break;
case MXAA_8X: case MXAA_8X:
mxaaLevel = 8; mxaaLevel = 8;
smxaaLevel = "8"; smxaaLevel = "8";
break; break;
case MXAA_16X: case MXAA_16X:
mxaaLevel = 16; mxaaLevel = 16;
smxaaLevel = "16"; smxaaLevel = "16";
break; break;
default: default:
mxaaLevel = 2; mxaaLevel = 2;
smxaaLevel = "2"; smxaaLevel = "2";
break; break;
} }
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1); SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1);
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, mxaaLevel); SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, mxaaLevel);
SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, smxaaLevel.c_str()); SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, smxaaLevel.c_str());
logger << LOGGER_INFO << "MXAA set to " << mxaaLevel << "xMSAA" << LOGGER_ENDL; logger << LOGGER_INFO << "MXAA set to " << mxaaLevel << "xMSAA" << LOGGER_ENDL;
} else { } else {
logger << LOGGER_INFO << "MXAA disabled" << LOGGER_ENDL; logger << LOGGER_INFO << "MXAA disabled" << LOGGER_ENDL;
} }
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 4); SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 4);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 5); SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 5);
// Create GL window // Create GL window
logger << LOGGER_INFO << "Creating window" << LOGGER_ENDL; logger << LOGGER_INFO << "Creating window" << LOGGER_ENDL;
window = SDL_CreateWindow(name.c_str(), window = SDL_CreateWindow(name.c_str(),
SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
SDL_WINDOWPOS_CENTERED, w, h, SDL_WINDOWPOS_CENTERED, w, h,
SDL_WINDOW_OPENGL); SDL_WINDOW_OPENGL);
// Create GL context // Create GL context
logger << LOGGER_INFO << "Creating OpenGL context" << LOGGER_ENDL; logger << LOGGER_INFO << "Creating OpenGL context" << LOGGER_ENDL;
glContext = SDL_GL_CreateContext(window); glContext = SDL_GL_CreateContext(window);
// SDL_WarpMouseInWindow(window, w / 2, h / 2); // SDL_WarpMouseInWindow(window, w / 2, h / 2);
// SDL_SetRelativeMouseMode(SDL_TRUE); // SDL_SetRelativeMouseMode(SDL_TRUE);
// Set VSYNC swap interval // Set VSYNC swap interval
if (vsyncMode == VSYNC_DEFAULT || vsyncMode == VSYNC_ENABLED) { if (vsyncMode == VSYNC_DEFAULT || vsyncMode == VSYNC_ENABLED) {
SDL_GL_SetSwapInterval(1); SDL_GL_SetSwapInterval(1);
logger << LOGGER_INFO << "VSync enabled" << LOGGER_ENDL; logger << LOGGER_INFO << "VSync enabled" << LOGGER_ENDL;
} }
if (vsyncMode == VSYNC_DISABLED) { if (vsyncMode == VSYNC_DISABLED) {
SDL_GL_SetSwapInterval(0); SDL_GL_SetSwapInterval(0);
logger << LOGGER_INFO << "VSync disabled" << LOGGER_ENDL; logger << LOGGER_INFO << "VSync disabled" << LOGGER_ENDL;
} }
logger << LOGGER_INFO << "Display set up" << LOGGER_ENDL; logger << LOGGER_INFO << "Display set up" << LOGGER_ENDL;
// Load OpenGL // Load OpenGL
gladLoadGLLoader(SDL_GL_GetProcAddress); gladLoadGLLoader(SDL_GL_GetProcAddress);
glEnable(GL_MULTISAMPLE); glEnable(GL_MULTISAMPLE);
glEnable(GL_DEPTH_TEST); glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE); glEnable(GL_CULL_FACE);
glCullFace(GL_BACK); glCullFace(GL_BACK);
logger << LOGGER_INFO << "Loaded OpenGL" << LOGGER_ENDL; logger << LOGGER_INFO << "Loaded OpenGL" << LOGGER_ENDL;
logger << LOGGER_ENDL; logger << LOGGER_ENDL;
isClosed = false; isClosed = false;
} }
void Display::setName(std::string name) { void Display::setName(std::string name) {
SDL_SetWindowTitle(window, name.c_str()); SDL_SetWindowTitle(window, name.c_str());
} }
void Display::update() { void Display::update() {
SDL_GL_SwapWindow(window); SDL_GL_SwapWindow(window);
glClear(GL_DEPTH_BUFFER_BIT); glClear(GL_DEPTH_BUFFER_BIT);
const float clear[] = { 0.1f, 0.45f, 0.9f, 1.0f }; const float clear[] = { 0.1f, 0.45f, 0.9f, 1.0f };
glClearBufferfv(GL_COLOR, 0, clear); glClearBufferfv(GL_COLOR, 0, clear);
} }
Display::~Display() { Display::~Display() {
SDL_DestroyWindow(window); SDL_DestroyWindow(window);
} }

122
src/display.h → legacy/src/display.h
View File

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

3682
src/glad.cpp → legacy/src/glad.cpp
View File

File diff suppressed because it is too large Load Diff

72
legacy/src/main.cpp Normal file
View File

@@ -0,0 +1,72 @@
// 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"
#include "camera.h"
#include "shader.h"
#include "model.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_16X, VSYNC_ENABLED};
Camera camera;
camera.mouseSensitivity = 0.0012f;
camera.cameraSpeed = 1.0f;
Shader shader;
shader.load("./resources/shaders/phong").attatch().link().use();
Mesh mesh{ "./resources/lucy.obj" };
mesh.setup();
SDL_Event e;
while (!display.isClosed) {
camera.moveCamera();
while (SDL_PollEvent(&e)) {
if (e.type == SDL_QUIT)
display.isClosed = true;
//if (e.key.keysym.sym == SDLK_t) {
// SDL_SetRelativeMouseMode(SDL_GetRelativeMouseMode() == SDL_TRUE ? SDL_FALSE : SDL_TRUE);
//}
camera.handleMouse(e);
}
const Uint8* state = SDL_GetKeyboardState(NULL);
if (state[SDL_SCANCODE_Q]) {
mesh.rotation += -1.5f;
}
if (state[SDL_SCANCODE_E]) {
mesh.rotation += 1.5f;
}
mesh.bind();
mesh.render(shader, camera);
mesh.unbind();
display.update();
}
return 0;
}

86
src/material.cpp → legacy/src/material.cpp
View File

@@ -1,43 +1,43 @@
#include "material.h" #include "material.h"
Material::Material() { Material::Material() {
} }
Material::Material(std::string objPath) { Material::Material(std::string objPath) {
// Logger logger; // Logger logger;
// objl::Loader loader; // objl::Loader loader;
// bool canLoad = loader.LoadFile(objPath); // bool canLoad = loader.LoadFile(objPath);
// if (!canLoad) { // if (!canLoad) {
// logger << LOGGER_ERROR << "Cannot load material '" << objPath << "'" << LOGGER_ENDL; // logger << LOGGER_ERROR << "Cannot load material '" << objPath << "'" << LOGGER_ENDL;
// return; // return;
// } // }
// loadFromObj(loader.LoadedMeshes[0]); // loadFromObj(loader.LoadedMeshes[0]);
} }
// Material::Material(objl::Mesh objMesh) { // Material::Material(objl::Mesh objMesh) {
// loadFromObj(objMesh); // loadFromObj(objMesh);
// } // }
// void Material::loadFromObj(objl::Mesh objMesh) { // void Material::loadFromObj(objl::Mesh objMesh) {
// loadFromMat(objMesh.MeshMaterial); // loadFromMat(objMesh.MeshMaterial);
// } // }
// void Material::loadFromMat(objl::Material mat) { // void Material::loadFromMat(objl::Material mat) {
// this->name = mat.name; // this->name = mat.name;
// OBJLVec3toGLM(mat.Ka, this->Ka); // OBJLVec3toGLM(mat.Ka, this->Ka);
// OBJLVec3toGLM(mat.Kd, this->Kd); // OBJLVec3toGLM(mat.Kd, this->Kd);
// OBJLVec3toGLM(mat.Ks, this->Ks); // OBJLVec3toGLM(mat.Ks, this->Ks);
// this->Ns = mat.Ns; // this->Ns = mat.Ns;
// this->Ni = mat.Ni; // this->Ni = mat.Ni;
// this->d = mat.d; // this->d = mat.d;
// this->illum = mat.illum; // this->illum = mat.illum;
// this->map_Ka = mat.map_Ka; // this->map_Ka = mat.map_Ka;
// this->map_Kd = mat.map_Kd; // this->map_Kd = mat.map_Kd;
// this->map_Ks = mat.map_Ks; // this->map_Ks = mat.map_Ks;
// this->map_Ns = mat.map_Ns; // this->map_Ns = mat.map_Ns;
// this->map_d = mat.map_d; // this->map_d = mat.map_d;
// this->map_bump = mat.map_bump; // this->map_bump = mat.map_bump;
// } // }

112
src/material.h → legacy/src/material.h
View File

@@ -1,56 +1,56 @@
#ifndef SMHENGINE_SRC_MATERIAL_H_ #ifndef SMHENGINE_SRC_MATERIAL_H_
#define SMHENGINE_SRC_MATERIAL_H_ #define SMHENGINE_SRC_MATERIAL_H_
#include <string> #include <string>
#include <vector> #include <vector>
#include <glad/glad.hpp> #include <glad/glad.hpp>
#include <glm/glm.hpp> #include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp> #include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp> #include <glm/gtc/type_ptr.hpp>
#include <logger.h> #include <logger.h>
#include "./util/util.h" #include "./util/util.h"
class Material { class Material {
public: public:
Material(); Material();
Material(std::string objPath); Material(std::string objPath);
// Material(objl::Mesh objMesh); // Material(objl::Mesh objMesh);
// void loadFromObj(objl::Mesh objMesh); // void loadFromObj(objl::Mesh objMesh);
// void loadFromMat(objl::Material mat); // void loadFromMat(objl::Material mat);
// Material Name // Material Name
std::string name; std::string name;
// Ambient Color // Ambient Color
glm::vec3 Ka; glm::vec3 Ka;
// Diffuse Color // Diffuse Color
glm::vec3 Kd; glm::vec3 Kd;
// Specular Color // Specular Color
glm::vec3 Ks; glm::vec3 Ks;
// Specular Exponent // Specular Exponent
float Ns; float Ns;
// Optical Density // Optical Density
float Ni; float Ni;
// Dissolve // Dissolve
float d; float d;
// Illumination model 0->10 // Illumination model 0->10
// TODO: Make an enum for this // TODO: Make an enum for this
int illum; int illum;
// Ambient Texture Map // Ambient Texture Map
std::string map_Ka; std::string map_Ka;
// Diffuse Texture Map // Diffuse Texture Map
std::string map_Kd; std::string map_Kd;
// Specular Texture Map // Specular Texture Map
std::string map_Ks; std::string map_Ks;
// Specular Hightlight Map // Specular Hightlight Map
std::string map_Ns; std::string map_Ns;
// Alpha Texture Map // Alpha Texture Map
std::string map_d; std::string map_d;
// Bump Map // Bump Map
std::string map_bump; std::string map_bump;
}; };
#endif #endif

260
src/mesh.cpp → legacy/src/mesh.cpp
View File

@@ -1,130 +1,130 @@
#include "mesh.h" #include "mesh.h"
#include "camera.h" #include "camera.h"
Mesh::Mesh() { Mesh::Mesh() {
} }
Mesh::Mesh(std::string objPath) { Mesh::Mesh(std::string objPath) {
Logger logger; Logger logger;
ObjLMesh mesh; ObjLMesh mesh;
std::string warn, err; std::string warn, err;
bool canLoad = tinyobj::LoadObj(&mesh.attrib, &mesh.shapes, &mesh.materials, &warn, &err, objPath.c_str()); bool canLoad = tinyobj::LoadObj(&mesh.attrib, &mesh.shapes, &mesh.materials, &warn, &err, objPath.c_str());
if (!err.empty() || !canLoad) { if (!err.empty() || !canLoad) {
logger << LOGGER_ERROR << "Cannot load obj '" << objPath << "': " << err << LOGGER_ENDL; logger << LOGGER_ERROR << "Cannot load obj '" << objPath << "': " << err << LOGGER_ENDL;
return; return;
} }
if (!warn.empty()) { if (!warn.empty()) {
logger << LOGGER_WARN << "Warning from obj loader while loading obj '" << objPath << "': " << warn << LOGGER_ENDL; logger << LOGGER_WARN << "Warning from obj loader while loading obj '" << objPath << "': " << warn << LOGGER_ENDL;
} }
logger << LOGGER_INFO << "Loaded: " << objPath << LOGGER_ENDL; logger << LOGGER_INFO << "Loaded: " << objPath << LOGGER_ENDL;
loadFromObj(mesh); loadFromObj(mesh);
} }
Mesh::Mesh(ObjLMesh mesh) { Mesh::Mesh(ObjLMesh mesh) {
// loadFromObj(objMesh); // loadFromObj(objMesh);
} }
void Mesh::loadFromObj(ObjLMesh mesh) { void Mesh::loadFromObj(ObjLMesh mesh) {
OBJLtoGLM(mesh, vertices, normals, texCoords, indices); OBJLtoGLM(mesh, vertices, normals, texCoords, indices);
// OBJLtoIndices(mesh, indices);E // OBJLtoIndices(mesh, indices);E
//Logger logger; //Logger logger;
//for (int i = 0; i < 100; i++) { //for (int i = 0; i < 100; i++) {
// logger << LOGGER_DEBUG << normals[i].x << " " << normals[i].y << " " << normals[i].z << LOGGER_ENDL; // logger << LOGGER_DEBUG << normals[i].x << " " << normals[i].y << " " << normals[i].z << LOGGER_ENDL;
//} //}
} }
void Mesh::setup() { void Mesh::setup() {
Logger logger; Logger logger;
glGenVertexArrays(1, &VAOid); glGenVertexArrays(1, &VAOid);
glGenBuffers(1, &vertexBuffer); glGenBuffers(1, &vertexBuffer);
glGenBuffers(1, &indexBuffer); glGenBuffers(1, &indexBuffer);
glBindVertexArray(VAOid); glBindVertexArray(VAOid);
glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer); glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer);
std::vector<glm::vec3> toGpu; std::vector<glm::vec3> toGpu;
toGpu.insert(toGpu.end(), vertices.begin(), vertices.end()); toGpu.insert(toGpu.end(), vertices.begin(), vertices.end());
toGpu.insert(toGpu.end(), normals.begin(), normals.end()); toGpu.insert(toGpu.end(), normals.begin(), normals.end());
toGpu.insert(toGpu.end(), texCoords.begin(), texCoords.end()); toGpu.insert(toGpu.end(), texCoords.begin(), texCoords.end());
glBufferData(GL_ARRAY_BUFFER, toGpu.size() * sizeof(glm::vec3), glBufferData(GL_ARRAY_BUFFER, toGpu.size() * sizeof(glm::vec3),
&toGpu[0], GL_STATIC_DRAW); &toGpu[0], GL_STATIC_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBuffer); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBuffer);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices.size() * sizeof(GLuint), glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices.size() * sizeof(GLuint),
&indices[0], GL_STATIC_DRAW); &indices[0], GL_STATIC_DRAW);
// Positions // Positions
glEnableVertexAttribArray(0); glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0,
(const void*)0); (const void*)0);
// Normals // Normals
glEnableVertexAttribArray(1); glEnableVertexAttribArray(1);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0,
(const void*)(vertices.size() * sizeof(glm::vec3))); (const void*)(vertices.size() * sizeof(glm::vec3)));
// TexCoords // TexCoords
glEnableVertexAttribArray(2); glEnableVertexAttribArray(2);
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 0, glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 0,
(const void*)((vertices.size() + texCoords.size()) * sizeof(glm::vec3))); (const void*)((vertices.size() + texCoords.size()) * sizeof(glm::vec3)));
logger << LOGGER_INFO << "Mesh setup" << LOGGER_ENDL; logger << LOGGER_INFO << "Mesh setup" << LOGGER_ENDL;
glBindVertexArray(0); glBindVertexArray(0);
} }
void Mesh::bind() { void Mesh::bind() {
glBindVertexArray(VAOid); glBindVertexArray(VAOid);
} }
void Mesh::render(Shader& shader, Camera& camera) { void Mesh::render(Shader& shader, Camera& camera) {
// Model matrice // Model matrice
glm::mat4 model = glm::mat4(1.0f); glm::mat4 model = glm::mat4(1.0f);
model = glm::translate(model, { -170.0f, -170.0f, -170.0f }); model = glm::translate(model, { -170.0f, -170.0f, -170.0f });
model = glm::rotate(model, glm::radians(-160.0f + this->rotation), glm::vec3(0.0f, 1.0f, 0.0f)); model = glm::rotate(model, glm::radians(-160.0f + this->rotation), glm::vec3(0.0f, 1.0f, 0.0f));
GLint uniTrans = glGetUniformLocation(shader.getProgram(), "model"); GLint uniTrans = glGetUniformLocation(shader.getProgram(), "model");
glUniformMatrix4fv(uniTrans, 1, GL_FALSE, glm::value_ptr(model)); glUniformMatrix4fv(uniTrans, 1, GL_FALSE, glm::value_ptr(model));
// // View matrice // // View matrice
// glm::mat4 view = glm::lookAt( // glm::mat4 view = glm::lookAt(
// glm::vec3(1.0f, 1.0f, 1.0f), // glm::vec3(1.0f, 1.0f, 1.0f),
// glm::vec3(0.0f, 0.4f, 0.0f), // glm::vec3(0.0f, 0.4f, 0.0f),
// glm::vec3(0.0f, 1.0f, 0.0f) // glm::vec3(0.0f, 1.0f, 0.0f)
// ); // );
// Get uniform and send it to the GPU // Get uniform and send it to the GPU
GLint uniView = glGetUniformLocation(shader.getProgram(), "view"); GLint uniView = glGetUniformLocation(shader.getProgram(), "view");
glUniformMatrix4fv(uniView, 1, GL_FALSE, glm::value_ptr(camera.getViewMatrix())); glUniformMatrix4fv(uniView, 1, GL_FALSE, glm::value_ptr(camera.getViewMatrix()));
// Projection matrice // Projection matrice
glm::mat4 proj = glm::perspective(glm::radians(45.0f), 1280.0f / 720.0f, 1.0f, 1000.0f); glm::mat4 proj = glm::perspective(glm::radians(45.0f), 1280.0f / 720.0f, 1.0f, 1000.0f);
// Get uniform and send it to the GPU // Get uniform and send it to the GPU
GLint uniProj = glGetUniformLocation(shader.getProgram(), "proj"); GLint uniProj = glGetUniformLocation(shader.getProgram(), "proj");
glUniformMatrix4fv(uniProj, 1, GL_FALSE, glm::value_ptr(proj)); glUniformMatrix4fv(uniProj, 1, GL_FALSE, glm::value_ptr(proj));
glm::vec3 lightPos = { -270.0f, -270.0f, -1.0f }; glm::vec3 lightPos = { -270.0f, -270.0f, -1.0f };
GLint uniLight = glGetUniformLocation(shader.getProgram(), "lightPos"); GLint uniLight = glGetUniformLocation(shader.getProgram(), "lightPos");
glUniformMatrix3fv(uniLight, 1, GL_FALSE, glm::value_ptr(lightPos)); glUniformMatrix3fv(uniLight, 1, GL_FALSE, glm::value_ptr(lightPos));
GLint uniCamPos = glGetUniformLocation(shader.getProgram(), "viewPos"); GLint uniCamPos = glGetUniformLocation(shader.getProgram(), "viewPos");
glUniformMatrix3fv(uniLight, 1, GL_FALSE, glm::value_ptr(camera.getPos())); glUniformMatrix3fv(uniLight, 1, GL_FALSE, glm::value_ptr(camera.getPos()));
glDrawElements(GL_TRIANGLES, indices.size(), GL_UNSIGNED_INT, 0); glDrawElements(GL_TRIANGLES, indices.size(), GL_UNSIGNED_INT, 0);
} }
void Mesh::unbind() { void Mesh::unbind() {
glBindVertexArray(0); glBindVertexArray(0);
} }

136
src/mesh.h → legacy/src/mesh.h
View File

@@ -1,68 +1,68 @@
#ifndef SMHENGINE_SRC_MESH_H_ #ifndef SMHENGINE_SRC_MESH_H_
#define SMHENGINE_SRC_MESH_H_ #define SMHENGINE_SRC_MESH_H_
#include <string> #include <string>
#include <vector> #include <vector>
#include <glad/glad.hpp> #include <glad/glad.hpp>
#include <glm/glm.hpp> #include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp> #include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp> #include <glm/gtc/type_ptr.hpp>
#include <tiny_obj_loader.h> #include <tiny_obj_loader.h>
#include <logger.h> #include <logger.h>
#include "shader.h" #include "shader.h"
#include "./util/util.h" #include "./util/util.h"
class Camera; class Camera;
// Not in use yet // Not in use yet
// Will be used as a vector, enabling // Will be used as a vector, enabling
// the use of strides when sending the // the use of strides when sending the
// vertex data to the GPU // vertex data to the GPU
struct Vertex { struct Vertex {
glm::vec3 vertice; glm::vec3 vertice;
glm::vec3 normal; glm::vec3 normal;
glm::vec2 texCoord; glm::vec2 texCoord;
}; };
// For easy passing around of the tinyobj // For easy passing around of the tinyobj
// mesh structures // mesh structures
struct ObjLMesh { struct ObjLMesh {
tinyobj::attrib_t attrib; tinyobj::attrib_t attrib;
std::vector<tinyobj::shape_t> shapes; std::vector<tinyobj::shape_t> shapes;
std::vector<tinyobj::material_t> materials; std::vector<tinyobj::material_t> materials;
}; };
class Mesh { class Mesh {
public: public:
Mesh(); Mesh();
Mesh(std::string objPath); Mesh(std::string objPath);
Mesh(ObjLMesh mesh); Mesh(ObjLMesh mesh);
void loadFromObj(ObjLMesh mesh); void loadFromObj(ObjLMesh mesh);
void setup(); void setup();
void bind(); void bind();
void render(Shader& shader, Camera& camera); void render(Shader& shader, Camera& camera);
static void unbind(); static void unbind();
GLuint VAOid; GLuint VAOid;
std::string name; std::string name;
std::vector<glm::vec3> vertices; std::vector<glm::vec3> vertices;
std::vector<glm::vec3> normals; std::vector<glm::vec3> normals;
// This is a vec3 so it can all pop into // This is a vec3 so it can all pop into
//one buffer :) //one buffer :)
std::vector<glm::vec3> texCoords; std::vector<glm::vec3> texCoords;
std::vector<unsigned int> indices; std::vector<unsigned int> indices;
float rotation = 0.0f; float rotation = 0.0f;
private: private:
GLuint vertexBuffer; GLuint vertexBuffer;
GLuint indexBuffer; GLuint indexBuffer;
}; };
#endif #endif

6
src/model.cpp → legacy/src/model.cpp
View File

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

52
src/model.h → legacy/src/model.h
View File

@@ -1,26 +1,26 @@
#ifndef SMHENGINE_SRC_MODEL_H_ #ifndef SMHENGINE_SRC_MODEL_H_
#define SMHENGINE_SRC_MODEL_H_ #define SMHENGINE_SRC_MODEL_H_
#include <string> #include <string>
#include <vector> #include <vector>
#include <glad/glad.hpp> #include <glad/glad.hpp>
#include <glm/glm.hpp> #include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp> #include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp> #include <glm/gtc/type_ptr.hpp>
#include <logger.h> #include <logger.h>
#include "mesh.h" #include "mesh.h"
#include "material.h" #include "material.h"
class Model { class Model {
public: public:
Model(); Model();
Model(std::string loadPath); Model(std::string loadPath);
std::vector<std::pair<Mesh, Material>> modelData; std::vector<std::pair<Mesh, Material>> modelData;
}; };
#endif #endif

56
src/object.h → legacy/src/object.h
View File

@@ -1,28 +1,28 @@
#ifndef SMHENGINE_SRC_OBJECT_H_ #ifndef SMHENGINE_SRC_OBJECT_H_
#define SMHENGINE_SRC_OBJECT_H_ #define SMHENGINE_SRC_OBJECT_H_
#include <string> #include <string>
#include <vector> #include <vector>
#include <glad/glad.hpp> #include <glad/glad.hpp>
#include <glm/glm.hpp> #include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp> #include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp> #include <glm/gtc/type_ptr.hpp>
#include <OBJLoader.h> #include <OBJLoader.h>
#include <logger.h> #include <logger.h>
#include "model.h" #include "model.h"
#include "shader.h" #include "shader.h"
class Object { class Object {
public: public:
Object(); Object();
std::vector<Model> models; std::vector<Model> models;
std::vector<Shader> shaders; std::vector<Shader> shaders;
}; };
#endif #endif

0
src/renderer.cpp → legacy/src/renderer.cpp
View File

0
src/renderer.h → legacy/src/renderer.h
View File

336
src/shader.cpp → legacy/src/shader.cpp
View File

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

84
src/shader.h → legacy/src/shader.h
View File

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

0
src/shaderManager.cpp → legacy/src/shaderManager.cpp
View File

0
src/shaderManager.h → legacy/src/shaderManager.h
View File

4
src/tiny_obj_loader.cpp → legacy/src/tiny_obj_loader.cpp
View File

@@ -1,2 +1,2 @@
#define TINYOBJLOADER_IMPLEMENTATION // define this in only *one* .cc #define TINYOBJLOADER_IMPLEMENTATION // define this in only *one* .cc
#include "tiny_obj_loader.h" #include "tiny_obj_loader.h"

158
src/util/util.cpp → legacy/src/util/util.cpp
View File

@@ -1,79 +1,79 @@
#include "util.h" #include "util.h"
#include <unordered_map> #include <unordered_map>
#include <logger.h> #include <logger.h>
#include "../mesh.h" #include "../mesh.h"
void OBJLtoGLM(ObjLMesh& mesh, void OBJLtoGLM(ObjLMesh& mesh,
std::vector<glm::vec3>& outVert, std::vector<glm::vec3>& outVert,
std::vector<glm::vec3>& outNorm, std::vector<glm::vec3>& outNorm,
std::vector<glm::vec3>& outTexCoord, std::vector<glm::vec3>& outTexCoord,
std::vector<GLuint>& outIndices) { std::vector<GLuint>& outIndices) {
std::unordered_map<glm::vec3, uint64_t> uniqueVertices {{{1.0f, 1.0f, 1.0f}, 1}}; std::unordered_map<glm::vec3, uint64_t> uniqueVertices {{{1.0f, 1.0f, 1.0f}, 1}};
for (const auto &shape : mesh.shapes) { for (const auto &shape : mesh.shapes) {
for (const auto& index : shape.mesh.indices) { for (const auto& index : shape.mesh.indices) {
glm::vec3 vertex { glm::vec3 vertex {
mesh.attrib.vertices[3 * index.vertex_index + 0], mesh.attrib.vertices[3 * index.vertex_index + 0],
mesh.attrib.vertices[3 * index.vertex_index + 1], mesh.attrib.vertices[3 * index.vertex_index + 1],
mesh.attrib.vertices[3 * index.vertex_index + 2] mesh.attrib.vertices[3 * index.vertex_index + 2]
}; };
// outNorm.push_back({ // outNorm.push_back({
// mesh.attrib.normals[3 * index.normal_index + 0], // mesh.attrib.normals[3 * index.normal_index + 0],
// mesh.attrib.normals[3 * index.normal_index + 1], // mesh.attrib.normals[3 * index.normal_index + 1],
// mesh.attrib.normals[3 * index.normal_index + 2] // mesh.attrib.normals[3 * index.normal_index + 2]
// }); // });
// outTexCoord.push_back({ // outTexCoord.push_back({
// mesh.attrib.texcoords[2 * index.texcoord_index + 0], // mesh.attrib.texcoords[2 * index.texcoord_index + 0],
// mesh.attrib.texcoords[2 * index.texcoord_index + 1], // mesh.attrib.texcoords[2 * index.texcoord_index + 1],
// 0.0f // 0.0f
// }); // });
if (uniqueVertices.count(vertex) == 0) { if (uniqueVertices.count(vertex) == 0) {
uniqueVertices[vertex] = static_cast<uint32_t>(outVert.size()); uniqueVertices[vertex] = static_cast<uint32_t>(outVert.size());
outVert.push_back(vertex); outVert.push_back(vertex);
} }
outIndices.push_back(uniqueVertices[vertex]); outIndices.push_back(uniqueVertices[vertex]);
} }
} }
ComputeNormals(outNorm, outVert, outIndices); ComputeNormals(outNorm, outVert, outIndices);
} }
void ComputeNormals(std::vector<glm::vec3>& normals, void ComputeNormals(std::vector<glm::vec3>& normals,
std::vector<glm::vec3>& vertices, std::vector<glm::vec3>& vertices,
std::vector<GLuint>& elements) { std::vector<GLuint>& elements) {
normals.resize(vertices.size(), glm::vec3(0.0, 0.0, 0.0)); normals.resize(vertices.size(), glm::vec3(0.0, 0.0, 0.0));
for (int i = 0; i < elements.size(); i += 3) { for (int i = 0; i < elements.size(); i += 3) {
GLushort ia = elements[i]; GLushort ia = elements[i];
GLushort ib = elements[i+1]; GLushort ib = elements[i+1];
GLushort ic = elements[i+2]; GLushort ic = elements[i+2];
glm::vec3 normal = glm::normalize(glm::cross( glm::vec3 normal = glm::normalize(glm::cross(
glm::vec3(vertices[ib]) - glm::vec3(vertices[ia]), glm::vec3(vertices[ib]) - glm::vec3(vertices[ia]),
glm::vec3(vertices[ic]) - glm::vec3(vertices[ia]))); glm::vec3(vertices[ic]) - glm::vec3(vertices[ia])));
normals[ia] = normals[ib] = normals[ic] = normal; normals[ia] = normals[ib] = normals[ic] = normal;
} }
} }
void UintToGLuint(ObjLMesh& mesh, void UintToGLuint(ObjLMesh& mesh,
std::vector<GLuint>& outIndices) { std::vector<GLuint>& outIndices) {
} }
// void OBJLVec3toGLM(objl::Vector3& inVec, glm::vec3& outVec) { // void OBJLVec3toGLM(objl::Vector3& inVec, glm::vec3& outVec) {
// outVec.x = inVec.X; // outVec.x = inVec.X;
// outVec.y = inVec.Y; // outVec.y = inVec.Y;
// outVec.z = inVec.Z; // outVec.z = inVec.Z;
// } // }

68
src/util/util.h → legacy/src/util/util.h
View File

@@ -1,34 +1,34 @@
#ifndef SMHENGINE_SRC_UTIL_UTIL_H_ #ifndef SMHENGINE_SRC_UTIL_UTIL_H_
#define SMHENGINE_SRC_UTIL_UTUL_H_ #define SMHENGINE_SRC_UTIL_UTUL_H_
#include <glad/glad.hpp> #include <glad/glad.hpp>
// This is so that i can use // This is so that i can use
// glm::vec3 inside of an // glm::vec3 inside of an
// std::unordered_map as it's // std::unordered_map as it's
// experimental for some reason // experimental for some reason
// smh // smh
#define GLM_ENABLE_EXPERIMENTAL #define GLM_ENABLE_EXPERIMENTAL
#include <glm/gtx/hash.hpp> #include <glm/gtx/hash.hpp>
#include <glm/glm.hpp> #include <glm/glm.hpp>
#include <vector> #include <vector>
#include <tiny_obj_loader.h> #include <tiny_obj_loader.h>
struct ObjLMesh; struct ObjLMesh;
void OBJLtoGLM(ObjLMesh& mesh, void OBJLtoGLM(ObjLMesh& mesh,
std::vector<glm::vec3>& outVert, std::vector<glm::vec3>& outVert,
std::vector<glm::vec3>& outNorm, std::vector<glm::vec3>& outNorm,
std::vector<glm::vec3>& outTexCoord, std::vector<glm::vec3>& outTexCoord,
std::vector<GLuint>& outIndices); std::vector<GLuint>& outIndices);
void ComputeNormals(std::vector<glm::vec3>& normals, void ComputeNormals(std::vector<glm::vec3>& normals,
std::vector<glm::vec3>& vertices, std::vector<glm::vec3>& vertices,
std::vector<GLuint>& elements); std::vector<GLuint>& elements);
void UintToGLuint(ObjLMesh& mesh, void UintToGLuint(ObjLMesh& mesh,
std::vector<GLuint>& outIndices); std::vector<GLuint>& outIndices);
// void OBJLVec3toGLM(objl::Vector3& inVec, glm::vec3& outVec); // void OBJLVec3toGLM(objl::Vector3& inVec, glm::vec3& outVec);
#endif #endif

72
src/main.cpp
View File

@@ -1,72 +1,6 @@
// General includes #include <iostream>
#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"
#include "camera.h"
#include "shader.h"
#include "model.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_16X, VSYNC_ENABLED};
Camera camera;
camera.mouseSensitivity = 0.0012f;
camera.cameraSpeed = 1.0f;
Shader shader;
shader.load("./resources/shaders/phong").attatch().link().use();
Mesh mesh{ "./resources/lucy.obj" };
mesh.setup();
SDL_Event e;
while (!display.isClosed) {
camera.moveCamera();
while (SDL_PollEvent(&e)) {
if (e.type == SDL_QUIT)
display.isClosed = true;
//if (e.key.keysym.sym == SDLK_t) {
// SDL_SetRelativeMouseMode(SDL_GetRelativeMouseMode() == SDL_TRUE ? SDL_FALSE : SDL_TRUE);
//}
camera.handleMouse(e);
}
const Uint8* state = SDL_GetKeyboardState(NULL);
if (state[SDL_SCANCODE_Q]) {
mesh.rotation += -1.5f;
}
if (state[SDL_SCANCODE_E]) {
mesh.rotation += 1.5f;
}
mesh.bind();
mesh.render(shader, camera);
mesh.unbind();
display.update();
}
int main(int argc, char** argv) {
std::cout << "bruh" << std::endl;
return 0; return 0;
} }