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

SMH

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

26
.gitignore vendored
View File

@@ -1,13 +1,13 @@
CMakeCache.txt
CMakeFiles/
CMakeScripts/
Testing/
Makefile
cmake_install.cmake
install_manifest.txt
compile_commands.json
CTestTestfile.cmake
build/
output
.vs/
.vscode/
CMakeCache.txt
CMakeFiles/
CMakeScripts/
Testing/
Makefile
cmake_install.cmake
install_manifest.txt
compile_commands.json
CTestTestfile.cmake
build/
output
.vs/
.vscode/

166
CMakeLists.txt
View File

@@ -1,83 +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 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}
)
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 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}
)

48
CMakeSettings.json
View File

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

42
LICENSE
View File

@@ -1,21 +1,21 @@
MIT License
Copyright (c) 2019 Benjamin Kyd
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
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 Software.
THE SOFTWARE IS 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 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
MIT License
Copyright (c) 2019 Benjamin Kyd
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
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 Software.
THE SOFTWARE IS 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 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

202
OBJLoaderExample.cpp
View File

@@ -1,101 +1,101 @@
// Example 1: Load and Print
//
// Load the data from the .obj then print it into a file
// called e1Out.txt
// Iostream - STD I/O Library
#include <iostream>
// fStream - STD File I/O Library
#include <fstream>
// OBJ_Loader - .obj Loader
#include "OBJ_Loader.h"
// Main function
int main(int argc, char* argv[])
{
// Initialize Loader
objl::Loader Loader;
// Load .obj File
bool loadout = Loader.LoadFile("box_stack.obj");
// Check to see if it loaded
// If so continue
if (loadout)
{
// Create/Open e1Out.txt
std::ofstream file("e1Out.txt");
// Go through each loaded mesh and out its contents
for (int i = 0; i < Loader.LoadedMeshes.size(); i++)
{
// Copy one of the loaded meshes to be our current mesh
objl::Mesh curMesh = Loader.LoadedMeshes[i];
// Print Mesh Name
file << "Mesh " << i << ": " << curMesh.MeshName << "\n";
// Print Vertices
file << "Vertices:\n";
// Go through each vertex and print its number,
// position, normal, and texture coordinate
for (int j = 0; j < curMesh.Vertices.size(); j++)
{
file << "V" << j << ": " <<
"P(" << curMesh.Vertices[j].Position.X << ", " << curMesh.Vertices[j].Position.Y << ", " << curMesh.Vertices[j].Position.Z << ") " <<
"N(" << curMesh.Vertices[j].Normal.X << ", " << curMesh.Vertices[j].Normal.Y << ", " << curMesh.Vertices[j].Normal.Z << ") " <<
"TC(" << curMesh.Vertices[j].TextureCoordinate.X << ", " << curMesh.Vertices[j].TextureCoordinate.Y << ")\n";
}
// Print Indices
file << "Indices:\n";
// Go through every 3rd index and print the
// triangle that these indices represent
for (int j = 0; j < curMesh.Indices.size(); j += 3)
{
file << "T" << j / 3 << ": " << curMesh.Indices[j] << ", " << curMesh.Indices[j + 1] << ", " << curMesh.Indices[j + 2] << "\n";
}
// Print Material
file << "Material: " << curMesh.MeshMaterial.name << "\n";
file << "Ambient Color: " << curMesh.MeshMaterial.Ka.X << ", " << curMesh.MeshMaterial.Ka.Y << ", " << curMesh.MeshMaterial.Ka.Z << "\n";
file << "Diffuse Color: " << curMesh.MeshMaterial.Kd.X << ", " << curMesh.MeshMaterial.Kd.Y << ", " << curMesh.MeshMaterial.Kd.Z << "\n";
file << "Specular Color: " << curMesh.MeshMaterial.Ks.X << ", " << curMesh.MeshMaterial.Ks.Y << ", " << curMesh.MeshMaterial.Ks.Z << "\n";
file << "Specular Exponent: " << curMesh.MeshMaterial.Ns << "\n";
file << "Optical Density: " << curMesh.MeshMaterial.Ni << "\n";
file << "Dissolve: " << curMesh.MeshMaterial.d << "\n";
file << "Illumination: " << curMesh.MeshMaterial.illum << "\n";
file << "Ambient Texture Map: " << curMesh.MeshMaterial.map_Ka << "\n";
file << "Diffuse Texture Map: " << curMesh.MeshMaterial.map_Kd << "\n";
file << "Specular Texture Map: " << curMesh.MeshMaterial.map_Ks << "\n";
file << "Alpha Texture Map: " << curMesh.MeshMaterial.map_d << "\n";
file << "Bump Map: " << curMesh.MeshMaterial.map_bump << "\n";
// Leave a space to separate from the next mesh
file << "\n";
}
// Close File
file.close();
}
// If not output an error
else
{
// Create/Open e1Out.txt
std::ofstream file("e1Out.txt");
// Output Error
file << "Failed to Load File. May have failed to find it or it was not an .obj file.\n";
// Close File
file.close();
}
// Exit the program
return 0;
}
// Example 1: Load and Print
//
// Load the data from the .obj then print it into a file
// called e1Out.txt
// Iostream - STD I/O Library
#include <iostream>
// fStream - STD File I/O Library
#include <fstream>
// OBJ_Loader - .obj Loader
#include "OBJ_Loader.h"
// Main function
int main(int argc, char* argv[])
{
// Initialize Loader
objl::Loader Loader;
// Load .obj File
bool loadout = Loader.LoadFile("box_stack.obj");
// Check to see if it loaded
// If so continue
if (loadout)
{
// Create/Open e1Out.txt
std::ofstream file("e1Out.txt");
// Go through each loaded mesh and out its contents
for (int i = 0; i < Loader.LoadedMeshes.size(); i++)
{
// Copy one of the loaded meshes to be our current mesh
objl::Mesh curMesh = Loader.LoadedMeshes[i];
// Print Mesh Name
file << "Mesh " << i << ": " << curMesh.MeshName << "\n";
// Print Vertices
file << "Vertices:\n";
// Go through each vertex and print its number,
// position, normal, and texture coordinate
for (int j = 0; j < curMesh.Vertices.size(); j++)
{
file << "V" << j << ": " <<
"P(" << curMesh.Vertices[j].Position.X << ", " << curMesh.Vertices[j].Position.Y << ", " << curMesh.Vertices[j].Position.Z << ") " <<
"N(" << curMesh.Vertices[j].Normal.X << ", " << curMesh.Vertices[j].Normal.Y << ", " << curMesh.Vertices[j].Normal.Z << ") " <<
"TC(" << curMesh.Vertices[j].TextureCoordinate.X << ", " << curMesh.Vertices[j].TextureCoordinate.Y << ")\n";
}
// Print Indices
file << "Indices:\n";
// Go through every 3rd index and print the
// triangle that these indices represent
for (int j = 0; j < curMesh.Indices.size(); j += 3)
{
file << "T" << j / 3 << ": " << curMesh.Indices[j] << ", " << curMesh.Indices[j + 1] << ", " << curMesh.Indices[j + 2] << "\n";
}
// Print Material
file << "Material: " << curMesh.MeshMaterial.name << "\n";
file << "Ambient Color: " << curMesh.MeshMaterial.Ka.X << ", " << curMesh.MeshMaterial.Ka.Y << ", " << curMesh.MeshMaterial.Ka.Z << "\n";
file << "Diffuse Color: " << curMesh.MeshMaterial.Kd.X << ", " << curMesh.MeshMaterial.Kd.Y << ", " << curMesh.MeshMaterial.Kd.Z << "\n";
file << "Specular Color: " << curMesh.MeshMaterial.Ks.X << ", " << curMesh.MeshMaterial.Ks.Y << ", " << curMesh.MeshMaterial.Ks.Z << "\n";
file << "Specular Exponent: " << curMesh.MeshMaterial.Ns << "\n";
file << "Optical Density: " << curMesh.MeshMaterial.Ni << "\n";
file << "Dissolve: " << curMesh.MeshMaterial.d << "\n";
file << "Illumination: " << curMesh.MeshMaterial.illum << "\n";
file << "Ambient Texture Map: " << curMesh.MeshMaterial.map_Ka << "\n";
file << "Diffuse Texture Map: " << curMesh.MeshMaterial.map_Kd << "\n";
file << "Specular Texture Map: " << curMesh.MeshMaterial.map_Ks << "\n";
file << "Alpha Texture Map: " << curMesh.MeshMaterial.map_d << "\n";
file << "Bump Map: " << curMesh.MeshMaterial.map_bump << "\n";
// Leave a space to separate from the next mesh
file << "\n";
}
// Close File
file.close();
}
// If not output an error
else
{
// Create/Open e1Out.txt
std::ofstream file("e1Out.txt");
// Output Error
file << "Failed to Load File. May have failed to find it or it was not an .obj file.\n";
// Close File
file.close();
}
// Exit the program
return 0;
}

