added uniforms

CMakeLists.txt

@@ -11,7 +11,10 @@ add_executable(${PROJECT_NAME} src/main.cpp
         include/VertexBuffer.hpp
         include/defines.hpp
         src/Shader.cpp
-        include/Shader.hpp)
+        include/Shader.hpp
+        include/IndexBuffer.hpp)
+
+target_compile_definitions(${PROJECT_NAME} PRIVATE $<$<CONFIG:Debug>:_DEBUG>)
 
 target_include_directories(${PROJECT_NAME} PRIVATE include)
 target_include_directories(${PROJECT_NAME} PRIVATE shaders)

include/IndexBuffer.hpp

@@ -0,0 +1,34 @@
+#pragma once
+#include <GL/glew.h>
+
+#include "defines.hpp"
+
+struct IndexBuffer {
+    IndexBuffer(void* data, uint32 numIndices, uint8 elementSize) {
+        glGenBuffers(1, &bufferId);
+        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, bufferId);
+        glBufferData(GL_ELEMENT_ARRAY_BUFFER, numIndices*elementSize, data, GL_STATIC_DRAW);
+
+        // POSITION
+        glEnableVertexAttribArray(0);
+        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*) offsetof(Vertex,x));
+        // COLOR
+        glEnableVertexAttribArray(1);
+        glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*) offsetof(Vertex,r));
+
+        glBindVertexArray(0);
+    };
+    virtual ~IndexBuffer() {
+        glDeleteBuffers(1, &bufferId);
+    }
+
+    void bind() {
+        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, bufferId);
+    }
+    void unbind() {
+        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
+    }
+
+private:
+    GLuint bufferId;
+};

include/Shader.hpp

