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

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

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

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

@@ -1,33 +1,33 @@
#ifndef SRC_OBJECT_H_
#define SRC_OBJECT_H_
// General includes
#include <vector>
// GL includes
#include <glad/glad.hpp>
#if _WIN32
#include <SDL.h>
#else
#include <SDL2/SDL.h>
#endif
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>
// Custom includes
#include <logger.h>
void LoadOBJ(Logger& logger,
std::string file,
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);
#endif
#ifndef SRC_OBJECT_H_
#define SRC_OBJECT_H_
// General includes
#include <vector>
// GL includes
#include <glad/glad.hpp>
#if _WIN32
#include <SDL.h>
#else
#include <SDL2/SDL.h>
#endif
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>
// Custom includes
#include <logger.h>
void LoadOBJ(Logger& logger,
std::string file,
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);
#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
in vec3 Normal;
in vec3 FragPos;
// in vec4 FragPosLightSpace;
uniform vec3 lightPos;
out vec4 outColour;
vec3 viewPos = vec3(0.0, 0.0, 0.0);
vec3 objectColour = vec3(1.0, 1.0, 1.0);
vec3 lightColour = vec3(0.7, 0.0, 0.65);
// vec3 lightColour = vec3(0.3, 0.85, 1.0);
void main() {
vec3 normal = normalize(Normal);
vec3 lightDir = normalize(lightPos - FragPos);
float diff = max(dot(normal, lightDir), 0.0);
vec3 diffuse = diff * lightColour;
float specularStrength = 0;
vec3 viewDir = normalize(viewPos - FragPos);
vec3 reflectDir = reflect(-lightDir, normal);
float spec = pow(max(dot(viewDir, reflectDir), 0.0), 32);
vec3 specular = specularStrength * spec * lightColour;
float ambientStrength = 0.4;
vec3 ambient = ambientStrength * lightColour;
vec3 result = (ambient + diffuse + specular) * objectColour;
outColour = vec4(result, 1.0);
}
#version 330
in vec3 Normal;
in vec3 FragPos;
// in vec4 FragPosLightSpace;
uniform vec3 lightPos;
out vec4 outColour;
vec3 viewPos = vec3(0.0, 0.0, 0.0);
vec3 objectColour = vec3(1.0, 1.0, 1.0);
vec3 lightColour = vec3(0.7, 0.0, 0.65);
// vec3 lightColour = vec3(0.3, 0.85, 1.0);
void main() {
vec3 normal = normalize(Normal);
vec3 lightDir = normalize(lightPos - FragPos);
float diff = max(dot(normal, lightDir), 0.0);
vec3 diffuse = diff * lightColour;
float specularStrength = 0;
vec3 viewDir = normalize(viewPos - FragPos);
vec3 reflectDir = reflect(-lightDir, normal);
float spec = pow(max(dot(viewDir, reflectDir), 0.0), 32);
vec3 specular = specularStrength * spec * lightColour;
float ambientStrength = 0.4;
vec3 ambient = ambientStrength * lightColour;
vec3 result = (ambient + diffuse + specular) * objectColour;
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
layout(location = 0) in vec3 position;
layout(location = 1) in vec3 normal;
layout(location = 2) in vec3 texCoord;
out vec3 Normal;
out vec3 FragPos;
uniform mat4 model;
uniform mat4 view;
uniform mat4 proj;
void main() {
gl_Position = proj * view * model * vec4(position, 1.0);
FragPos = vec3(model * vec4(position, 1.0));
Normal = mat3(model) * normal;
}
#version 330
layout(location = 0) in vec3 position;
layout(location = 1) in vec3 normal;
layout(location = 2) in vec3 texCoord;
out vec3 Normal;
out vec3 FragPos;
uniform mat4 model;
uniform mat4 view;
uniform mat4 proj;
void main() {
gl_Position = proj * view * model * vec4(position, 1.0);
FragPos = vec3(model * vec4(position, 1.0));
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
out float fragdepth;
void main(){
gl_FragDepth = gl_FragCoord.z;
}
#version 330
out float fragdepth;
void main(){
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
in vec3 vertPos;
uniform mat4 lightSpaceMatrix;
uniform mat4 model;
void main() {
gl_Position = lightSpaceMatrix * model * vec4(vertPos, 1.0);
}
#version 330
in vec3 vertPos;
uniform mat4 lightSpaceMatrix;
uniform mat4 model;
void main() {
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
out vec4 outColour;
void main() {
outColour = vec4(0.58, 0.61, 0.627, 1.0);
}
#version 330
out vec4 outColour;
void main() {
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
in vec3 position;
uniform mat4 model;
uniform mat4 view;
uniform mat4 proj;
void main() {
gl_Position = proj * view * model * vec4(position, 1.0);
}
#version 330
in vec3 position;
uniform mat4 model;
uniform mat4 view;
uniform mat4 proj;
void main() {
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 <iostream>
#include <fstream>
Shader::Shader(Logger& logger)
: logger(logger) {
m_program = glCreateProgram();
}
Shader& Shader::use() {
glUseProgram(m_program);
return *this;
}
Shader& Shader::link() {
glLinkProgram(m_program);
return *this;
}
Shader& Shader::attatch() {
glAttachShader(m_program, m_vert);
glAttachShader(m_program, m_frag);
return *this;
}
std::string readShader(std::string source) {
std::ifstream t(source);
std::string shaderCode((std::istreambuf_iterator<char>(t)),
std::istreambuf_iterator<char>());
return shaderCode;
}
Shader& Shader::load(GLenum type, std::string sourceLoc) {
const char* source = readShader(sourceLoc).c_str();
if (type == GL_VERTEX_SHADER) {
m_vertLoc = sourceLoc;
m_vertSource = (std::string)source;
m_vert = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(m_vert, 1, &source, NULL);
glCompileShader(m_vert);
glGetShaderiv(m_vert, GL_COMPILE_STATUS, &m_status);
if (m_status == GL_FALSE) {
char buf[512];
glGetShaderInfoLog(m_vert, 512, NULL, buf);
logger << LOGGER_ERROR << buf << LOGGER_ENDL;
}
logger << LOGGER_INFO << "Vertex shader at '" << sourceLoc << "' compiled..." << LOGGER_ENDL;
} else if (type == GL_FRAGMENT_SHADER) {
m_fragLoc = sourceLoc;
m_fragSource = (std::string)source;
m_frag = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(m_frag, 1, &source, NULL);
glCompileShader(m_frag);
glGetShaderiv(m_frag, GL_COMPILE_STATUS, &m_status);
if (m_status == GL_FALSE) {
char buf[512];
glGetShaderInfoLog(m_frag, 512, NULL, buf);
logger << LOGGER_ERROR << buf << LOGGER_ENDL;
}
logger << LOGGER_INFO << "Vertex shader at '" << sourceLoc << "' compiled..." << LOGGER_ENDL;
}
return *this;
}
Shader& Shader::load(std::string sourceLoc) {
m_vertLoc = sourceLoc + ".vert";
m_fragLoc = sourceLoc + ".frag";
m_vertSource = readShader(m_vertLoc);
m_fragSource = readShader(m_fragLoc);
m_vert = glCreateShader(GL_VERTEX_SHADER);
m_frag = glCreateShader(GL_FRAGMENT_SHADER);
const char* vertSource = m_vertSource.c_str();
glShaderSource(m_vert, 1, &vertSource, NULL);
glCompileShader(m_vert);
const char* fragSource = m_fragSource.c_str();
glShaderSource(m_frag, 1, &fragSource, NULL);
glCompileShader(m_frag);
glGetShaderiv(m_vert, GL_COMPILE_STATUS, &m_status);
if (m_status == GL_FALSE) {
char buf[512];
glGetShaderInfoLog(m_vert, 512, NULL, buf);
logger << LOGGER_ERROR << buf << LOGGER_ENDL;
}
glGetShaderiv(m_frag, GL_COMPILE_STATUS, &m_status);
if (m_status == GL_FALSE) {
char buf[512];
glGetShaderInfoLog(m_frag, 512, NULL, buf);
logger << LOGGER_ERROR << buf << LOGGER_ENDL;
}
logger << LOGGER_INFO << "Vertex shader at '" << m_vertLoc << "' compiled..." << LOGGER_ENDL;
logger << LOGGER_INFO << "Fragment shader at '" << m_fragLoc << "' compiled..." << LOGGER_ENDL;
return *this;
}
Shader& Shader::reload() {
glDeleteProgram(m_program);
glDeleteShader(m_vert);
glDeleteShader(m_frag);
m_vertSource = readShader(m_vertLoc);
m_fragSource = readShader(m_fragLoc);
m_vert = glCreateShader(GL_VERTEX_SHADER);
m_frag = glCreateShader(GL_FRAGMENT_SHADER);
const char* vertSource = m_vertSource.c_str();
glShaderSource(m_vert, 1, &vertSource, NULL);
glCompileShader(m_vert);
const char* fragSource = m_fragSource.c_str();
glShaderSource(m_frag, 1, &fragSource, NULL);
glCompileShader(m_frag);
glGetShaderiv(m_vert, GL_COMPILE_STATUS, &m_status);
if (m_status == GL_FALSE) {
char buf[512];
glGetShaderInfoLog(m_vert, 512, NULL, buf);
logger << LOGGER_ERROR << buf << LOGGER_ENDL;
}
glGetShaderiv(m_frag, GL_COMPILE_STATUS, &m_status);
if (m_status == GL_FALSE) {
char buf[512];
glGetShaderInfoLog(m_frag, 512, NULL, buf);
logger << LOGGER_ERROR << buf << LOGGER_ENDL;
}
logger << LOGGER_INFO << "Vertex shader at '" << m_vertLoc << "' compiled..." << LOGGER_ENDL;
logger << LOGGER_INFO << "Fragment shader at '" << m_fragLoc << "' compiled..." << LOGGER_ENDL;
link();
attatch();
return *this;
}
GLuint Shader::getProgram() {
return m_program;
}
GLuint Shader::getVertex() {
return m_vert;
}
GLuint Shader::getFragment() {
return m_frag;
}
Shader::~Shader() {
glDeleteProgram(m_program);
glDeleteShader(m_vert);
glDeleteShader(m_frag);
}
#include "shader.h"
#include <iostream>
#include <fstream>
Shader::Shader(Logger& logger)
: logger(logger) {
m_program = glCreateProgram();
}
Shader& Shader::use() {
glUseProgram(m_program);
return *this;
}
Shader& Shader::link() {
glLinkProgram(m_program);
return *this;
}
Shader& Shader::attatch() {
glAttachShader(m_program, m_vert);
glAttachShader(m_program, m_frag);
return *this;
}
std::string readShader(std::string source) {
std::ifstream t(source);
std::string shaderCode((std::istreambuf_iterator<char>(t)),
std::istreambuf_iterator<char>());
return shaderCode;
}
Shader& Shader::load(GLenum type, std::string sourceLoc) {
const char* source = readShader(sourceLoc).c_str();
if (type == GL_VERTEX_SHADER) {
m_vertLoc = sourceLoc;
m_vertSource = (std::string)source;
m_vert = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(m_vert, 1, &source, NULL);
glCompileShader(m_vert);
glGetShaderiv(m_vert, GL_COMPILE_STATUS, &m_status);
if (m_status == GL_FALSE) {
char buf[512];
glGetShaderInfoLog(m_vert, 512, NULL, buf);
logger << LOGGER_ERROR << buf << LOGGER_ENDL;
}
logger << LOGGER_INFO << "Vertex shader at '" << sourceLoc << "' compiled..." << LOGGER_ENDL;
} else if (type == GL_FRAGMENT_SHADER) {
m_fragLoc = sourceLoc;
m_fragSource = (std::string)source;
m_frag = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(m_frag, 1, &source, NULL);
glCompileShader(m_frag);
glGetShaderiv(m_frag, GL_COMPILE_STATUS, &m_status);
if (m_status == GL_FALSE) {
char buf[512];
glGetShaderInfoLog(m_frag, 512, NULL, buf);
logger << LOGGER_ERROR << buf << LOGGER_ENDL;
}
logger << LOGGER_INFO << "Vertex shader at '" << sourceLoc << "' compiled..." << LOGGER_ENDL;
}
return *this;
}
Shader& Shader::load(std::string sourceLoc) {
m_vertLoc = sourceLoc + ".vert";
m_fragLoc = sourceLoc + ".frag";
m_vertSource = readShader(m_vertLoc);
m_fragSource = readShader(m_fragLoc);
m_vert = glCreateShader(GL_VERTEX_SHADER);
m_frag = glCreateShader(GL_FRAGMENT_SHADER);
const char* vertSource = m_vertSource.c_str();
glShaderSource(m_vert, 1, &vertSource, NULL);
glCompileShader(m_vert);
const char* fragSource = m_fragSource.c_str();
glShaderSource(m_frag, 1, &fragSource, NULL);
glCompileShader(m_frag);
glGetShaderiv(m_vert, GL_COMPILE_STATUS, &m_status);
if (m_status == GL_FALSE) {
char buf[512];
glGetShaderInfoLog(m_vert, 512, NULL, buf);
logger << LOGGER_ERROR << buf << LOGGER_ENDL;
}
glGetShaderiv(m_frag, GL_COMPILE_STATUS, &m_status);
if (m_status == GL_FALSE) {
char buf[512];
glGetShaderInfoLog(m_frag, 512, NULL, buf);
logger << LOGGER_ERROR << buf << LOGGER_ENDL;
}
logger << LOGGER_INFO << "Vertex shader at '" << m_vertLoc << "' compiled..." << LOGGER_ENDL;
logger << LOGGER_INFO << "Fragment shader at '" << m_fragLoc << "' compiled..." << LOGGER_ENDL;
return *this;
}
Shader& Shader::reload() {
glDeleteProgram(m_program);
glDeleteShader(m_vert);
glDeleteShader(m_frag);
m_vertSource = readShader(m_vertLoc);
m_fragSource = readShader(m_fragLoc);
m_vert = glCreateShader(GL_VERTEX_SHADER);
m_frag = glCreateShader(GL_FRAGMENT_SHADER);
const char* vertSource = m_vertSource.c_str();
glShaderSource(m_vert, 1, &vertSource, NULL);
glCompileShader(m_vert);
const char* fragSource = m_fragSource.c_str();
glShaderSource(m_frag, 1, &fragSource, NULL);
glCompileShader(m_frag);
glGetShaderiv(m_vert, GL_COMPILE_STATUS, &m_status);
if (m_status == GL_FALSE) {
char buf[512];
glGetShaderInfoLog(m_vert, 512, NULL, buf);
logger << LOGGER_ERROR << buf << LOGGER_ENDL;
}
glGetShaderiv(m_frag, GL_COMPILE_STATUS, &m_status);
if (m_status == GL_FALSE) {
char buf[512];
glGetShaderInfoLog(m_frag, 512, NULL, buf);
logger << LOGGER_ERROR << buf << LOGGER_ENDL;
}
logger << LOGGER_INFO << "Vertex shader at '" << m_vertLoc << "' compiled..." << LOGGER_ENDL;
logger << LOGGER_INFO << "Fragment shader at '" << m_fragLoc << "' compiled..." << LOGGER_ENDL;
link();
attatch();
return *this;
}
GLuint Shader::getProgram() {
return m_program;
}
GLuint Shader::getVertex() {
return m_vert;
}
GLuint Shader::getFragment() {
return m_frag;
}
Shader::~Shader() {
glDeleteProgram(m_program);
glDeleteShader(m_vert);
glDeleteShader(m_frag);
}

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

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

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

@@ -1,36 +1,36 @@
#ifndef SRC_TIMERS_H_
#define SRC_TIMERS_H_
// General includes
#include <chrono>
// GL includes
#if _WIN32
#include <SDL.h>
#else
#include <SDL2/SDL.h>
#endif
// Custom includes
#include <logger.h>
std::chrono::high_resolution_clock timer;
auto FPSCalculateLast = timer.now();
auto FPSClock = SDL_GetTicks();
auto UpdateClock = SDL_GetTicks();
void FPSCount(Logger& logger) {
if (SDL_GetTicks() - FPSClock >= 1000) {
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;
FPSClock = SDL_GetTicks();
}
FPSCalculateLast = timer.now();
}
bool UPSTimer() {
return (SDL_GetTicks() - UpdateClock >= 10);
}
#endif
#ifndef SRC_TIMERS_H_
#define SRC_TIMERS_H_
// General includes
#include <chrono>
// GL includes
#if _WIN32
#include <SDL.h>
#else
#include <SDL2/SDL.h>
#endif
// Custom includes
#include <logger.h>
std::chrono::high_resolution_clock timer;
auto FPSCalculateLast = timer.now();
auto FPSClock = SDL_GetTicks();
auto UpdateClock = SDL_GetTicks();
void FPSCount(Logger& logger) {
if (SDL_GetTicks() - FPSClock >= 1000) {
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;
FPSClock = SDL_GetTicks();
}
FPSCalculateLast = timer.now();
}
bool UPSTimer() {
return (SDL_GetTicks() - UpdateClock >= 10);
}
#endif

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

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

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

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

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

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

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

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

3682
src/glad.cpp → 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"
Material::Material() {
}
Material::Material(std::string objPath) {
// Logger logger;
// objl::Loader loader;
// bool canLoad = loader.LoadFile(objPath);
// if (!canLoad) {
// logger << LOGGER_ERROR << "Cannot load material '" << objPath << "'" << LOGGER_ENDL;
// return;
// }
// loadFromObj(loader.LoadedMeshes[0]);
}
// Material::Material(objl::Mesh objMesh) {
// loadFromObj(objMesh);
// }
// void Material::loadFromObj(objl::Mesh objMesh) {
// loadFromMat(objMesh.MeshMaterial);
// }
// void Material::loadFromMat(objl::Material mat) {
// this->name = mat.name;
// OBJLVec3toGLM(mat.Ka, this->Ka);
// OBJLVec3toGLM(mat.Kd, this->Kd);
// OBJLVec3toGLM(mat.Ks, this->Ks);
// this->Ns = mat.Ns;
// this->Ni = mat.Ni;
// this->d = mat.d;
// this->illum = mat.illum;
// this->map_Ka = mat.map_Ka;
// this->map_Kd = mat.map_Kd;
// this->map_Ks = mat.map_Ks;
// this->map_Ns = mat.map_Ns;
// this->map_d = mat.map_d;
// this->map_bump = mat.map_bump;
// }
#include "material.h"
Material::Material() {
}
Material::Material(std::string objPath) {
// Logger logger;
// objl::Loader loader;
// bool canLoad = loader.LoadFile(objPath);
// if (!canLoad) {
// logger << LOGGER_ERROR << "Cannot load material '" << objPath << "'" << LOGGER_ENDL;
// return;
// }
// loadFromObj(loader.LoadedMeshes[0]);
}
// Material::Material(objl::Mesh objMesh) {
// loadFromObj(objMesh);
// }
// void Material::loadFromObj(objl::Mesh objMesh) {
// loadFromMat(objMesh.MeshMaterial);
// }
// void Material::loadFromMat(objl::Material mat) {
// this->name = mat.name;
// OBJLVec3toGLM(mat.Ka, this->Ka);
// OBJLVec3toGLM(mat.Kd, this->Kd);
// OBJLVec3toGLM(mat.Ks, this->Ks);
// this->Ns = mat.Ns;
// this->Ni = mat.Ni;
// this->d = mat.d;
// this->illum = mat.illum;
// this->map_Ka = mat.map_Ka;
// this->map_Kd = mat.map_Kd;
// this->map_Ks = mat.map_Ks;
// this->map_Ns = mat.map_Ns;
// this->map_d = mat.map_d;
// 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_
#define SMHENGINE_SRC_MATERIAL_H_
#include <string>
#include <vector>
#include <glad/glad.hpp>
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>
#include <logger.h>
#include "./util/util.h"
class Material {
public:
Material();
Material(std::string objPath);
// Material(objl::Mesh objMesh);
// void loadFromObj(objl::Mesh objMesh);
// void loadFromMat(objl::Material mat);
// Material Name
std::string name;
// Ambient Color
glm::vec3 Ka;
// Diffuse Color
glm::vec3 Kd;
// Specular Color
glm::vec3 Ks;
// Specular Exponent
float Ns;
// Optical Density
float Ni;
// Dissolve
float d;
// Illumination model 0->10
// TODO: Make an enum for this
int illum;
// Ambient Texture Map
std::string map_Ka;
// Diffuse Texture Map
std::string map_Kd;
// Specular Texture Map
std::string map_Ks;
// Specular Hightlight Map
std::string map_Ns;
// Alpha Texture Map
std::string map_d;
// Bump Map
std::string map_bump;
};
#endif
#ifndef SMHENGINE_SRC_MATERIAL_H_
#define SMHENGINE_SRC_MATERIAL_H_
#include <string>
#include <vector>
#include <glad/glad.hpp>
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>
#include <logger.h>
#include "./util/util.h"
class Material {
public:
Material();
Material(std::string objPath);
// Material(objl::Mesh objMesh);
// void loadFromObj(objl::Mesh objMesh);
// void loadFromMat(objl::Material mat);
// Material Name
std::string name;
// Ambient Color
glm::vec3 Ka;
// Diffuse Color
glm::vec3 Kd;
// Specular Color
glm::vec3 Ks;
// Specular Exponent
float Ns;
// Optical Density
float Ni;
// Dissolve
float d;
// Illumination model 0->10
// TODO: Make an enum for this
int illum;
// Ambient Texture Map
std::string map_Ka;
// Diffuse Texture Map
std::string map_Kd;
// Specular Texture Map
std::string map_Ks;
// Specular Hightlight Map
std::string map_Ns;
// Alpha Texture Map
std::string map_d;
// Bump Map
std::string map_bump;
};
#endif

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

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

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

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

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

@@ -1,28 +1,28 @@
#ifndef SMHENGINE_SRC_OBJECT_H_
#define SMHENGINE_SRC_OBJECT_H_
#include <string>
#include <vector>
#include <glad/glad.hpp>
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>
#include <OBJLoader.h>
#include <logger.h>
#include "model.h"
#include "shader.h"
class Object {
public:
Object();
std::vector<Model> models;
std::vector<Shader> shaders;
};
#endif
#ifndef SMHENGINE_SRC_OBJECT_H_
#define SMHENGINE_SRC_OBJECT_H_
#include <string>
#include <vector>
#include <glad/glad.hpp>
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>
#include <OBJLoader.h>
#include <logger.h>
#include "model.h"
#include "shader.h"
class Object {
public:
Object();
std::vector<Model> models;
std::vector<Shader> shaders;
};
#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 <iostream>
#include <fstream>
Shader::Shader()
: logger(*new Logger) {
m_program = glCreateProgram();
}
Shader& Shader::use() {
glUseProgram(m_program);
return *this;
}
Shader& Shader::link() {
glLinkProgram(m_program);
return *this;
}
Shader& Shader::attatch() {
glAttachShader(m_program, m_vert);
glAttachShader(m_program, m_frag);
return *this;
}
std::string readShader(std::string source) {
std::ifstream t(source);
std::string shaderCode((std::istreambuf_iterator<char>(t)),
std::istreambuf_iterator<char>());
return shaderCode;
}
Shader& Shader::load(GLenum type, std::string sourceLoc) {
const char* source = readShader(sourceLoc).c_str();
if (type == GL_VERTEX_SHADER) {
m_vertLoc = sourceLoc;
m_vertSource = (std::string)source;
m_vert = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(m_vert, 1, &source, NULL);
glCompileShader(m_vert);
glGetShaderiv(m_vert, GL_COMPILE_STATUS, &m_status);
if (m_status == GL_FALSE) {
char buf[512];
glGetShaderInfoLog(m_vert, 512, NULL, buf);
logger << LOGGER_ERROR << buf << LOGGER_ENDL;
}
logger << LOGGER_INFO << "Vertex shader at '" << sourceLoc << "' compiled..." << LOGGER_ENDL;
}
else if (type == GL_FRAGMENT_SHADER) {
m_fragLoc = sourceLoc;
m_fragSource = (std::string)source;
m_frag = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(m_frag, 1, &source, NULL);
glCompileShader(m_frag);
glGetShaderiv(m_frag, GL_COMPILE_STATUS, &m_status);
if (m_status == GL_FALSE) {
char buf[512];
glGetShaderInfoLog(m_frag, 512, NULL, buf);
logger << LOGGER_ERROR << buf << LOGGER_ENDL;
}
logger << LOGGER_INFO << "Vertex shader at '" << sourceLoc << "' compiled..." << LOGGER_ENDL;
}
return *this;
}
Shader& Shader::load(std::string sourceLoc) {
m_vertLoc = sourceLoc + ".vert";
m_fragLoc = sourceLoc + ".frag";
m_vertSource = readShader(m_vertLoc);
m_fragSource = readShader(m_fragLoc);
m_vert = glCreateShader(GL_VERTEX_SHADER);
m_frag = glCreateShader(GL_FRAGMENT_SHADER);
const char* vertSource = m_vertSource.c_str();
glShaderSource(m_vert, 1, &vertSource, NULL);
glCompileShader(m_vert);
const char* fragSource = m_fragSource.c_str();
glShaderSource(m_frag, 1, &fragSource, NULL);
glCompileShader(m_frag);
glGetShaderiv(m_vert, GL_COMPILE_STATUS, &m_status);
if (m_status == GL_FALSE) {
char buf[512];
glGetShaderInfoLog(m_vert, 512, NULL, buf);
logger << LOGGER_ERROR << buf << LOGGER_ENDL;
}
glGetShaderiv(m_frag, GL_COMPILE_STATUS, &m_status);
if (m_status == GL_FALSE) {
char buf[512];
glGetShaderInfoLog(m_frag, 512, NULL, buf);
logger << LOGGER_ERROR << buf << LOGGER_ENDL;
}
logger << LOGGER_INFO << "Vertex shader at '" << m_vertLoc << "' compiled..." << LOGGER_ENDL;
logger << LOGGER_INFO << "Fragment shader at '" << m_fragLoc << "' compiled..." << LOGGER_ENDL;
return *this;
}
Shader& Shader::reload() {
glDeleteProgram(m_program);
glDeleteShader(m_vert);
glDeleteShader(m_frag);
m_vertSource = readShader(m_vertLoc);
m_fragSource = readShader(m_fragLoc);
m_vert = glCreateShader(GL_VERTEX_SHADER);
m_frag = glCreateShader(GL_FRAGMENT_SHADER);
const char* vertSource = m_vertSource.c_str();
glShaderSource(m_vert, 1, &vertSource, NULL);
glCompileShader(m_vert);
const char* fragSource = m_fragSource.c_str();
glShaderSource(m_frag, 1, &fragSource, NULL);
glCompileShader(m_frag);
glGetShaderiv(m_vert, GL_COMPILE_STATUS, &m_status);
if (m_status == GL_FALSE) {
char buf[512];
glGetShaderInfoLog(m_vert, 512, NULL, buf);
logger << LOGGER_ERROR << buf << LOGGER_ENDL;
}
glGetShaderiv(m_frag, GL_COMPILE_STATUS, &m_status);
if (m_status == GL_FALSE) {
char buf[512];
glGetShaderInfoLog(m_frag, 512, NULL, buf);
logger << LOGGER_ERROR << buf << LOGGER_ENDL;
}
logger << LOGGER_INFO << "Vertex shader at '" << m_vertLoc << "' compiled..." << LOGGER_ENDL;
logger << LOGGER_INFO << "Fragment shader at '" << m_fragLoc << "' compiled..." << LOGGER_ENDL;
link();
attatch();
return *this;
}
GLuint Shader::getProgram() {
return m_program;
}
GLuint Shader::getVertex() {
return m_vert;
}
GLuint Shader::getFragment() {
return m_frag;
}
Shader::~Shader() {
glDeleteProgram(m_program);
glDeleteShader(m_vert);
glDeleteShader(m_frag);
}
#include "shader.h"
#include <iostream>
#include <fstream>
Shader::Shader()
: logger(*new Logger) {
m_program = glCreateProgram();
}
Shader& Shader::use() {
glUseProgram(m_program);
return *this;
}
Shader& Shader::link() {
glLinkProgram(m_program);
return *this;
}
Shader& Shader::attatch() {
glAttachShader(m_program, m_vert);
glAttachShader(m_program, m_frag);
return *this;
}
std::string readShader(std::string source) {
std::ifstream t(source);
std::string shaderCode((std::istreambuf_iterator<char>(t)),
std::istreambuf_iterator<char>());
return shaderCode;
}
Shader& Shader::load(GLenum type, std::string sourceLoc) {
const char* source = readShader(sourceLoc).c_str();
if (type == GL_VERTEX_SHADER) {
m_vertLoc = sourceLoc;
m_vertSource = (std::string)source;
m_vert = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(m_vert, 1, &source, NULL);
glCompileShader(m_vert);
glGetShaderiv(m_vert, GL_COMPILE_STATUS, &m_status);
if (m_status == GL_FALSE) {
char buf[512];
glGetShaderInfoLog(m_vert, 512, NULL, buf);
logger << LOGGER_ERROR << buf << LOGGER_ENDL;
}
logger << LOGGER_INFO << "Vertex shader at '" << sourceLoc << "' compiled..." << LOGGER_ENDL;
}
else if (type == GL_FRAGMENT_SHADER) {
m_fragLoc = sourceLoc;
m_fragSource = (std::string)source;
m_frag = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(m_frag, 1, &source, NULL);
glCompileShader(m_frag);
glGetShaderiv(m_frag, GL_COMPILE_STATUS, &m_status);
if (m_status == GL_FALSE) {
char buf[512];
glGetShaderInfoLog(m_frag, 512, NULL, buf);
logger << LOGGER_ERROR << buf << LOGGER_ENDL;
}
logger << LOGGER_INFO << "Vertex shader at '" << sourceLoc << "' compiled..." << LOGGER_ENDL;
}
return *this;
}
Shader& Shader::load(std::string sourceLoc) {
m_vertLoc = sourceLoc + ".vert";
m_fragLoc = sourceLoc + ".frag";
m_vertSource = readShader(m_vertLoc);
m_fragSource = readShader(m_fragLoc);
m_vert = glCreateShader(GL_VERTEX_SHADER);
m_frag = glCreateShader(GL_FRAGMENT_SHADER);
const char* vertSource = m_vertSource.c_str();
glShaderSource(m_vert, 1, &vertSource, NULL);
glCompileShader(m_vert);
const char* fragSource = m_fragSource.c_str();
glShaderSource(m_frag, 1, &fragSource, NULL);
glCompileShader(m_frag);
glGetShaderiv(m_vert, GL_COMPILE_STATUS, &m_status);
if (m_status == GL_FALSE) {
char buf[512];
glGetShaderInfoLog(m_vert, 512, NULL, buf);
logger << LOGGER_ERROR << buf << LOGGER_ENDL;
}
glGetShaderiv(m_frag, GL_COMPILE_STATUS, &m_status);
if (m_status == GL_FALSE) {
char buf[512];
glGetShaderInfoLog(m_frag, 512, NULL, buf);
logger << LOGGER_ERROR << buf << LOGGER_ENDL;
}
logger << LOGGER_INFO << "Vertex shader at '" << m_vertLoc << "' compiled..." << LOGGER_ENDL;
logger << LOGGER_INFO << "Fragment shader at '" << m_fragLoc << "' compiled..." << LOGGER_ENDL;
return *this;
}
Shader& Shader::reload() {
glDeleteProgram(m_program);
glDeleteShader(m_vert);
glDeleteShader(m_frag);
m_vertSource = readShader(m_vertLoc);
m_fragSource = readShader(m_fragLoc);
m_vert = glCreateShader(GL_VERTEX_SHADER);
m_frag = glCreateShader(GL_FRAGMENT_SHADER);
const char* vertSource = m_vertSource.c_str();
glShaderSource(m_vert, 1, &vertSource, NULL);
glCompileShader(m_vert);
const char* fragSource = m_fragSource.c_str();
glShaderSource(m_frag, 1, &fragSource, NULL);
glCompileShader(m_frag);
glGetShaderiv(m_vert, GL_COMPILE_STATUS, &m_status);
if (m_status == GL_FALSE) {
char buf[512];
glGetShaderInfoLog(m_vert, 512, NULL, buf);
logger << LOGGER_ERROR << buf << LOGGER_ENDL;
}
glGetShaderiv(m_frag, GL_COMPILE_STATUS, &m_status);
if (m_status == GL_FALSE) {
char buf[512];
glGetShaderInfoLog(m_frag, 512, NULL, buf);
logger << LOGGER_ERROR << buf << LOGGER_ENDL;
}
logger << LOGGER_INFO << "Vertex shader at '" << m_vertLoc << "' compiled..." << LOGGER_ENDL;
logger << LOGGER_INFO << "Fragment shader at '" << m_fragLoc << "' compiled..." << LOGGER_ENDL;
link();
attatch();
return *this;
}
GLuint Shader::getProgram() {
return m_program;
}
GLuint Shader::getVertex() {
return m_vert;
}
GLuint Shader::getFragment() {
return m_frag;
}
Shader::~Shader() {
glDeleteProgram(m_program);
glDeleteShader(m_vert);
glDeleteShader(m_frag);
}

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

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

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
#include "tiny_obj_loader.h"
#define TINYOBJLOADER_IMPLEMENTATION // define this in only *one* .cc
#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 <unordered_map>
#include <logger.h>
#include "../mesh.h"
void OBJLtoGLM(ObjLMesh& mesh,
std::vector<glm::vec3>& outVert,
std::vector<glm::vec3>& outNorm,
std::vector<glm::vec3>& outTexCoord,
std::vector<GLuint>& outIndices) {
std::unordered_map<glm::vec3, uint64_t> uniqueVertices {{{1.0f, 1.0f, 1.0f}, 1}};
for (const auto &shape : mesh.shapes) {
for (const auto& index : shape.mesh.indices) {
glm::vec3 vertex {
mesh.attrib.vertices[3 * index.vertex_index + 0],
mesh.attrib.vertices[3 * index.vertex_index + 1],
mesh.attrib.vertices[3 * index.vertex_index + 2]
};
// outNorm.push_back({
// mesh.attrib.normals[3 * index.normal_index + 0],
// mesh.attrib.normals[3 * index.normal_index + 1],
// mesh.attrib.normals[3 * index.normal_index + 2]
// });
// outTexCoord.push_back({
// mesh.attrib.texcoords[2 * index.texcoord_index + 0],
// mesh.attrib.texcoords[2 * index.texcoord_index + 1],
// 0.0f
// });
if (uniqueVertices.count(vertex) == 0) {
uniqueVertices[vertex] = static_cast<uint32_t>(outVert.size());
outVert.push_back(vertex);
}
outIndices.push_back(uniqueVertices[vertex]);
}
}
ComputeNormals(outNorm, outVert, outIndices);
}
void ComputeNormals(std::vector<glm::vec3>& normals,
std::vector<glm::vec3>& vertices,
std::vector<GLuint>& elements) {
normals.resize(vertices.size(), glm::vec3(0.0, 0.0, 0.0));
for (int i = 0; i < elements.size(); i += 3) {
GLushort ia = elements[i];
GLushort ib = elements[i+1];
GLushort ic = elements[i+2];
glm::vec3 normal = glm::normalize(glm::cross(
glm::vec3(vertices[ib]) - glm::vec3(vertices[ia]),
glm::vec3(vertices[ic]) - glm::vec3(vertices[ia])));
normals[ia] = normals[ib] = normals[ic] = normal;
}
}
void UintToGLuint(ObjLMesh& mesh,
std::vector<GLuint>& outIndices) {
}
// void OBJLVec3toGLM(objl::Vector3& inVec, glm::vec3& outVec) {
// outVec.x = inVec.X;
// outVec.y = inVec.Y;
// outVec.z = inVec.Z;
// }
#include "util.h"
#include <unordered_map>
#include <logger.h>
#include "../mesh.h"
void OBJLtoGLM(ObjLMesh& mesh,
std::vector<glm::vec3>& outVert,
std::vector<glm::vec3>& outNorm,
std::vector<glm::vec3>& outTexCoord,
std::vector<GLuint>& outIndices) {
std::unordered_map<glm::vec3, uint64_t> uniqueVertices {{{1.0f, 1.0f, 1.0f}, 1}};
for (const auto &shape : mesh.shapes) {
for (const auto& index : shape.mesh.indices) {
glm::vec3 vertex {
mesh.attrib.vertices[3 * index.vertex_index + 0],
mesh.attrib.vertices[3 * index.vertex_index + 1],
mesh.attrib.vertices[3 * index.vertex_index + 2]
};
// outNorm.push_back({
// mesh.attrib.normals[3 * index.normal_index + 0],
// mesh.attrib.normals[3 * index.normal_index + 1],
// mesh.attrib.normals[3 * index.normal_index + 2]
// });
// outTexCoord.push_back({
// mesh.attrib.texcoords[2 * index.texcoord_index + 0],
// mesh.attrib.texcoords[2 * index.texcoord_index + 1],
// 0.0f
// });
if (uniqueVertices.count(vertex) == 0) {
uniqueVertices[vertex] = static_cast<uint32_t>(outVert.size());
outVert.push_back(vertex);
}
outIndices.push_back(uniqueVertices[vertex]);
}
}
ComputeNormals(outNorm, outVert, outIndices);
}
void ComputeNormals(std::vector<glm::vec3>& normals,
std::vector<glm::vec3>& vertices,
std::vector<GLuint>& elements) {
normals.resize(vertices.size(), glm::vec3(0.0, 0.0, 0.0));
for (int i = 0; i < elements.size(); i += 3) {
GLushort ia = elements[i];
GLushort ib = elements[i+1];
GLushort ic = elements[i+2];
glm::vec3 normal = glm::normalize(glm::cross(
glm::vec3(vertices[ib]) - glm::vec3(vertices[ia]),
glm::vec3(vertices[ic]) - glm::vec3(vertices[ia])));
normals[ia] = normals[ib] = normals[ic] = normal;
}
}
void UintToGLuint(ObjLMesh& mesh,
std::vector<GLuint>& outIndices) {
}
// void OBJLVec3toGLM(objl::Vector3& inVec, glm::vec3& outVec) {
// outVec.x = inVec.X;
// outVec.y = inVec.Y;
// 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_
#define SMHENGINE_SRC_UTIL_UTUL_H_
#include <glad/glad.hpp>
// This is so that i can use
// glm::vec3 inside of an
// std::unordered_map as it's
// experimental for some reason
// smh
#define GLM_ENABLE_EXPERIMENTAL
#include <glm/gtx/hash.hpp>
#include <glm/glm.hpp>
#include <vector>
#include <tiny_obj_loader.h>
struct ObjLMesh;
void OBJLtoGLM(ObjLMesh& mesh,
std::vector<glm::vec3>& outVert,
std::vector<glm::vec3>& outNorm,
std::vector<glm::vec3>& outTexCoord,
std::vector<GLuint>& outIndices);
void ComputeNormals(std::vector<glm::vec3>& normals,
std::vector<glm::vec3>& vertices,
std::vector<GLuint>& elements);
void UintToGLuint(ObjLMesh& mesh,
std::vector<GLuint>& outIndices);
// void OBJLVec3toGLM(objl::Vector3& inVec, glm::vec3& outVec);
#endif
#ifndef SMHENGINE_SRC_UTIL_UTIL_H_
#define SMHENGINE_SRC_UTIL_UTUL_H_
#include <glad/glad.hpp>
// This is so that i can use
// glm::vec3 inside of an
// std::unordered_map as it's
// experimental for some reason
// smh
#define GLM_ENABLE_EXPERIMENTAL
#include <glm/gtx/hash.hpp>
#include <glm/glm.hpp>
#include <vector>
#include <tiny_obj_loader.h>
struct ObjLMesh;
void OBJLtoGLM(ObjLMesh& mesh,
std::vector<glm::vec3>& outVert,
std::vector<glm::vec3>& outNorm,
std::vector<glm::vec3>& outTexCoord,
std::vector<GLuint>& outIndices);
void ComputeNormals(std::vector<glm::vec3>& normals,
std::vector<glm::vec3>& vertices,
std::vector<GLuint>& elements);
void UintToGLuint(ObjLMesh& mesh,
std::vector<GLuint>& outIndices);
// void OBJLVec3toGLM(objl::Vector3& inVec, glm::vec3& outVec);
#endif

72
src/main.cpp
View File

@@ -1,72 +1,6 @@
// 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();
}
#include <iostream>
int main(int argc, char** argv) {
std::cout << "bruh" << std::endl;
return 0;
}