18
README.md
View File

@@ -1,9 +1,9 @@
# SMH Engine
This is the SMH engine, it's aim is to display various modern real-time rendering techniques commonly used in the videogame industry using OpenGL.
![alt text](https://i.imgur.com/q5days1.png, "Latest Screenshot")
## Dependancies
- SDL2
# SMH Engine
This is the SMH engine, it's aim is to display various modern real-time rendering techniques commonly used in the videogame industry using OpenGL.
![alt text](https://i.imgur.com/q5days1.png, "Latest Screenshot")
## Dependancies
- SDL2

564
include/KHR/khrplatform.h
View File

@@ -1,282 +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_ */
#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_ */

2332
include/OBJLoader.h
View File

File diff suppressed because it is too large Load Diff

7234
include/glad/glad.hpp
View File

File diff suppressed because it is too large Load Diff

308
include/logger.h
View File

@@ -1,154 +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
#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

3682
legacy/glad.cpp
View File

File diff suppressed because it is too large Load Diff

474
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
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
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
View File

File diff suppressed because it is too large Load Diff

300032
legacy/resources/dragon.obj
View File

File diff suppressed because it is too large Load Diff

300156
legacy/resources/lucy.obj
View File

File diff suppressed because it is too large Load Diff

78
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);
}

42
legacy/resources/shaders/phong.vert
View File

@@ -1,21 +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;
}
#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;
}

14
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
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
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
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);
}

334
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
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
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

2312
resources/donut.obj
View File

File diff suppressed because it is too large Load Diff

300032
resources/dragon.obj
View File

File diff suppressed because it is too large Load Diff

78
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);
}

358
src/display.cpp
View File

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

118
src/display.h
View File

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

3682
src/glad.cpp
View File

File diff suppressed because it is too large Load Diff

76
src/main.cpp
View File

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

6
src/material.cpp
View File

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

18
src/material.h
View File

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

68
src/mesh.cpp
View File

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

85
src/mesh.h
View File

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

6
src/shader.cpp
View File

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

18
src/shader.h
View File

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

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

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

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

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