@@ -10,6 +10,8 @@ struct Shader {
     void bind();
     void unbind();
 
+    GLuint getShaderId();
+
 private:
     GLuint compile(std::string shaderSource, GLenum shaderType);
     std::string parse(const char* filename);

shaders/basic.frag

@@ -4,6 +4,8 @@ layout(location = 0) out vec4 f_color;
 
 in vec4 v_color;
 
+uniform vec4 u_color;
+
 void main() {
-    f_color = v_color;
+    f_color = u_color;
 }

src/Shader.cpp

@@ -18,6 +18,10 @@ void Shader::unbind() {
     glUseProgram(0);
 }
 
+GLuint Shader::getShaderId() {
+    return this->shaderId;
+}
+
 GLuint Shader::compile(std::string shaderSource, GLenum shaderType) {
     GLuint id = glCreateShader(shaderType);
     const char* src = shaderSource.c_str();

src/main.cpp

@@ -2,12 +2,66 @@
 #define GLEW_STATIC
 #include <GL/glew.h>
 #define SDL_MAIN_HANDLED
+#include <cmath>
 #include <SDL3/SDL.h>
-
 #include "defines.hpp"
+#include "IndexBuffer.hpp"
 #include "VertexBuffer.hpp"
 #include "Shader.hpp"
 
+void openGLDebugCallback(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar* message, const void* userParam) {
+    if (severity == GL_DEBUG_SEVERITY_NOTIFICATION) return; //ignore notifications (mostly performance information)
+
+    std::cerr << "--------------------- OpenGL Debug Message ---------------------" << std::endl;
+    std::cerr << "Message:  " << message << std::endl;
+    std::cerr << "ID:       " << id << std::endl;
+
+    std::string sourceStr;
+    switch (source) {
+        case GL_DEBUG_SOURCE_API:             sourceStr = "API"; break;
+        case GL_DEBUG_SOURCE_WINDOW_SYSTEM:   sourceStr = "Window System"; break;
+        case GL_DEBUG_SOURCE_SHADER_COMPILER: sourceStr = "Shader Compiler"; break;
+        case GL_DEBUG_SOURCE_THIRD_PARTY:      sourceStr = "Third Party"; break;
+        case GL_DEBUG_SOURCE_APPLICATION:      sourceStr = "Application"; break;
+        case GL_DEBUG_SOURCE_OTHER:            sourceStr = "Other"; break;
+        default:                               sourceStr = "Unknown"; break;
+    }
+
+    std::string typeStr;
+    switch (type) {
+        case GL_DEBUG_TYPE_ERROR:               typeStr = "Error"; break;
+        case GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR: typeStr = "Deprecated Behavior"; break;
+        case GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR:  typeStr = "Undefined Behavior"; break;
+        case GL_DEBUG_TYPE_PORTABILITY:         typeStr = "Portability"; break;
+        case GL_DEBUG_TYPE_PERFORMANCE:         typeStr = "Performance"; break;
+        case GL_DEBUG_TYPE_MARKER:              typeStr = "Marker"; break;
+        case GL_DEBUG_TYPE_PUSH_GROUP:          typeStr = "Push Group"; break;
+        case GL_DEBUG_TYPE_POP_GROUP:           typeStr = "Pop Group"; break;
+        case GL_DEBUG_TYPE_OTHER:               typeStr = "Other"; break;
+        default:                                typeStr = "Unknown"; break;
+    }
+
+    std::string severityStr;
+    switch (severity) {
+        case GL_DEBUG_SEVERITY_HIGH:         severityStr = "HIGH"; break;
+        case GL_DEBUG_SEVERITY_MEDIUM:       severityStr = "MEDIUM"; break;
+        case GL_DEBUG_SEVERITY_LOW:          severityStr = "LOW"; break;
+        case GL_DEBUG_SEVERITY_NOTIFICATION: severityStr = "NOTIFICATION"; break;
+        default:                             severityStr = "UNKNOWN"; break;
+    }
+
+    std::cerr << "Source:   " << sourceStr << std::endl;
+    std::cerr << "Type:     " << typeStr << std::endl;
+    std::cerr << "Severity: " << severityStr << std::endl;
+    std::cerr << "---------------------------------------------------------------" << std::endl;
+
+    // Breakpoint
+    if (severity == GL_DEBUG_SEVERITY_HIGH) {
+        std::cerr << "Kritischer Fehler! Programm wird unterbrochen." << std::endl;
+        __builtin_trap(); // only for linux/gcc/clang
+    }
+}
+
 int main() {
     SDL_Init(SDL_INIT_VIDEO);
 
@@ -18,6 +72,10 @@ int main() {
     SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8);
     SDL_GL_SetAttribute(SDL_GL_BUFFER_SIZE, 32);
     SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
+    #ifdef _DEBUG
+    SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS, SDL_GL_CONTEXT_DEBUG_FLAG); //remove for stable release
+    #endif
+
 
     uint32 flags = SDL_WINDOW_OPENGL; //| SDL_WINDOW_FULLSCREEN;
 
@@ -35,6 +93,11 @@ int main() {
         return -1;
     }
     std::cout << "OpenGL Version: " << glGetString(GL_VERSION) << std::endl;
+    #ifdef _DEBUG
+    glEnable(GL_DEBUG_OUTPUT);
+    glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
+    glDebugMessageCallback(openGLDebugCallback, nullptr);
+    #endif
 
     Vertex vertices[] = {
         Vertex{-0.5f, -0.5f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f},
@@ -51,10 +114,7 @@ int main() {
     };
     uint32 numIndices = sizeof(indices) / sizeof(uint32);
 
-    GLuint indexBuffer;
+    IndexBuffer indexBuffer(indices, numIndices, sizeof(indices[0]));
-    glGenBuffers(1, &indexBuffer);
-    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBuffer);
-    glBufferData(GL_ELEMENT_ARRAY_BUFFER, numIndices * sizeof(indices[0]), indices, GL_STATIC_DRAW);
 
     VertexBuffer vertexBuffer(vertices, numVertices);
     vertexBuffer.unbind();
@@ -62,6 +122,11 @@ int main() {
     Shader shader("shaders/basic.vert", "shaders/basic.frag");
     shader.bind();
 
+    int colorUniformLocation = glGetUniformLocation(shader.getShaderId(), "u_color");
+    if (colorUniformLocation != 1) {
+        glUniform4f(colorUniformLocation, 1.0f, 0.0f, 1.0f, 1.0f);
+    }
+
     const uint64 perfCounterFrequency = SDL_GetPerformanceFrequency();
     uint64 lastCounter = SDL_GetPerformanceCounter();
     float32 delta = 0.0f;
@@ -69,17 +134,25 @@ int main() {
     // WIREFRAME
     //glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
 
+    float time = 0.0f;
+
     bool running = true;
     SDL_Event e;
     while (running) {
         glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
         glClear(GL_COLOR_BUFFER_BIT);
+        time += delta;
+
+        if (colorUniformLocation != 1) {
+            glUniform4f(colorUniformLocation, sinf(time)*sinf(time), 0.0f, 1.0f, 1.0f);
+        }
 
         // FRAME GENERATION
         vertexBuffer.bind();
-        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBuffer);
+        indexBuffer.bind();
         glDrawElements(GL_TRIANGLES, numIndices, GL_UNSIGNED_INT, 0);
         vertexBuffer.unbind();
+        indexBuffer.unbind();
 
         SDL_GL_SwapWindow(window);