added uniforms

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;
-    glGenBuffers(1, &indexBuffer);
-    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBuffer);
-    glBufferData(GL_ELEMENT_ARRAY_BUFFER, numIndices * sizeof(indices[0]), indices, GL_STATIC_DRAW);
+    IndexBuffer indexBuffer(indices, numIndices, sizeof(indices[0]));
 
     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);