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

initial commit

Browse Source
This commit is contained in:
Benjamin Kyd
2019-02-20 20:56:32 +00:00
parent 8a3ae2992b
commit f88a89cd1a
21 changed files with 306783 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

83
CMakeLists.txt Normal file
View File

@@ -0,0 +1,83 @@
cmake_minimum_required(VERSION 3.7)
project(OpenGLPlayground)
set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} CMakeModules/)
cmake_policy(SET CMP0037 OLD)
set(CMAKE_BUILD_TYPE Debug)
set(executable output)
set(SrcDIR ./src)
set(IncludeDIR ./include)
if (UNIX)
find_package(SDL2 REQUIRED)
#find_package(SDL2_image REQUIRED)
#find_package(PNG REQUIRED)
#find_package(JPEG REQUIRED)
endif(UNIX)
if (WIN32)
SET(CMAKE_CXX_FLAGS "-IC:/dev/SDL2/include/ -LC:/dev/SDL2/lib/x64/")
#SET(CMAKE_CXX_FLAGS "-IC:/dev/SDL2_image/include/ -LC:/dev/SDL2_image/lib/x64/")
SET(CMAKE_CXX_FLAGS "-IC:/dev/glm")
include_directories(${executable}
"C:/dev/glm"
"C:/dev/SDL2/include/"
#"C:/dev/SDL2_image/include/"
)
endif (WIN32)
set(THREADS_PREFER_PTHREAD_FLAD ON)
find_package(Threads REQUIRED)
find_package(OpenGL REQUIRED)
if (UNIX)
include_directories(${executable}
${SDL2_INCLUDE_DIR}
#${SDL2_IMAGE_INCLUDE_DIR}
)
endif (UNIX)
include_directories(${executable}
#${PNG_INCLUDE_DIR}
#${JPEG_INCLUDE_DIR}
${IncludeDIR}
)
file(GLOB_RECURSE SourceFiles
${SrcDIR}/*
)
add_executable(${executable} ${SourceFiles})
set_target_properties(${executable} PROPERTIES
CXX_STANDARD 17
CXX_EXTENSIONS OFF
)
if (UNIX)
target_link_libraries(${executable}
SDL2
#SDL2_image
#PNG::PNG
#JPEG::JPEG
OpenGL::OpenGL
OpenGL::GL
Threads::Threads
)
endif (UNIX)
if (WIN32)
target_link_libraries(${executable}
"C:/dev/SDL2/lib/x64/SDL2.lib"
"C:/dev/SDL2/lib/x64/SDL2main.lib"
"C:/dev/SDL2/lib/x64/SDL2test.lib"
#"C:/dev/SDL2_image/lib/x64/SDL2_image.lib"
${WinSDK}
)
endif (WIN32)
target_link_libraries(${executable}
${CMAKE_DL_LIBS}
)

25
CMakeSettings.json Normal file
View File

@@ -0,0 +1,25 @@
{
"environments": [
{
"DevDir": "E:\\Languages\\Examples\\OpenGL\\playground\\build",
"BuildDir": "${env.USERPROFILE}\\CMakeBuilds\\${workspaceHash}"
}
],
"configurations": [
{
"name": "x64-Debug",
"generator": "Ninja",
"configurationType": "Debug",
"inheritEnvironments": [
"msvc_x64_x64"
],
"buildRoot": "E:\\Languages\\Examples\\OpenGL\\playground\\build",
// "buildRoot": "${env.USERPROFILE}\\CMakeBuilds\\${workspaceHash}",
"installRoot": "E:\\Languages\\Examples\\OpenGL\\playground\\build",
// "installRoot": "${env.USERPROFILE}\\CMakeBuilds\\${workspaceHash}",
"cmakeCommandArgs": "",
"buildCommandArgs": "-v",
"ctestCommandArgs": ""
}
]
}

282
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
include/glad/glad.h Normal file
View File

File diff suppressed because it is too large Load Diff

160
include/logger.h Normal file
View File

@@ -0,0 +1,160 @@
#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<class T>
static void consoleColour(T colour);
};
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
}
template<typename T>
void Colour::consoleColour(T colour) {
#ifdef _WIN32
SetConsoleTextAttribute(h, colour);
#else
std::cout << "\033[" << colour << "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

150016
resources/dragon.obj Normal file
View File

File diff suppressed because it is too large Load Diff

150078
resources/lucy.obj Normal file
View File

File diff suppressed because it is too large Load Diff

53
resources/shaders/phong.frag Normal file
View File

@@ -0,0 +1,53 @@
#version 330
in vec3 Normal;
in vec3 FragPos;
in vec4 FragPosLightSpace;
uniform vec3 lightPos;
out vec4 outColour;
uniform sampler2D diffuseTexture;
uniform sampler2D shadowMap;
vec3 viewPos = vec3(0.0, 0.0, 0.0);
vec3 objectColour = vec3(1.0, 1.0, 1.0);
vec3 lightColour = vec3(1.0, 1.0, 1.0);
// vec3 lightColour = vec3(0.1, 0.45, 0.9);
float calculateShadow(vec4 fragPosLightSpace) {
vec3 projCoords = fragPosLightSpace.xyz / fragPosLightSpace.w;
projCoords = projCoords * 0.5 + 0.5;
float closestDepth = texture(shadowMap, projCoords.xy).r;
float currentDepth = projCoords.z;
float shadow = currentDepth > closestDepth ? 1.0 : 0.0;
return shadow;
}
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.2;
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.1;
vec3 ambient = ambientStrength * lightColour;
float shadow = calculateShadow(FragPosLightSpace);
vec3 result = (ambient + (1.0 - shadow) * (diffuse + specular)) * objectColour;
outColour = vec4(result, 1.0);
}

21
resources/shaders/phong.vert Normal file
View File

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

7
resources/shaders/shadowmap.frag Normal file
View File

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

10
resources/shaders/shadowmap.vert Normal file
View File

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

7
resources/shaders/simple.frag Normal file
View File

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

11
resources/shaders/simple.vert Normal file
View File

@@ -0,0 +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);
}

BIN
resources/stanford_dragon.zip Normal file
View File

Binary file not shown.

1841
src/glad.c Normal file
View File

File diff suppressed because it is too large Load Diff

236
src/main.cpp Normal file
View File

@@ -0,0 +1,236 @@
// General includes
#include <chrono>
#include <vector>
// GL includes
#include <glad/glad.h>
// 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);
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;
}

58
src/object.cpp Normal file
View File

@@ -0,0 +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);
}
}
}

33
src/object.h Normal file
View File

@@ -0,0 +1,33 @@
#ifndef SRC_OBJECT_H_
#define SRC_OBJECT_H_
// General includes
#include <vector>
// GL includes
#include <glad/glad.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>
// 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

167
src/shader.cpp Normal file
View File

@@ -0,0 +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);
}

42
src/shader.h Normal file
View File

@@ -0,0 +1,42 @@
#ifndef SRC_SHADER_H_
#define SRC_SHADER_H_
#include <glad/glad.h>
#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

36
src/timers.h Normal file
View File

@@ -0,0 +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