Gulum/DarkRP2D
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Formatted classes

Browse Source
This commit is contained in:
Julian Nießner
2018-05-26 11:14:12 +02:00
parent ae5fa3f2aa
commit 9ffdf66bd0
27 changed files with 574 additions and 461 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
src/Assets.h
View File

@@ -9,15 +9,16 @@
#include "Texture.h" #include "Texture.h"
#include "Shader.h" #include "Shader.h"
class Assets { class Assets
private: {
private:
std::map<std::string, Texture2D> textures; std::map<std::string, Texture2D> textures;
std::map<std::string, Shader> shaders; std::map<std::string, Shader> shaders;
Texture2D loadTextureFromFile(const GLchar *file, GLboolean alpha); Texture2D loadTextureFromFile(const GLchar *file, GLboolean alpha);
Shader loadShaderFromFile(const GLchar *vShaderFile,const GLchar *fShaderFile, const GLchar *gShaderFile=nullptr); Shader loadShaderFromFile(const GLchar *vShaderFile, const GLchar *fShaderFile, const GLchar *gShaderFile = nullptr);
public: public:
Assets() {} Assets() {}
~Assets(); ~Assets();
@@ -25,8 +26,6 @@ class Assets {
Shader getShader(std::string name); Shader getShader(std::string name);
Texture2D loadTexture(const GLchar *file, GLboolean alpha, std::string name); Texture2D loadTexture(const GLchar *file, GLboolean alpha, std::string name);
Texture2D getTexture(std::string name); Texture2D getTexture(std::string name);
}; };
#endif #endif

57
src/BitmapFont.cpp
View File

@@ -6,20 +6,25 @@
#include <iostream> #include <iostream>
BitmapFont::BitmapFont(std::string fontLocation) { BitmapFont::BitmapFont(std::string fontLocation)
{
FT_Library ft; FT_Library ft;
if(FT_Init_FreeType(&ft)) { if (FT_Init_FreeType(&ft))
{
std::cout << "ERROR::FreeType: Could not init FreeType Library" << std::endl; std::cout << "ERROR::FreeType: Could not init FreeType Library" << std::endl;
} }
FT_Face face; FT_Face face;
if(FT_New_Face(ft, fontLocation.c_str(), 0, &face)){ if (FT_New_Face(ft, fontLocation.c_str(), 0, &face))
{
std::cout << "ERROR::FreeType: Failed to load font" << std::endl; std::cout << "ERROR::FreeType: Failed to load font" << std::endl;
} }
FT_Set_Pixel_Sizes(face, 0, 48); FT_Set_Pixel_Sizes(face, 0, 48);
glPixelStorei(GL_UNPACK_ALIGNMENT, 1); //Disable byte-alignment restriction glPixelStorei(GL_UNPACK_ALIGNMENT, 1); //Disable byte-alignment restriction
for(GLubyte c = 0; c < 128; c++) { for (GLubyte c = 0; c < 128; c++)
{
//Map bitmaps to chars //Map bitmaps to chars
if(FT_Load_Char(face, c, FT_LOAD_RENDER)) { if (FT_Load_Char(face, c, FT_LOAD_RENDER))
{
std::cout << "ERROR::FreeType: Could not load Glyph: " << c << std::endl; std::cout << "ERROR::FreeType: Could not load Glyph: " << c << std::endl;
continue; continue;
} }
@@ -27,16 +32,15 @@ BitmapFont::BitmapFont(std::string fontLocation) {
glGenTextures(1, &texture); glGenTextures(1, &texture);
glBindTexture(GL_TEXTURE_2D, texture); glBindTexture(GL_TEXTURE_2D, texture);
glTexImage2D( glTexImage2D(
GL_TEXTURE_2D, GL_TEXTURE_2D,
0, 0,
GL_RED, GL_RED,
face->glyph->bitmap.width, face->glyph->bitmap.width,
face->glyph->bitmap.rows, face->glyph->bitmap.rows,
0, 0,
GL_RED, GL_RED,
GL_UNSIGNED_BYTE, GL_UNSIGNED_BYTE,
face->glyph->bitmap.buffer face->glyph->bitmap.buffer);
);
// Set texture options // Set texture options
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
@@ -46,8 +50,7 @@ BitmapFont::BitmapFont(std::string fontLocation) {
texture, texture,
glm::ivec2(face->glyph->bitmap.width, face->glyph->bitmap.rows), glm::ivec2(face->glyph->bitmap.width, face->glyph->bitmap.rows),
glm::ivec2(face->glyph->bitmap_left, face->glyph->bitmap_top), glm::ivec2(face->glyph->bitmap_left, face->glyph->bitmap_top),
face->glyph->advance.x face->glyph->advance.x};
};
characters.insert(std::pair<GLchar, Character>(c, character)); characters.insert(std::pair<GLchar, Character>(c, character));
} }
glPixelStorei(GL_UNPACK_ALIGNMENT, 4); //Reset byte-alignment restriction glPixelStorei(GL_UNPACK_ALIGNMENT, 4); //Reset byte-alignment restriction
@@ -57,7 +60,7 @@ BitmapFont::BitmapFont(std::string fontLocation) {
glEnable(GL_BLEND); glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
projection = glm::ortho(0.0f,800.0f,0.0f,600.0f); projection = glm::ortho(0.0f, 800.0f, 0.0f, 600.0f);
glGenVertexArrays(1, &VAO); glGenVertexArrays(1, &VAO);
glGenBuffers(1, &VBO); glGenBuffers(1, &VBO);
@@ -70,10 +73,11 @@ BitmapFont::BitmapFont(std::string fontLocation) {
glBindVertexArray(0); glBindVertexArray(0);
} }
void BitmapFont::drawText(Shader &s, std::string text, GLfloat x, GLfloat y, GLfloat scale, glm::vec3 color) { void BitmapFont::drawText(Shader &s, std::string text, GLfloat x, GLfloat y, GLfloat scale, glm::vec3 color)
{
s.Use(); s.Use();
s.SetVector3f("textColor", color, true); s.SetVector3f("textColor", color, true);
s.SetMatrix4("projection",projection,true); s.SetMatrix4("projection", projection, true);
glActiveTexture(GL_TEXTURE0); glActiveTexture(GL_TEXTURE0);
glBindVertexArray(VAO); glBindVertexArray(VAO);
@@ -91,14 +95,13 @@ void BitmapFont::drawText(Shader &s, std::string text, GLfloat x, GLfloat y, GLf
GLfloat h = ch.size.y * scale; GLfloat h = ch.size.y * scale;
// Update VBO for each character // Update VBO for each character
GLfloat vertices[6][4] = { GLfloat vertices[6][4] = {
{ xpos, ypos + h, 0.0, 0.0 }, {xpos, ypos + h, 0.0, 0.0},
{ xpos, ypos, 0.0, 1.0 }, {xpos, ypos, 0.0, 1.0},
{ xpos + w, ypos, 1.0, 1.0 }, {xpos + w, ypos, 1.0, 1.0},
{ xpos, ypos + h, 0.0, 0.0 }, {xpos, ypos + h, 0.0, 0.0},
{ xpos + w, ypos, 1.0, 1.0 }, {xpos + w, ypos, 1.0, 1.0},
{ xpos + w, ypos + h, 1.0, 0.0 } {xpos + w, ypos + h, 1.0, 0.0}};
};
// Render glyph texture over quad // Render glyph texture over quad
glBindTexture(GL_TEXTURE_2D, ch.texID); glBindTexture(GL_TEXTURE_2D, ch.texID);
// Update content of VBO memory // Update content of VBO memory

10
src/BitmapFont.h
View File

@@ -8,19 +8,21 @@
#include "Shader.h" #include "Shader.h"
struct Character { struct Character
{
GLuint texID; GLuint texID;
glm::ivec2 size; glm::ivec2 size;
glm::ivec2 bearing; glm::ivec2 bearing;
GLuint advance; GLuint advance;
}; };
class BitmapFont { class BitmapFont
public: {
public:
BitmapFont(std::string fontLocation); BitmapFont(std::string fontLocation);
void drawText(Shader &s, std::string text, GLfloat x, GLfloat y, GLfloat scale, glm::vec3 color); void drawText(Shader &s, std::string text, GLfloat x, GLfloat y, GLfloat scale, glm::vec3 color);
private: private:
std::map<GLchar, Character> characters; std::map<GLchar, Character> characters;
GLuint VAO, VBO; GLuint VAO, VBO;
glm::mat4 projection; glm::mat4 projection;

36
src/Camera.cpp
View File

@@ -2,52 +2,60 @@
#include <glm/gtc/matrix_transform.hpp> #include <glm/gtc/matrix_transform.hpp>
void OrtographicCamera::setPosition(glm::vec2 position) { void OrtographicCamera::setPosition(glm::vec2 position)
{
this->cameraPos = position; this->cameraPos = position;
} }
glm::vec2 OrtographicCamera::getPosition() { glm::vec2 OrtographicCamera::getPosition()
{
return this->cameraPos; return this->cameraPos;
} }
void OrtographicCamera::setZoomLevel(float newZoom) { void OrtographicCamera::setZoomLevel(float newZoom)
{
this->zoom = newZoom; this->zoom = newZoom;
} }
void OrtographicCamera::zoomIn(float targetZoom) { void OrtographicCamera::zoomIn(float targetZoom)
{
zoom -= targetZoom; zoom -= targetZoom;
} }
void OrtographicCamera::translate(glm::vec2 target) { void OrtographicCamera::translate(glm::vec2 target)
{
cameraPos = cameraPos - target; cameraPos = cameraPos - target;
} }
void OrtographicCamera::smoothTranslate(glm::vec2 target) { void OrtographicCamera::smoothTranslate(glm::vec2 target)
{
} }
glm::mat4 OrtographicCamera::getViewMatrix() { glm::mat4 OrtographicCamera::getViewMatrix()
{
glm::mat4 view(1); glm::mat4 view(1);
view = glm::translate(view, glm::vec3(-cameraPos,0.f)); view = glm::translate(view, glm::vec3(-cameraPos, 0.f));
return view; return view;
} }
glm::mat4 OrtographicCamera::getProjectionMatrix() { glm::mat4 OrtographicCamera::getProjectionMatrix()
{
//Dies gibt die Größe des kamera auschnittes an die in die welt zeigt (Frustum) //Dies gibt die Größe des kamera auschnittes an die in die welt zeigt (Frustum)
int width = 800; int width = 800;
int height = 600; int height = 600;
int DPI = 2; // 200% windows settings int DPI = 2; // 200% windows settings
glm::mat4 projection; glm::mat4 projection;
projection = glm::ortho(0.0f, (width/DPI)*this->zoom, 0.0f, (height/DPI)*this->zoom); projection = glm::ortho(0.0f, (width / DPI) * this->zoom, 0.0f, (height / DPI) * this->zoom);
return projection; return projection;
} }
glm::mat4 OrtographicCamera::getCombinedMatrix() { glm::mat4 OrtographicCamera::getCombinedMatrix()
{
glm::mat4 combined; glm::mat4 combined;
combined = getProjectionMatrix() * getViewMatrix(); combined = getProjectionMatrix() * getViewMatrix();
return combined; return combined;
} }
void OrtographicCamera::update() { void OrtographicCamera::update()
{
} }

9
src/Camera.h
View File

@@ -3,13 +3,14 @@
#include <glm/glm.hpp> #include <glm/glm.hpp>
class OrtographicCamera { class OrtographicCamera
private: {
private:
glm::vec2 cameraPos; glm::vec2 cameraPos;
float zoom; float zoom;
public: public:
OrtographicCamera() : cameraPos(glm::vec2(-5.0f,-5.0f)), zoom(0.05f) {} OrtographicCamera() : cameraPos(glm::vec2(-5.0f, -5.0f)), zoom(0.05f) {}
void setPosition(glm::vec2); void setPosition(glm::vec2);
glm::vec2 getPosition(); glm::vec2 getPosition();

106
src/DarkRP2D.cpp
View File

@@ -1,8 +1,8 @@
#include "DarkRP2D.h" #include "DarkRP2D.h"
#ifndef NDEBUG #ifndef NDEBUG
#include "imgui.h" #include "imgui.h"
#include "imgui_impl_sdl_gl3.h" #include "imgui_impl_sdl_gl3.h"
#endif #endif
#include <GL/glew.h> #include <GL/glew.h>
@@ -10,51 +10,56 @@
#include "screens/GameScreen.h" #include "screens/GameScreen.h"
#include "Utility.h" #include "Utility.h"
DarkRP2D::~DarkRP2D() { DarkRP2D::~DarkRP2D()
{
std::cout << "Game got destroyed!" << std::endl; std::cout << "Game got destroyed!" << std::endl;
#ifndef NDEBUG #ifndef NDEBUG
ImGui_ImplSdlGL3_Shutdown(); ImGui_ImplSdlGL3_Shutdown();
ImGui::DestroyContext(); ImGui::DestroyContext();
#endif #endif
delete gameScreen; delete gameScreen;
delete assets; delete assets;
delete renderer; delete renderer;
} }
void DarkRP2D::create () { void DarkRP2D::create()
{
std::cout << "Game got created!" << std::endl; std::cout << "Game got created!" << std::endl;
assets = new Assets(); assets = new Assets();
assets->loadTexture("police_officer.png",true,"police_officer"); assets->loadTexture("police_officer.png", true, "police_officer");
assets->loadShader("vert.shader","frag.shader",nullptr,"defaultShader"); assets->loadShader("vert.shader", "frag.shader", nullptr, "defaultShader");
assets->loadShader("bitmapvert.shader","bitmapfrag.shader",nullptr,"bitmapShader"); assets->loadShader("bitmapvert.shader", "bitmapfrag.shader", nullptr, "bitmapShader");
renderer = new Renderer(); renderer = new Renderer();
font = new BitmapFont("arial.ttf"); font = new BitmapFont("arial.ttf");
gameScreen = new GameScreen(renderer,assets); gameScreen = new GameScreen(renderer, assets);
gameScreen->show(); gameScreen->show();
#ifndef NDEBUG #ifndef NDEBUG
//Setup IMGUI debugging //Setup IMGUI debugging
ImGui::CreateContext(); ImGui::CreateContext();
ImGui_ImplSdlGL3_Init(this->gWindow); ImGui_ImplSdlGL3_Init(this->gWindow);
ImGui::StyleColorsDark(); ImGui::StyleColorsDark();
#endif #endif
} }
void DarkRP2D::loop(unsigned int delta) { void DarkRP2D::loop(unsigned int delta)
{
static unsigned int accumulator = 0, ups = 0, fps = 0, acc = 0; static unsigned int accumulator = 0, ups = 0, fps = 0, acc = 0;
accumulator += delta; accumulator += delta;
acc += delta; acc += delta;
while(accumulator >= 17) { while (accumulator >= 17)
{
accumulator -= 17; accumulator -= 17;
update(delta); update(delta);
ups++; ups++;
} }
if(acc >= 1000) { if (acc >= 1000)
{
std::cout << "Updates per second: " << ups << " Frames per Second: " << fps << std::endl; std::cout << "Updates per second: " << ups << " Frames per Second: " << fps << std::endl;
acc -= 1000; acc -= 1000;
ups = 0; ups = 0;
@@ -64,47 +69,50 @@ void DarkRP2D::loop(unsigned int delta) {
fps++; fps++;
} }
void DarkRP2D::update(unsigned int delta) { void DarkRP2D::update(unsigned int delta)
{
gameScreen->update(); gameScreen->update();
} }
void DarkRP2D::render(unsigned int delta) { void DarkRP2D::render(unsigned int delta)
{
renderer->clear(); renderer->clear();
#ifndef NDEBUG #ifndef NDEBUG
ImGui_ImplSdlGL3_NewFrame(gWindow); ImGui_ImplSdlGL3_NewFrame(gWindow);
#endif #endif
//texttest //texttest
Shader bitmapShader = assets->getShader("bitmapShader"); Shader bitmapShader = assets->getShader("bitmapShader");
font->drawText(bitmapShader, "Hallo du noob", 25.0f, 25.0f, 1.f, glm::vec3(0.5f,0.8f,0.2f)); font->drawText(bitmapShader, "Hallo du noob", 25.0f, 25.0f, 1.f, glm::vec3(0.5f, 0.8f, 0.2f));
gameScreen->render(); gameScreen->render();
#ifndef NDEBUG #ifndef NDEBUG
// 1. Show a simple window. // 1. Show a simple window.
// Tip: if we don't call ImGui::Begin()/ImGui::End() the widgets automatically appears in a window called "Debug". // Tip: if we don't call ImGui::Begin()/ImGui::End() the widgets automatically appears in a window called "Debug".
static bool ShowOpenGLLogger = false; static bool ShowOpenGLLogger = false;
{ {
ImGui::Separator(); ImGui::Separator();
ImGui::Text("\t\t\t\t\tOpenGL Info"); ImGui::Text("\t\t\t\t\tOpenGL Info");
ImGui::Text("GLEW Version: %s\n", glewGetString(GLEW_VERSION)); ImGui::Text("GLEW Version: %s\n", glewGetString(GLEW_VERSION));
ImGui::Text(" Version: %s\n", glGetString(GL_VERSION)); ImGui::Text(" Version: %s\n", glGetString(GL_VERSION));
ImGui::Text(" Vendor: %s\n", glGetString(GL_VENDOR)); ImGui::Text(" Vendor: %s\n", glGetString(GL_VENDOR));
ImGui::Text(" Renderer: %s\n", glGetString(GL_RENDERER)); ImGui::Text(" Renderer: %s\n", glGetString(GL_RENDERER));
ImGui::Text(" Shading: %s\n", glGetString(GL_SHADING_LANGUAGE_VERSION)); ImGui::Text(" Shading: %s\n", glGetString(GL_SHADING_LANGUAGE_VERSION));
ImGui::Separator(); ImGui::Separator();
ImGui::Text("Application average %.3f ms/frame (%.1f FPS)", 1000.0f / ImGui::GetIO().Framerate, ImGui::GetIO().Framerate); ImGui::Text("Application average %.3f ms/frame (%.1f FPS)", 1000.0f / ImGui::GetIO().Framerate, ImGui::GetIO().Framerate);
ImGui::Checkbox("Show OpenGL Logger", &ShowOpenGLLogger); ImGui::Checkbox("Show OpenGL Logger", &ShowOpenGLLogger);
} }
if(ShowOpenGLLogger) if (ShowOpenGLLogger)
Utility::Debug::openGLLogger.Draw("OpenGL Logger"); Utility::Debug::openGLLogger.Draw("OpenGL Logger");
ImGui::Render(); ImGui::Render();
ImGui_ImplSdlGL3_RenderDrawData(ImGui::GetDrawData()); ImGui_ImplSdlGL3_RenderDrawData(ImGui::GetDrawData());
#endif #endif
SDL_GL_SwapWindow(gWindow); SDL_GL_SwapWindow(gWindow);
} }
void DarkRP2D::resize(int width, int height){ void DarkRP2D::resize(int width, int height)
{
} }

16
src/DarkRP2D.h
View File

@@ -5,31 +5,29 @@ class DarkRP2D;
#include <SDL.h> #include <SDL.h>
#include <vector> #include <vector>
#include "Assets.h" #include "Assets.h"
#include "Renderer.h" #include "Renderer.h"
#include "input/InputHandler.h" #include "input/InputHandler.h"
#include "BitmapFont.h" #include "BitmapFont.h"
#include "screens/Screen.h" #include "screens/Screen.h"
class DarkRP2D { class DarkRP2D
private: {
SDL_Window* gWindow; private:
SDL_Window *gWindow;
Assets *assets; Assets *assets;
Renderer* renderer; Renderer *renderer;
BitmapFont *font; BitmapFont *font;
Screen *gameScreen; Screen *gameScreen;
public: public:
DarkRP2D(SDL_Window *gWindow) : gWindow(gWindow) {} DarkRP2D(SDL_Window *gWindow) : gWindow(gWindow) {}
~DarkRP2D(); ~DarkRP2D();
void create (); void create();
void loop(unsigned int delta); void loop(unsigned int delta);
void update(unsigned int delta); void update(unsigned int delta);
void render(unsigned int delta); void render(unsigned int delta);
void resize(int width, int height); void resize(int width, int height);
}; };
#endif #endif

95
src/DesktopLauncher.cpp
View File

@@ -4,23 +4,24 @@
#include <SDL_image.h> #include <SDL_image.h>
#include <GL/glew.h> #include <GL/glew.h>
#include "Desktoplauncher.h" #include "Desktoplauncher.h"
#include "DarkRP2D.h" #include "DarkRP2D.h"
#include "Utility.h" #include "Utility.h"
using namespace std; using namespace std;
static SDL_Window* gWindow = NULL; static SDL_Window *gWindow = NULL;
static SDL_GLContext glcontext; static SDL_GLContext glcontext;
static bool gameQuit = false; static bool gameQuit = false;
void dispose(); void dispose();
bool initSDL(); bool initSDL();
int main(int argc, char *argv[]) { int main(int argc, char *argv[])
{
//Init SDL_Window, SDL_Surface, SDL_Renderer //Init SDL_Window, SDL_Surface, SDL_Renderer
if(!initSDL()) { if (!initSDL())
{
dispose(); dispose();
return 1; return 1;
} }
@@ -29,7 +30,8 @@ int main(int argc, char *argv[]) {
DarkRP2D resA(gWindow); DarkRP2D resA(gWindow);
resA.create(); resA.create();
unsigned int lastTime = SDL_GetTicks(), currentTime, elapsedTime; unsigned int lastTime = SDL_GetTicks(), currentTime, elapsedTime;
while( !gameQuit ) { while (!gameQuit)
{
currentTime = SDL_GetTicks(); currentTime = SDL_GetTicks();
elapsedTime = currentTime - lastTime; elapsedTime = currentTime - lastTime;
lastTime = currentTime; lastTime = currentTime;
@@ -40,87 +42,102 @@ int main(int argc, char *argv[]) {
return 0; return 0;
} }
void Game::exit() { void Game::exit()
{
gameQuit = true; gameQuit = true;
} }
namespace Game { namespace Game
float DDPI, HDPI,VDPI; {
float DDPI, HDPI, VDPI;
} }
bool initSDL() { bool initSDL()
{
int result = SetProcessDPIAware(); // NEEDED or SDL_GetDisplayDPI returns wrong numbers int result = SetProcessDPIAware(); // NEEDED or SDL_GetDisplayDPI returns wrong numbers
cout << "Result: " << result << endl; cout << "Result: " << result << endl;
//Init SDL //Init SDL
if(SDL_Init(SDL_INIT_VIDEO) < 0 ) { if (SDL_Init(SDL_INIT_VIDEO) < 0)
{
cout << "SDL could not initialize! SDL_Error: " << SDL_GetError() << endl; cout << "SDL could not initialize! SDL_Error: " << SDL_GetError() << endl;
return false; return false;
} }
//Init Window //Init Window
uint32_t WindowFlags = SDL_WINDOW_ALLOW_HIGHDPI | SDL_WINDOW_OPENGL; uint32_t WindowFlags = SDL_WINDOW_ALLOW_HIGHDPI | SDL_WINDOW_OPENGL;
gWindow = SDL_CreateWindow( "SDL TEST", SDL_WINDOWPOS_UNDEFINED,SDL_WINDOWPOS_UNDEFINED, Game::SCREEN_WIDTH, Game::SCREEN_HEIGHT, WindowFlags); gWindow = SDL_CreateWindow("SDL TEST", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, Game::SCREEN_WIDTH, Game::SCREEN_HEIGHT, WindowFlags);
if( gWindow == NULL) { if (gWindow == NULL)
{
cout << "Window could not be created! SDL_Error: " << SDL_GetError() << endl; cout << "Window could not be created! SDL_Error: " << SDL_GetError() << endl;
return false; return false;
} }
//Read in Display DPI //Read in Display DPI
int returnDisplayDPI = SDL_GetDisplayDPI(SDL_GetWindowDisplayIndex(gWindow),&Game::DDPI,&Game::HDPI,&Game::VDPI); int returnDisplayDPI = SDL_GetDisplayDPI(SDL_GetWindowDisplayIndex(gWindow), &Game::DDPI, &Game::HDPI, &Game::VDPI);
if(returnDisplayDPI != 0) { if (returnDisplayDPI != 0)
cout << "DisplayDPI cannot be loaded! SDL_ERROR: " << SDL_GetError() << endl; {
cout << "DisplayDPI cannot be loaded! SDL_ERROR: " << SDL_GetError() << endl;
} }
cout << "DPI: DDPI: " << Game::DDPI << " HDPI: " << Game::HDPI << " VPDI: " << Game::VDPI << endl; cout << "DPI: DDPI: " << Game::DDPI << " HDPI: " << Game::HDPI << " VPDI: " << Game::VDPI << endl;
//Mask deprectated functions //Mask deprectated functions
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE); SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
#ifndef NDEBUG #ifndef NDEBUG
SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS, SDL_GL_CONTEXT_DEBUG_FLAG); SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS, SDL_GL_CONTEXT_DEBUG_FLAG);
#endif #endif
//Init OpenGL Renderer //Init OpenGL Renderer
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1); SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
glcontext = SDL_GL_CreateContext(gWindow); glcontext = SDL_GL_CreateContext(gWindow);
if(glcontext == NULL) { if (glcontext == NULL)
{
cout << "Could not create OpenGL Context: " << SDL_GetError() << endl; cout << "Could not create OpenGL Context: " << SDL_GetError() << endl;
return false; return false;
} }
//Init GLEW //Init GLEW
glewExperimental = GL_TRUE; glewExperimental = GL_TRUE;
GLenum err = glewInit(); GLenum err = glewInit();
if(GLEW_OK != err) { if (GLEW_OK != err)
{
cout << "Init of Glew failed: " << glewGetErrorString(err) << endl; cout << "Init of Glew failed: " << glewGetErrorString(err) << endl;
return false; return false;
} }
//Init debug callback function //Init debug callback function
#ifndef NDEBUG #ifndef NDEBUG
if (GLEW_ARB_debug_output) { if (GLEW_ARB_debug_output)
{
Utility::printInfo(Utility::GLEW, "Supporting ARB debug output!"); Utility::printInfo(Utility::GLEW, "Supporting ARB debug output!");
} }
if (GLEW_AMD_debug_output) { if (GLEW_AMD_debug_output)
{
Utility::printInfo(Utility::GLEW, "Supporting AMD debug output!"); Utility::printInfo(Utility::GLEW, "Supporting AMD debug output!");
} }
if (GLEW_KHR_debug) { if (GLEW_KHR_debug)
{
Utility::printInfo(Utility::GLEW, "Supporting KHR debug output!"); Utility::printInfo(Utility::GLEW, "Supporting KHR debug output!");
} }
if(glDebugMessageCallback) { if (glDebugMessageCallback)
{
glEnable(GL_DEBUG_OUTPUT); glEnable(GL_DEBUG_OUTPUT);
Utility::printInfo(Utility::OpenGL, "Register OpenGL debug callback"); Utility::printInfo(Utility::OpenGL, "Register OpenGL debug callback");
glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS); glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
glDebugMessageCallback(Utility::openglCallbackFunction, nullptr); glDebugMessageCallback(Utility::openglCallbackFunction, nullptr);
GLuint unusedIds = 0; GLuint unusedIds = 0;
glDebugMessageControl(GL_DONT_CARE, glDebugMessageControl(GL_DONT_CARE,
GL_DONT_CARE, GL_DONT_CARE,
GL_DONT_CARE, GL_DONT_CARE,
0, 0,
&unusedIds, &unusedIds,
true); true);
} else { }
else
{
Utility::printWarning(Utility::OpenGL, "glDebugMessageCallback not available"); Utility::printWarning(Utility::OpenGL, "glDebugMessageCallback not available");
} }
#endif #endif
return true; return true;
} }
void dispose() { void dispose()
{
SDL_GL_DeleteContext(glcontext); SDL_GL_DeleteContext(glcontext);
SDL_DestroyWindow( gWindow ); SDL_DestroyWindow(gWindow);
SDL_Quit(); SDL_Quit();
} }

6
src/DesktopLauncher.h
View File

@@ -3,7 +3,8 @@
#include <string> #include <string>
namespace Game { namespace Game
{
const int SCREEN_WIDTH = 800; const int SCREEN_WIDTH = 800;
const int SCREEN_HEIGHT = 600; const int SCREEN_HEIGHT = 600;
@@ -15,8 +16,7 @@ extern float HDPI;
//vertical DPI of the display used while starting //vertical DPI of the display used while starting
extern float VDPI; extern float VDPI;
void exit(); void exit();
} } // namespace Game
#endif #endif

29
src/Mesh.cpp
View File

@@ -3,8 +3,8 @@
#include <GL/glew.h> #include <GL/glew.h>
#include <iostream> #include <iostream>
Mesh::Mesh(std::vector<Vertex2D> vertices, std::vector<unsigned int> indices, Texture2D texture)
Mesh::Mesh(std::vector<Vertex2D> vertices, std::vector<unsigned int> indices, Texture2D texture) { {
this->texture = texture; this->texture = texture;
this->vertices = vertices; this->vertices = vertices;
this->indices = indices; this->indices = indices;
@@ -12,13 +12,14 @@ Mesh::Mesh(std::vector<Vertex2D> vertices, std::vector<unsigned int> indices, Te
setupMesh(); setupMesh();
} }
void Mesh::setupMesh() { void Mesh::setupMesh()
{
//Create VAO & Bind //Create VAO & Bind
glGenVertexArrays(1, &VAO); glGenVertexArrays(1, &VAO);
glBindVertexArray(VAO); glBindVertexArray(VAO);
//Create VBO //Create VBO
glGenBuffers(1, &VBO); glGenBuffers(1, &VBO);
glBindBuffer(GL_ARRAY_BUFFER,VBO); glBindBuffer(GL_ARRAY_BUFFER, VBO);
glBufferData(GL_ARRAY_BUFFER, vertices.size() * sizeof(Vertex2D), &vertices[0], GL_STATIC_DRAW); glBufferData(GL_ARRAY_BUFFER, vertices.size() * sizeof(Vertex2D), &vertices[0], GL_STATIC_DRAW);
//Create EBO //Create EBO
glGenBuffers(1, &EBO); glGenBuffers(1, &EBO);
@@ -27,7 +28,7 @@ void Mesh::setupMesh() {
//Set attriPointer and enable //Set attriPointer and enable
glEnableVertexAttribArray(0); glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex2D), (void *) 0); glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex2D), (void *)0);
glEnableVertexAttribArray(1); glEnableVertexAttribArray(1);
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex2D), (void *)offsetof(Vertex2D, texCoord)); glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex2D), (void *)offsetof(Vertex2D, texCoord));
@@ -36,21 +37,25 @@ void Mesh::setupMesh() {
glBindVertexArray(0); glBindVertexArray(0);
} }
Mesh::~Mesh() { Mesh::~Mesh()
{
std::cout << "Deleting Mesh" << std::endl; std::cout << "Deleting Mesh" << std::endl;
glDeleteBuffers(1,&VBO); glDeleteBuffers(1, &VBO);
glDeleteBuffers(1,&EBO); glDeleteBuffers(1, &EBO);
glDeleteBuffers(1,&VAO); glDeleteBuffers(1, &VAO);
} }
unsigned int Mesh::getIndicesCount() const { unsigned int Mesh::getIndicesCount() const
{
return indices.size(); return indices.size();
} }
void Mesh::bindVAO() const { void Mesh::bindVAO() const
{
glBindVertexArray(this->VAO); glBindVertexArray(this->VAO);
} }
void Mesh::bindTexture() const { void Mesh::bindTexture() const
{
texture.Bind(); texture.Bind();
} }

18
src/Mesh.h
View File

@@ -7,24 +7,26 @@
//Aggregate class -> so following construction is available //Aggregate class -> so following construction is available
//Vertex2D{glm::vec2(-0.5f,-0.5f), glm::vec2(0.0f,1.0f)} //Vertex2D{glm::vec2(-0.5f,-0.5f), glm::vec2(0.0f,1.0f)}
struct Vertex2D { struct Vertex2D
{
glm::vec2 position; glm::vec2 position;
glm::vec2 texCoord; glm::vec2 texCoord;
}; };
class Mesh { class Mesh
private: {
private:
unsigned int VBO, VAO, EBO; unsigned int VBO, VAO, EBO;
void setupMesh(); void setupMesh();
public: public:
/* Mesh Data */ /* Mesh Data */
std::vector<Vertex2D> vertices; std::vector<Vertex2D> vertices;
std::vector<unsigned int> indices; std::vector<unsigned int> indices;
Texture2D texture; Texture2D texture;
Mesh(std::vector<Vertex2D> vertices, std::vector<unsigned int> indices,Texture2D textures); Mesh(std::vector<Vertex2D> vertices, std::vector<unsigned int> indices, Texture2D textures);
~Mesh(); ~Mesh();
unsigned int getIndicesCount() const; unsigned int getIndicesCount() const;

13
src/Renderer.cpp
View File

@@ -1,18 +1,21 @@
#include "Renderer.h" #include "Renderer.h"
#include <GL/glew.h> #include <GL/glew.h>
Renderer::Renderer() { Renderer::Renderer()
glClearColor(1.f,1.f,1.f,1.f); {
glClearColor(1.f, 1.f, 1.f, 1.f);
} }
void Renderer::draw(const Mesh& mesh, Shader& shader) { void Renderer::draw(const Mesh &mesh, Shader &shader)
{
//Bind texture of mesh //Bind texture of mesh
mesh.bindTexture(); mesh.bindTexture();
mesh.bindVAO(); mesh.bindVAO();
//draw Mesh //draw Mesh
glDrawElements(GL_TRIANGLES, mesh.getIndicesCount(), GL_UNSIGNED_INT, 0); glDrawElements(GL_TRIANGLES, mesh.getIndicesCount(), GL_UNSIGNED_INT, 0);
} }
void Renderer::clear() const { void Renderer::clear() const
{
glClear(GL_COLOR_BUFFER_BIT); glClear(GL_COLOR_BUFFER_BIT);
} }

11
src/Renderer.h
View File

@@ -4,11 +4,12 @@
#include "Mesh.h" #include "Mesh.h"
#include "Shader.h" #include "Shader.h"
class Renderer { class Renderer
public: {
Renderer(); public:
void draw(const Mesh& mesh, Shader& shader); Renderer();
void clear() const; void draw(const Mesh &mesh, Shader &shader);
void clear() const;
}; };
#endif #endif

45
src/Shader.cpp
View File

@@ -2,12 +2,14 @@
#include <iostream> #include <iostream>
Shader &Shader::Use() { Shader &Shader::Use()
{
glUseProgram(this->ID); glUseProgram(this->ID);
return *this; return *this;
} }
void Shader::Compile(const GLchar* vertexSource, const GLchar* fragmentSource, const GLchar* geometrySource) { void Shader::Compile(const GLchar *vertexSource, const GLchar *fragmentSource, const GLchar *geometrySource)
{
GLuint sVertex, sFragment, gShader; GLuint sVertex, sFragment, gShader;
// Vertex Shader // Vertex Shader
sVertex = glCreateShader(GL_VERTEX_SHADER); sVertex = glCreateShader(GL_VERTEX_SHADER);
@@ -42,54 +44,63 @@ void Shader::Compile(const GLchar* vertexSource, const GLchar* fragmentSource, c
glDeleteShader(gShader); glDeleteShader(gShader);
} }
void Shader::SetFloat(const GLchar *name, GLfloat value, GLboolean useShader) { void Shader::SetFloat(const GLchar *name, GLfloat value, GLboolean useShader)
{
if (useShader) if (useShader)
this->Use(); this->Use();
glUniform1f(glGetUniformLocation(this->ID, name), value); glUniform1f(glGetUniformLocation(this->ID, name), value);
} }
void Shader::SetInteger(const GLchar *name, GLint value, GLboolean useShader) { void Shader::SetInteger(const GLchar *name, GLint value, GLboolean useShader)
{
if (useShader) if (useShader)
this->Use(); this->Use();
glUniform1i(glGetUniformLocation(this->ID, name), value); glUniform1i(glGetUniformLocation(this->ID, name), value);
} }
void Shader::SetVector2f(const GLchar *name, GLfloat x, GLfloat y, GLboolean useShader) { void Shader::SetVector2f(const GLchar *name, GLfloat x, GLfloat y, GLboolean useShader)
{
if (useShader) if (useShader)
this->Use(); this->Use();
glUniform2f(glGetUniformLocation(this->ID, name), x, y); glUniform2f(glGetUniformLocation(this->ID, name), x, y);
} }
void Shader::SetVector2f(const GLchar *name, const glm::vec2 &value, GLboolean useShader) { void Shader::SetVector2f(const GLchar *name, const glm::vec2 &value, GLboolean useShader)
{
if (useShader) if (useShader)
this->Use(); this->Use();
glUniform2f(glGetUniformLocation(this->ID, name), value.x, value.y); glUniform2f(glGetUniformLocation(this->ID, name), value.x, value.y);
} }
void Shader::SetVector3f(const GLchar *name, GLfloat x, GLfloat y, GLfloat z, GLboolean useShader) { void Shader::SetVector3f(const GLchar *name, GLfloat x, GLfloat y, GLfloat z, GLboolean useShader)
{
if (useShader) if (useShader)
this->Use(); this->Use();
glUniform3f(glGetUniformLocation(this->ID, name), x, y, z); glUniform3f(glGetUniformLocation(this->ID, name), x, y, z);
} }
void Shader::SetVector3f(const GLchar *name, const glm::vec3 &value, GLboolean useShader) { void Shader::SetVector3f(const GLchar *name, const glm::vec3 &value, GLboolean useShader)
{
if (useShader) if (useShader)
this->Use(); this->Use();
glUniform3f(glGetUniformLocation(this->ID, name), value.x, value.y, value.z); glUniform3f(glGetUniformLocation(this->ID, name), value.x, value.y, value.z);
} }
void Shader::SetVector4f(const GLchar *name, GLfloat x, GLfloat y, GLfloat z, GLfloat w, GLboolean useShader) { void Shader::SetVector4f(const GLchar *name, GLfloat x, GLfloat y, GLfloat z, GLfloat w, GLboolean useShader)
{
if (useShader) if (useShader)
this->Use(); this->Use();
glUniform4f(glGetUniformLocation(this->ID, name), x, y, z, w); glUniform4f(glGetUniformLocation(this->ID, name), x, y, z, w);
} }
void Shader::SetVector4f(const GLchar *name, const glm::vec4 &value, GLboolean useShader) { void Shader::SetVector4f(const GLchar *name, const glm::vec4 &value, GLboolean useShader)
{
if (useShader) if (useShader)
this->Use(); this->Use();
glUniform4f(glGetUniformLocation(this->ID, name), value.x, value.y, value.z, value.w); glUniform4f(glGetUniformLocation(this->ID, name), value.x, value.y, value.z, value.w);
} }
void Shader::SetMatrix4(const GLchar *name, const glm::mat4 &matrix, GLboolean useShader) { void Shader::SetMatrix4(const GLchar *name, const glm::mat4 &matrix, GLboolean useShader)
{
if (useShader) if (useShader)
this->Use(); this->Use();
glUniformMatrix4fv(glGetUniformLocation(this->ID, name), 1, GL_FALSE, glm::value_ptr(matrix)); glUniformMatrix4fv(glGetUniformLocation(this->ID, name), 1, GL_FALSE, glm::value_ptr(matrix));
} }
void Shader::checkCompileErrors(GLuint object, std::string type)
void Shader::checkCompileErrors(GLuint object, std::string type) { {
GLint success; GLint success;
GLchar infoLog[1024]; GLchar infoLog[1024];
if (type != "PROGRAM") if (type != "PROGRAM")
@@ -99,8 +110,8 @@ void Shader::checkCompileErrors(GLuint object, std::string type) {
{ {
glGetShaderInfoLog(object, 1024, NULL, infoLog); glGetShaderInfoLog(object, 1024, NULL, infoLog);
std::cout << "| Shader Error at Compile-time: Type: " << type << "\n" std::cout << "| Shader Error at Compile-time: Type: " << type << "\n"
<< infoLog << "\n -- --------------------------------------------------- -- " << infoLog << "\n -- --------------------------------------------------- -- "
<< std::endl; << std::endl;
} }
} }
else else
@@ -110,8 +121,8 @@ void Shader::checkCompileErrors(GLuint object, std::string type) {
{ {
glGetProgramInfoLog(object, 1024, NULL, infoLog); glGetProgramInfoLog(object, 1024, NULL, infoLog);
std::cout << "| ERROR::Shader: Link-time error: Type: " << type << "\n" std::cout << "| ERROR::Shader: Link-time error: Type: " << type << "\n"
<< infoLog << "\n -- --------------------------------------------------- -- " << infoLog << "\n -- --------------------------------------------------- -- "
<< std::endl; << std::endl;
} }
} }
} }

32
src/Shader.h
View File

@@ -7,34 +7,34 @@
#include <glm/glm.hpp> #include <glm/glm.hpp>
#include <glm/gtc/type_ptr.hpp> #include <glm/gtc/type_ptr.hpp>
// General purpsoe shader object. Compiles from file, generates // General purpsoe shader object. Compiles from file, generates
// compile/link-time error messages and hosts several utility // compile/link-time error messages and hosts several utility
// functions for easy management. // functions for easy management.
class Shader class Shader
{ {
public: public:
// State // State
GLuint ID; GLuint ID;
// Constructor // Constructor
Shader() { } Shader() {}
// Sets the current shader as active // Sets the current shader as active
Shader &Use(); Shader &Use();
// Compiles the shader from given source code // Compiles the shader from given source code
void Compile(const GLchar *vertexSource, const GLchar *fragmentSource, const GLchar *geometrySource = nullptr); // Note: geometry source code is optional void Compile(const GLchar *vertexSource, const GLchar *fragmentSource, const GLchar *geometrySource = nullptr); // Note: geometry source code is optional
// Utility functions // Utility functions
void SetFloat (const GLchar *name, GLfloat value, GLboolean useShader = false); void SetFloat(const GLchar *name, GLfloat value, GLboolean useShader = false);
void SetInteger (const GLchar *name, GLint value, GLboolean useShader = false); void SetInteger(const GLchar *name, GLint value, GLboolean useShader = false);
void SetVector2f (const GLchar *name, GLfloat x, GLfloat y, GLboolean useShader = false); void SetVector2f(const GLchar *name, GLfloat x, GLfloat y, GLboolean useShader = false);
void SetVector2f (const GLchar *name, const glm::vec2 &value, GLboolean useShader = false); void SetVector2f(const GLchar *name, const glm::vec2 &value, GLboolean useShader = false);
void SetVector3f (const GLchar *name, GLfloat x, GLfloat y, GLfloat z, GLboolean useShader = false); void SetVector3f(const GLchar *name, GLfloat x, GLfloat y, GLfloat z, GLboolean useShader = false);
void SetVector3f (const GLchar *name, const glm::vec3 &value, GLboolean useShader = false); void SetVector3f(const GLchar *name, const glm::vec3 &value, GLboolean useShader = false);
void SetVector4f (const GLchar *name, GLfloat x, GLfloat y, GLfloat z, GLfloat w, GLboolean useShader = false); void SetVector4f(const GLchar *name, GLfloat x, GLfloat y, GLfloat z, GLfloat w, GLboolean useShader = false);
void SetVector4f (const GLchar *name, const glm::vec4 &value, GLboolean useShader = false); void SetVector4f(const GLchar *name, const glm::vec4 &value, GLboolean useShader = false);
void SetMatrix4 (const GLchar *name, const glm::mat4 &matrix, GLboolean useShader = false); void SetMatrix4(const GLchar *name, const glm::mat4 &matrix, GLboolean useShader = false);
private:
private:
// Checks if compilation or linking failed and if so, print the error logs // Checks if compilation or linking failed and if so, print the error logs
void checkCompileErrors(GLuint object, std::string type); void checkCompileErrors(GLuint object, std::string type);
}; };
#endif #endif

9
src/Texture.cpp
View File

@@ -2,14 +2,14 @@
#include "Texture.h" #include "Texture.h"
Texture2D::Texture2D() Texture2D::Texture2D()
: Width(0), Height(0), Internal_Format(GL_RGB), Image_Format(GL_RGB), Wrap_S(GL_REPEAT), Wrap_T(GL_REPEAT), Filter_Min(GL_LINEAR_MIPMAP_NEAREST), Filter_Max(GL_NEAREST) : Width(0), Height(0), Internal_Format(GL_RGB), Image_Format(GL_RGB), Wrap_S(GL_REPEAT), Wrap_T(GL_REPEAT), Filter_Min(GL_LINEAR_MIPMAP_NEAREST), Filter_Max(GL_LINEAR)
{ {
glGenTextures(1, &this->ID); glGenTextures(1, &this->ID);
} }
void Texture2D::Generate(GLuint width, GLuint height, unsigned char* data) { void Texture2D::Generate(GLuint width, GLuint height, unsigned char *data)
{
this->Width = width; this->Width = width;
this->Height = height; this->Height = height;
// Create Texture // Create Texture
@@ -31,6 +31,7 @@ void Texture2D::Generate(GLuint width, GLuint height, unsigned char* data) {
glBindTexture(GL_TEXTURE_2D, 0); glBindTexture(GL_TEXTURE_2D, 0);
} }
void Texture2D::Bind() const { void Texture2D::Bind() const
{
glBindTexture(GL_TEXTURE_2D, this->ID); glBindTexture(GL_TEXTURE_2D, this->ID);
} }

10
src/Texture.h
View File

@@ -7,23 +7,23 @@
// It also hosts utility functions for easy management. // It also hosts utility functions for easy management.
class Texture2D class Texture2D
{ {
public: public:
// Holds the ID of the texture object, used for all texture operations to reference to this particlar texture // Holds the ID of the texture object, used for all texture operations to reference to this particlar texture
GLuint ID; GLuint ID;
// Texture image dimensions // Texture image dimensions
GLuint Width, Height; // Width and height of loaded image in pixels GLuint Width, Height; // Width and height of loaded image in pixels
// Texture Format // Texture Format
GLuint Internal_Format; // Format of texture object GLuint Internal_Format; // Format of texture object
GLuint Image_Format; // Format of loaded image GLuint Image_Format; // Format of loaded image
// Texture configuration // Texture configuration
GLuint Wrap_S; // Wrapping mode on S axis GLuint Wrap_S; // Wrapping mode on S axis
GLuint Wrap_T; // Wrapping mode on T axis GLuint Wrap_T; // Wrapping mode on T axis
GLuint Filter_Min; // Filtering mode if texture pixels < screen pixels GLuint Filter_Min; // Filtering mode if texture pixels < screen pixels
GLuint Filter_Max; // Filtering mode if texture pixels > screen pixels GLuint Filter_Max; // Filtering mode if texture pixels > screen pixels
// Constructor (sets default texture modes) // Constructor (sets default texture modes)
Texture2D(); Texture2D();
// Generates texture from image data // Generates texture from image data
void Generate(GLuint width, GLuint height, unsigned char* data); void Generate(GLuint width, GLuint height, unsigned char *data);
// Binds the texture as the current active GL_TEXTURE_2D texture object // Binds the texture as the current active GL_TEXTURE_2D texture object
void Bind() const; void Bind() const;
}; };

182
src/Utility.cpp
View File

@@ -2,87 +2,103 @@
#ifndef NDEBUG #ifndef NDEBUG
namespace Utility{ namespace Utility
namespace Debug { {
ImGuiLogger openGLLogger; namespace Debug
} {
} ImGuiLogger openGLLogger;
}
} // namespace Utility
void Utility::Debug::ImGuiLogger::Clear() { void Utility::Debug::ImGuiLogger::Clear()
Buf.clear(); {
LineOffsets.clear(); Buf.clear();
} LineOffsets.clear();
}
void Utility::Debug::ImGuiLogger::AddLog(const char* fmt, ...) IM_FMTARGS(2) { void Utility::Debug::ImGuiLogger::AddLog(const char *fmt, ...) IM_FMTARGS(2)
int old_size = Buf.size(); {
va_list args; int old_size = Buf.size();
va_start(args, fmt); va_list args;
Buf.appendfv(fmt, args); va_start(args, fmt);
va_end(args); Buf.appendfv(fmt, args);
for (int new_size = Buf.size(); old_size < new_size; old_size++) va_end(args);
if (Buf[old_size] == '\n') for (int new_size = Buf.size(); old_size < new_size; old_size++)
LineOffsets.push_back(old_size); if (Buf[old_size] == '\n')
ScrollToBottom = true; LineOffsets.push_back(old_size);
} ScrollToBottom = true;
}
void Utility::Debug::ImGuiLogger::Draw(const char* title, bool* p_open) { void Utility::Debug::ImGuiLogger::Draw(const char *title, bool *p_open)
ImGui::SetNextWindowSize(ImVec2(500,400), ImGuiCond_FirstUseEver); {
ImGui::Begin(title, p_open); ImGui::SetNextWindowSize(ImVec2(500, 400), ImGuiCond_FirstUseEver);
if (ImGui::Button("Clear")) Clear(); ImGui::Begin(title, p_open);
ImGui::SameLine(); if (ImGui::Button("Clear"))
bool copy = ImGui::Button("Copy"); Clear();
ImGui::SameLine(); ImGui::SameLine();
ImGui::Checkbox("Errors", &ShowError); ImGui::SameLine(); bool copy = ImGui::Button("Copy");
ImGui::Checkbox("Deprecated Behavior", &ShowDeprecatedBehavior); ImGui::SameLine(); ImGui::SameLine();
ImGui::Checkbox("Undefined Behavior", &ShowUndefinedBehavior); ImGui::SameLine(); ImGui::Checkbox("Errors", &ShowError);
ImGui::Checkbox("Portability", &ShowPortability); ImGui::SameLine();
ImGui::Checkbox("Performance", &ShowPerformance); ImGui::SameLine(); ImGui::Checkbox("Deprecated Behavior", &ShowDeprecatedBehavior);
ImGui::Checkbox("Marker", &ShowMarker); ImGui::SameLine(); ImGui::SameLine();
ImGui::Checkbox("Push Group", &ShowPushGroup); ImGui::SameLine(); ImGui::Checkbox("Undefined Behavior", &ShowUndefinedBehavior);
ImGui::Checkbox("Pop Group", &ShowPopGroup); ImGui::SameLine(); ImGui::SameLine();
ImGui::Checkbox("Other", &ShowOther); ImGui::Checkbox("Portability", &ShowPortability);
ImGui::Checkbox("Performance", &ShowPerformance);
ImGui::SameLine();
ImGui::Checkbox("Marker", &ShowMarker);
ImGui::SameLine();
ImGui::Checkbox("Push Group", &ShowPushGroup);
ImGui::SameLine();
ImGui::Checkbox("Pop Group", &ShowPopGroup);
ImGui::SameLine();
ImGui::Checkbox("Other", &ShowOther);
Filter.Draw("Filter", -100.0f); Filter.Draw("Filter", -100.0f);
ImGui::Separator(); ImGui::Separator();
ImGui::BeginChild("scrolling", ImVec2(0,0), false, ImGuiWindowFlags_HorizontalScrollbar); ImGui::BeginChild("scrolling", ImVec2(0, 0), false, ImGuiWindowFlags_HorizontalScrollbar);
if (copy) ImGui::LogToClipboard(); if (copy)
ImGui::LogToClipboard();
if (Filter.IsActive()) if (Filter.IsActive())
{
const char *buf_begin = Buf.begin();
const char *line = buf_begin;
for (int line_no = 0; line != NULL; line_no++)
{ {
const char* buf_begin = Buf.begin(); const char *line_end = (line_no < LineOffsets.Size) ? buf_begin + LineOffsets[line_no] : NULL;
const char* line = buf_begin; if (Filter.PassFilter(line, line_end))
for (int line_no = 0; line != NULL; line_no++) ImGui::TextUnformatted(line, line_end);
{ line = line_end && line_end[1] ? line_end + 1 : NULL;
const char* line_end = (line_no < LineOffsets.Size) ? buf_begin + LineOffsets[line_no] : NULL;
if (Filter.PassFilter(line, line_end))
ImGui::TextUnformatted(line, line_end);
line = line_end && line_end[1] ? line_end + 1 : NULL;
}
} }
else
{
ImGui::TextUnformatted(Buf.begin());
}
if (ScrollToBottom)
ImGui::SetScrollHere(1.0f);
ScrollToBottom = false;
ImGui::EndChild();
ImGui::End();
} }
else
{
ImGui::TextUnformatted(Buf.begin());
}
if (ScrollToBottom)
ImGui::SetScrollHere(1.0f);
ScrollToBottom = false;
ImGui::EndChild();
ImGui::End();
}
#endif //NDEBUG #endif //NDEBUG
void APIENTRY Utility::openglCallbackFunction(GLenum source, void APIENTRY Utility::openglCallbackFunction(GLenum source,
GLenum type, GLenum type,
GLuint id, GLuint id,
GLenum severity, GLenum severity,
GLsizei length, GLsizei length,
const GLchar* message, const GLchar *message,
const void* userParam){ const void *userParam)
{
std::string _severity; std::string _severity;
switch (severity){ switch (severity)
{
case GL_DEBUG_SEVERITY_LOW: case GL_DEBUG_SEVERITY_LOW:
_severity = "LOW"; _severity = "LOW";
break; break;
@@ -97,48 +113,58 @@ void APIENTRY Utility::openglCallbackFunction(GLenum source,
break; break;
} }
switch (type) { switch (type)
{
case GL_DEBUG_TYPE_ERROR: case GL_DEBUG_TYPE_ERROR:
if(Utility::Debug::openGLLogger.ShowError) { if (Utility::Debug::openGLLogger.ShowError)
{
Debug::openGLLogger.AddLog("ERROR: %s ID: %d SEVERITY: %s\n", message, id, _severity.c_str()); Debug::openGLLogger.AddLog("ERROR: %s ID: %d SEVERITY: %s\n", message, id, _severity.c_str());
} }
break; break;
case GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR: case GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR:
if(Utility::Debug::openGLLogger.ShowDeprecatedBehavior) { if (Utility::Debug::openGLLogger.ShowDeprecatedBehavior)
{
Debug::openGLLogger.AddLog("DEPRECATED_BEHAVIOR: %s ID: %d SEVERITY: %s\n", message, id, _severity.c_str()); Debug::openGLLogger.AddLog("DEPRECATED_BEHAVIOR: %s ID: %d SEVERITY: %s\n", message, id, _severity.c_str());
} }
break; break;
case GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR: case GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR:
if(Utility::Debug::openGLLogger.ShowUndefinedBehavior) { if (Utility::Debug::openGLLogger.ShowUndefinedBehavior)
{
Debug::openGLLogger.AddLog("UNDEFINED_BEHAVIOR: %s ID: %d SEVERITY: %s\n", message, id, _severity.c_str()); Debug::openGLLogger.AddLog("UNDEFINED_BEHAVIOR: %s ID: %d SEVERITY: %s\n", message, id, _severity.c_str());
} }
break; break;
case GL_DEBUG_TYPE_PORTABILITY: case GL_DEBUG_TYPE_PORTABILITY:
if(Utility::Debug::openGLLogger.ShowPortability) { if (Utility::Debug::openGLLogger.ShowPortability)
{
Debug::openGLLogger.AddLog("PORTATBILITY: %s ID: %d SEVERITY: %s\n", message, id, _severity.c_str()); Debug::openGLLogger.AddLog("PORTATBILITY: %s ID: %d SEVERITY: %s\n", message, id, _severity.c_str());
} }
break; break;
case GL_DEBUG_TYPE_PERFORMANCE: case GL_DEBUG_TYPE_PERFORMANCE:
if(Utility::Debug::openGLLogger.ShowPerformance) { if (Utility::Debug::openGLLogger.ShowPerformance)
{
Debug::openGLLogger.AddLog("PERFORMANCE: %s ID: %d SEVERITY: %s\n", message, id, _severity.c_str()); Debug::openGLLogger.AddLog("PERFORMANCE: %s ID: %d SEVERITY: %s\n", message, id, _severity.c_str());
} }
break; break;
case GL_DEBUG_TYPE_OTHER: case GL_DEBUG_TYPE_OTHER:
if(Utility::Debug::openGLLogger.ShowOther) { if (Utility::Debug::openGLLogger.ShowOther)
{
Debug::openGLLogger.AddLog("OTHER: %s ID: %d SEVERITY: %s\n", message, id, _severity.c_str()); Debug::openGLLogger.AddLog("OTHER: %s ID: %d SEVERITY: %s\n", message, id, _severity.c_str());
} }
break; break;
} }
} }
static const char* Errornames[] = { "OpenGL", "SDL","GLEW", "Other" }; static const char *Errornames[] = {"OpenGL", "SDL", "GLEW", "Other"};
void Utility::printWarning(ERROR_TYPE type, std::string msg) { void Utility::printWarning(ERROR_TYPE type, std::string msg)
{
std::cout << "Warning[" << Errornames[type] << "]: " << msg << std::endl; std::cout << "Warning[" << Errornames[type] << "]: " << msg << std::endl;
} }
void Utility::printError(ERROR_TYPE type, std::string msg) { void Utility::printError(ERROR_TYPE type, std::string msg)
{
std::cout << "Error[" << Errornames[type] << "]: " << msg << std::endl; std::cout << "Error[" << Errornames[type] << "]: " << msg << std::endl;
} }
void Utility::printInfo(ERROR_TYPE type, std::string msg) { void Utility::printInfo(ERROR_TYPE type, std::string msg)
{
std::cout << "Info[" << Errornames[type] << "]: " << msg << std::endl; std::cout << "Info[" << Errornames[type] << "]: " << msg << std::endl;
} }

66
src/Utility.h
View File

@@ -7,13 +7,15 @@
#include <string> #include <string>
#ifndef NDEBUG #ifndef NDEBUG
#include "imgui.h" #include "imgui.h"
#endif #endif
namespace Utility{ namespace Utility
{
#ifndef NDEBUG #ifndef NDEBUG
namespace Debug { namespace Debug
{
// Usage: // Usage:
// static ExampleAppLog my_log; // static ExampleAppLog my_log;
@@ -21,43 +23,47 @@ namespace Debug {
// my_log.Draw("title"); // my_log.Draw("title");
struct ImGuiLogger struct ImGuiLogger
{ {
ImGuiTextBuffer Buf; ImGuiTextBuffer Buf;
ImGuiTextFilter Filter; ImGuiTextFilter Filter;
ImVector<int> LineOffsets; // Index to lines offset ImVector<int> LineOffsets; // Index to lines offset
bool ShowError; bool ShowError;
bool ShowDeprecatedBehavior; bool ShowDeprecatedBehavior;
bool ShowUndefinedBehavior; bool ShowUndefinedBehavior;
bool ShowPortability; bool ShowPortability;
bool ShowPerformance; bool ShowPerformance;
bool ShowMarker; bool ShowMarker;
bool ShowPushGroup; bool ShowPushGroup;
bool ShowPopGroup; bool ShowPopGroup;
bool ShowOther; bool ShowOther;
bool ScrollToBottom; bool ScrollToBottom;
ImGuiLogger() : ShowError(true) {} ImGuiLogger() : ShowError(true) {}
void Clear(); void Clear();
void AddLog(const char* fmt, ...) IM_FMTARGS(2); void AddLog(const char *fmt, ...) IM_FMTARGS(2);
void Draw(const char* title, bool* p_open = NULL); void Draw(const char *title, bool *p_open = NULL);
}; };
extern ImGuiLogger openGLLogger; extern ImGuiLogger openGLLogger;
} } // namespace Debug
#endif //NDEBUG #endif //NDEBUG
enum ERROR_TYPE { OpenGL = 0, SDL, GLEW, Other}; enum ERROR_TYPE
{
OpenGL = 0,
SDL,
GLEW,
Other
};
void APIENTRY openglCallbackFunction(GLenum source, void APIENTRY openglCallbackFunction(GLenum source,
GLenum type, GLenum type,
GLuint id, GLuint id,
GLenum severity, GLenum severity,
GLsizei length, GLsizei length,
const GLchar* message, const GLchar *message,
const void* userParam); const void *userParam);
void printWarning(ERROR_TYPE type, std::string msg); void printWarning(ERROR_TYPE type, std::string msg);
@@ -65,5 +71,5 @@ void printError(ERROR_TYPE type, std::string msg);
void printInfo(ERROR_TYPE type, std::string msg); void printInfo(ERROR_TYPE type, std::string msg);
} } // namespace Utility
#endif // UTILITY_H #endif // UTILITY_H

3
src/entities/components/Position.h
View File

@@ -1,7 +1,8 @@
#ifndef POSITION_H #ifndef POSITION_H
#define POSITION_H #define POSITION_H
struct Position { struct Position
{
Position(float x = 0.0f, float y = 0.0f) : x(x), y(y) {} Position(float x = 0.0f, float y = 0.0f) : x(x), y(y) {}
float x, y; float x, y;

15
src/input/Command.cpp
View File

@@ -2,22 +2,27 @@
#include "../DesktopLauncher.h" #include "../DesktopLauncher.h"
void QuitCommand::execute(OrtographicCamera& camera) { void QuitCommand::execute(OrtographicCamera &camera)
{
Game::exit(); Game::exit();
} }
void WCommand::execute(OrtographicCamera& camera) { void WCommand::execute(OrtographicCamera &camera)
{
camera.zoomIn(0.01f); camera.zoomIn(0.01f);
} }
void ACommand::execute(OrtographicCamera& camera) { void ACommand::execute(OrtographicCamera &camera)
{
camera.translate(glm::vec2(-0.1f, 0.0f)); camera.translate(glm::vec2(-0.1f, 0.0f));
} }
void SCommand::execute(OrtographicCamera& camera) { void SCommand::execute(OrtographicCamera &camera)
{
camera.zoomIn(-0.01f); camera.zoomIn(-0.01f);
} }
void DCommand::execute(OrtographicCamera& camera) { void DCommand::execute(OrtographicCamera &camera)
{
camera.translate(glm::vec2(0.1f, 0.0f)); camera.translate(glm::vec2(0.1f, 0.0f));
} }

43
src/input/Command.h
View File

@@ -3,33 +3,38 @@
#include "../Camera.h" #include "../Camera.h"
class Command { class Command
public: {
public:
virtual ~Command() {} virtual ~Command() {}
virtual void execute(OrtographicCamera& camera) = 0; virtual void execute(OrtographicCamera &camera) = 0;
}; };
class QuitCommand : public Command { class QuitCommand : public Command
public: {
virtual void execute(OrtographicCamera& camera) override; public:
virtual void execute(OrtographicCamera &camera) override;
}; };
class WCommand : public Command { class WCommand : public Command
public: {
virtual void execute(OrtographicCamera& camera) override; public:
virtual void execute(OrtographicCamera &camera) override;
}; };
class ACommand : public Command { class ACommand : public Command
public: {
virtual void execute(OrtographicCamera& camera) override; public:
virtual void execute(OrtographicCamera &camera) override;
}; };
class SCommand : public Command { class SCommand : public Command
public: {
virtual void execute(OrtographicCamera& camera) override; public:
virtual void execute(OrtographicCamera &camera) override;
}; };
class DCommand : public Command { class DCommand : public Command
public: {
virtual void execute(OrtographicCamera& camera) override; public:
virtual void execute(OrtographicCamera &camera) override;
}; };
#endif #endif

63
src/input/InputHandler.cpp
View File

@@ -2,7 +2,8 @@
#include <iostream> #include <iostream>
InputHandler::InputHandler() { InputHandler::InputHandler()
{
W = new WCommand(); W = new WCommand();
A = new ACommand(); A = new ACommand();
S = new SCommand(); S = new SCommand();
@@ -10,7 +11,8 @@ InputHandler::InputHandler() {
quit = new QuitCommand(); quit = new QuitCommand();
} }
InputHandler::~InputHandler() { InputHandler::~InputHandler()
{
//Free all Commands //Free all Commands
delete W; delete W;
delete A; delete A;
@@ -19,38 +21,43 @@ InputHandler::~InputHandler() {
delete quit; delete quit;
} }
Command* InputHandler::handleInput(SDL_Event *event) { Command *InputHandler::handleInput(SDL_Event *event)
if(event == NULL) { {
if (event == NULL)
{
return NULL; return NULL;
} }
switch (event->type) { switch (event->type)
case SDL_QUIT: {
return quit; case SDL_QUIT:
return quit;
break;
case SDL_KEYDOWN:
std::cout << "The Key " << SDL_GetKeyName(event->key.keysym.sym) << " has been pressed!" << std::endl;
return NULL;
break;
case SDL_KEYUP:
std::cout << "The Key " << SDL_GetKeyName(event->key.keysym.sym) << " has been released!" << std::endl;
switch (event->key.keysym.sym)
{
case SDLK_w:
return W;
break; break;
case SDL_KEYDOWN: case SDLK_a:
std::cout << "The Key " << SDL_GetKeyName(event->key.keysym.sym) << " has been pressed!" << std::endl; return A;
return NULL;
break; break;
case SDL_KEYUP: case SDLK_s:
std::cout << "The Key " << SDL_GetKeyName(event->key.keysym.sym) << " has been released!" << std::endl; return S;
switch(event->key.keysym.sym) { break;
case SDLK_w: case SDLK_d:
return W; return D;
break;
case SDLK_a:
return A;
break;
case SDLK_s:
return S;
break;
case SDLK_d:
return D;
break;
default: break;
}
return NULL;
break; break;
default: default:
break;
}
return NULL;
break;
default:
return NULL; return NULL;
break; break;
} }

19
src/input/InputHandler.h
View File

@@ -4,17 +4,18 @@
#include "Command.h" #include "Command.h"
class InputHandler { class InputHandler
public: {
public:
~InputHandler(); ~InputHandler();
InputHandler(); InputHandler();
Command* handleInput(SDL_Event *event); Command *handleInput(SDL_Event *event);
private: private:
Command* W; Command *W;
Command* A; Command *A;
Command* S; Command *S;
Command* D; Command *D;
Command* quit; Command *quit;
}; };
#endif #endif

78
src/screens/GameScreen.cpp
View File

@@ -4,76 +4,78 @@
#include <iostream> #include <iostream>
GameScreen::GameScreen(Renderer* renderer, Assets* assets) { GameScreen::GameScreen(Renderer *renderer, Assets *assets)
std::cout << "GameScreen got created!" << std::endl; {
this->renderer = renderer; std::cout << "GameScreen got created!" << std::endl;
this->assets = assets; this->renderer = renderer;
this->assets = assets;
//Vertex2D can be defined like this, because it an aggregate class. //Vertex2D can be defined like this, because it an aggregate class.
// see https://stackoverflow.com/questions/4178175/what-are-aggregates-and-pods-and-how-why-are-they-special // see https://stackoverflow.com/questions/4178175/what-are-aggregates-and-pods-and-how-why-are-they-special
std::vector<Vertex2D> vertices({ std::vector<Vertex2D> vertices({Vertex2D{glm::vec2(-0.5f, -0.5f), glm::vec2(0.0f, 1.0f)},
Vertex2D{glm::vec2(-0.5f,-0.5f), glm::vec2(0.0f,1.0f)}, Vertex2D{glm::vec2(0.5f, -0.5f), glm::vec2(1.0f, 1.0f)},
Vertex2D{glm::vec2(0.5f,-0.5f), glm::vec2(1.0f,1.0f)}, Vertex2D{glm::vec2(0.5f, 0.5f), glm::vec2(1.0f, 0.0f)},
Vertex2D{glm::vec2(0.5f,0.5f), glm::vec2(1.0f,0.0f)}, Vertex2D{glm::vec2(-0.5f, 0.5f), glm::vec2(0.0f, 0.0f)}});
Vertex2D{glm::vec2(-0.5f,0.5f), glm::vec2(0.0f,0.0f)}
});
std::vector<unsigned int> indices({ std::vector<unsigned int> indices({0, 1, 3,
0,1,3, 1, 2, 3});
1,2,3
});
obj = new Mesh(vertices,indices,assets->getTexture("police_officer")); obj = new Mesh(vertices, indices, assets->getTexture("police_officer"));
inputHandler = new InputHandler(); inputHandler = new InputHandler();
camera = new OrtographicCamera(); camera = new OrtographicCamera();
//Create Entities //Create Entities
//entityx::EntityX ex; //entityx::EntityX ex;
//entityx::Entity charakter = ex.entities.create(); //entityx::Entity charakter = ex.entities.create();
//charakter.assign<Position>(); //charakter.assign<Position>();
} }
GameScreen::~GameScreen() { GameScreen::~GameScreen()
delete camera; {
delete obj; delete camera;
delete obj;
delete inputHandler; delete inputHandler;
} }
void GameScreen::hide() { void GameScreen::hide()
{
} }
void GameScreen::pause() { void GameScreen::pause()
{
} }
void GameScreen::render() { void GameScreen::render()
//Drawing {
//Drawing
Shader defaultShader = assets->getShader("defaultShader"); Shader defaultShader = assets->getShader("defaultShader");
defaultShader.SetMatrix4("MVP",camera->getCombinedMatrix(),true); defaultShader.SetMatrix4("MVP", camera->getCombinedMatrix(), true);
//Draw Mesh //Draw Mesh
renderer->draw(*obj,defaultShader); renderer->draw(*obj, defaultShader);
} }
void GameScreen::update() { void GameScreen::update()
{
SDL_Event event; SDL_Event event;
while(SDL_PollEvent(&event) != 0) { while (SDL_PollEvent(&event) != 0)
Command* command = inputHandler->handleInput(&event); {
if (command) { Command *command = inputHandler->handleInput(&event);
if (command)
{
command->execute(*camera); command->execute(*camera);
} }
} }
} }
void GameScreen::resize() { void GameScreen::resize()
{
} }
void GameScreen::resume() { void GameScreen::resume()
{
} }
void GameScreen::show() { void GameScreen::show()
{
} }

15
src/screens/GameScreen.h
View File

@@ -8,9 +8,10 @@
#include "../Camera.h" #include "../Camera.h"
#include "../input/InputHandler.h" #include "../input/InputHandler.h"
class GameScreen : public Screen { class GameScreen : public Screen
public: {
GameScreen(Renderer* renderer, Assets* assets); public:
GameScreen(Renderer *renderer, Assets *assets);
~GameScreen(); ~GameScreen();
virtual void hide() override; virtual void hide() override;
@@ -21,10 +22,10 @@ class GameScreen : public Screen {
virtual void resume() override; virtual void resume() override;
virtual void show() override; virtual void show() override;
private: private:
Renderer* renderer; Renderer *renderer;
Assets* assets; Assets *assets;
InputHandler* inputHandler; InputHandler *inputHandler;
OrtographicCamera *camera; OrtographicCamera *camera;
Mesh *obj; Mesh *obj;

8
src/screens/Screen.h
View File

@@ -1,11 +1,12 @@
#ifndef SCREEN_H #ifndef SCREEN_H
#define SCREEN_H #define SCREEN_H
class Screen { class Screen
protected: {
protected:
Screen() {} Screen() {}
public: public:
virtual ~Screen() {} virtual ~Screen() {}
/* Called when this screen is no longer the current screen for a Game. */ /* Called when this screen is no longer the current screen for a Game. */
@@ -16,7 +17,6 @@ class Screen {
virtual void resize() = 0; virtual void resize() = 0;
virtual void resume() = 0; virtual void resume() = 0;
virtual void show() = 0; virtual void show() = 0;
}; };
#endif #endif