abstracted shader from material

It will be useful when it comes to postprocessing

CMakeLists.txt

@@ -18,7 +18,9 @@ add_executable(featherGL ${SRCS}
         core/Transformable.h
         core/Settings.h
         core/Settings.cpp
-        core/lights/DebugLight.h)
+        core/lights/DebugLight.h
+        core/PostProcess.h
+        core/Shader.h)
 
 file(COPY assets DESTINATION ${CMAKE_BINARY_DIR})
 

assets/shaders/invertPostProcess/fragment.glsl

@@ -0,0 +1,10 @@
+out vec4 frag_color;
+in vec2 vUV;
+
+uniform sampler2D screenTexture;
+
+void main() {
+    vec4 screenColor = texture(screenTexture, vUV);
+    vec3 color = vec3(1.0) - screenColor.rgb;
+    frag_color = vec4(color, screenColor.a);
+}

core/Engine.cpp

@@ -78,6 +78,7 @@ Engine::Engine(int windowWidth, int windowHeight, const char *name = "Feather Pr
 
     setClearColor(0.1f, 0.1f, 0.1f, 1.0f);
 
+    glEnable(GL_FRAMEBUFFER_SRGB);
     glDepthFunc(GL_LESS);   // Specify the depth test for the z-buffer
     glEnable(GL_DEPTH_TEST);      // Enable the z-buffer test in the rasterization
     glEnable(GL_BLEND);

core/PostProcess.h

@@ -0,0 +1,12 @@
+//
+// Created by barth on 27/09/23.
+//
+
+#ifndef FEATHERGL_POSTPROCESS_H
+#define FEATHERGL_POSTPROCESS_H
+
+class PostProcess {
+
+};
+
+#endif //FEATHERGL_POSTPROCESS_H

core/Shader.h

@@ -0,0 +1,112 @@
+//
+// Created by barth on 27/09/23.
+//
+
+#ifndef FEATHERGL_SHADER_H
+#define FEATHERGL_SHADER_H
+
+#include <string>
+#include <glm/fwd.hpp>
+#include <glm/gtc/type_ptr.hpp>
+#include <iostream>
+#include "glad/glad.h"
+#include "Observable.h"
+#include "Texture.h"
+
+class Shader {
+public:
+    explicit Shader(const char *shaderFolder) {
+        std::string vertexPath;
+        vertexPath.append(shaderFolder);
+        vertexPath += "/vertex.glsl";
+
+        std::string fragmentPath;
+        fragmentPath.append(shaderFolder);
+        fragmentPath += "/fragment.glsl";
+
+        loadFileToBuffer(vertexPath.c_str(), _vertexShaderCode);
+        loadFileToBuffer(fragmentPath.c_str(), _fragmentShaderCode);
+    }
+
+    void compile() {
+        _program = glCreateProgram();
+
+        std::string versionedVertexShaderCode = "#version 400\n" + _vertexShaderCode;
+        std::string versionedFragmentShaderCode = "#version 400\n" + _fragmentShaderCode;
+
+
+        GLuint vs = glCreateShader(GL_VERTEX_SHADER);
+        const char *vertexShaderCString = versionedVertexShaderCode.c_str();
+        glShaderSource(vs, 1, &vertexShaderCString, nullptr);
+        glCompileShader(vs);
+
+        GLint success;
+        GLchar infoLog[512];
+        glGetShaderiv(vs, GL_COMPILE_STATUS, &success);
+        if (!success) {
+            glGetShaderInfoLog(vs, 512, nullptr, infoLog);
+            std::cout << "ERROR in compiling GL_VERTEX_SHADER\n" << infoLog << std::endl;
+        }
+
+
+        GLuint fs = glCreateShader(GL_FRAGMENT_SHADER);
+        const char *fragmentShaderCString = versionedFragmentShaderCode.c_str();
+        glShaderSource(fs, 1, &fragmentShaderCString, nullptr);
+        glCompileShader(fs);
+
+        glGetShaderiv(fs, GL_COMPILE_STATUS, &success);
+        if (!success) {
+            glGetShaderInfoLog(fs, 512, nullptr, infoLog);
+            std::cout << "ERROR in compiling GL_FRAGMENT_SHADER\n" << infoLog << std::endl;
+        }
+
+        glAttachShader(_program, fs);
+        glAttachShader(_program, vs);
+        glLinkProgram(_program);
+    }
+
+    virtual void bind() {
+        glUseProgram(_program);
+        onBindObservable.notifyObservers();
+    }
+
+    virtual void unbind() {}
+
+    void setMat4(const char *uniformName, const glm::mat4 *matrix) const {
+        glUniformMatrix4fv(glGetUniformLocation(_program, uniformName), 1, GL_FALSE, glm::value_ptr(*matrix));
+    }
+
+    void setVec3(const char *uniformName, const glm::vec3 *vector) const {
+        glUniform3fv(glGetUniformLocation(_program, uniformName), 1, glm::value_ptr(*vector));
+    }
+
+    void setInt(const char *uniformName, int integer) const {
+        glUniform1i(glGetUniformLocation(_program, uniformName), integer);
+    }
+
+    void setFloat(const char *uniformName, float value) const {
+        glUniform1f(glGetUniformLocation(_program, uniformName), value);
+    }
+
+    void setBool(const char *uniformName, bool value) const {
+        glUniform1i(glGetUniformLocation(_program, uniformName), value);
+    }
+
+    void bindTexture(const char *uniformName, Texture *texture, int id) const {
+        glUniform1i(glGetUniformLocation(_program, uniformName), id);
+        texture->bind(id);
+    }
+
+    void setDefine(const char *defineName) {
+        _fragmentShaderCode = "#define " + std::string(defineName) + "\n" + _fragmentShaderCode;
+        _vertexShaderCode = "#define " + std::string(defineName) + "\n" + _vertexShaderCode;
+    }
+
+    Observable<> onBindObservable{};
+private:
+    GLuint _program{};
+    std::string _vertexShaderCode{};
+    std::string _fragmentShaderCode{};
+};
+
+#endif //FEATHERGL_SHADER_H

core/materials/Material.cpp

@@ -7,58 +7,10 @@
 #include "Material.h"
 #include "glad/glad.h"
 
-Material::Material(const char *shaderFolder) {
-    std::string vertexPath;
-    vertexPath.append(shaderFolder);
-    vertexPath += "/vertex.glsl";
-
-    std::string fragmentPath;
-    fragmentPath.append(shaderFolder);
-    fragmentPath += "/fragment.glsl";
-
-    loadFileToBuffer(vertexPath.c_str(), _vertexShaderCode);
-    loadFileToBuffer(fragmentPath.c_str(), _fragmentShaderCode);
-}
-
-void Material::compile() {
-    _program = glCreateProgram();
-
-    std::string versionedVertexShaderCode = "#version 400\n" + _vertexShaderCode;
-    std::string versionedFragmentShaderCode = "#version 400\n" + _fragmentShaderCode;
-
-
-    GLuint vs = glCreateShader(GL_VERTEX_SHADER);
-    const char *vertexShaderCString = versionedVertexShaderCode.c_str();
-    glShaderSource(vs, 1, &vertexShaderCString, nullptr);
-    glCompileShader(vs);
-
-    GLint success;
-    GLchar infoLog[512];
-    glGetShaderiv(vs, GL_COMPILE_STATUS, &success);
-    if (!success) {
-        glGetShaderInfoLog(vs, 512, nullptr, infoLog);
-        std::cout << "ERROR in compiling GL_VERTEX_SHADER\n" << infoLog << std::endl;
-    }
-
-
-    GLuint fs = glCreateShader(GL_FRAGMENT_SHADER);
-    const char *fragmentShaderCString = versionedFragmentShaderCode.c_str();
-    glShaderSource(fs, 1, &fragmentShaderCString, nullptr);
-    glCompileShader(fs);
-
-    glGetShaderiv(fs, GL_COMPILE_STATUS, &success);
-    if (!success) {
-        glGetShaderInfoLog(fs, 512, nullptr, infoLog);
-        std::cout << "ERROR in compiling GL_FRAGMENT_SHADER\n" << infoLog << std::endl;
-    }
-
-    glAttachShader(_program, fs);
-    glAttachShader(_program, vs);
-    glLinkProgram(_program);
-}
+Material::Material(const char *shaderFolder) : Shader(shaderFolder) {}
 
 void Material::bind() {
-    glUseProgram(_program);
+    Shader::bind();
 
     if (_isBackFaceCullingEnabled) {
         glEnable(GL_CULL_FACE); // Enables face culling (based on the orientation defined by the CW/CCW enumeration).
@@ -67,38 +19,4 @@ void Material::bind() {
     }
 
     glPolygonMode(GL_FRONT_AND_BACK, _isWireframe ? GL_LINE : GL_FILL);
-
-    onBindObservable.notifyObservers();
-}
-
-void Material::setMat4(const char *uniformName, const glm::mat4 *matrix) const {
-    glUniformMatrix4fv(glGetUniformLocation(_program, uniformName), 1, GL_FALSE, glm::value_ptr(*matrix));
-}
-
-void Material::setVec3(const char *uniformName, const glm::vec3 *vector) const {
-    glUniform3fv(glGetUniformLocation(_program, uniformName), 1, glm::value_ptr(*vector));
-}
-
-void Material::bindTexture(const char *uniformName, Texture *texture, int id) const {
-    glUniform1i(glGetUniformLocation(_program, uniformName), id);
-    texture->bind(id);
-}
-
-void Material::unbind() {}
-
-void Material::setDefine(const char *defineName) {
-    _fragmentShaderCode = "#define " + std::string(defineName) + "\n" + _fragmentShaderCode;
-    _vertexShaderCode = "#define " + std::string(defineName) + "\n" + _vertexShaderCode;
-}
-
-void Material::setInt(const char *uniformName, int integer) const {
-    glUniform1i(glGetUniformLocation(_program, uniformName), integer);
-}
-
-void Material::setFloat(const char *uniformName, float value) const {
-    glUniform1f(glGetUniformLocation(_program, uniformName), value);
-}
-
-void Material::setBool(const char *uniformName, bool value) const {
-    glUniform1i(glGetUniformLocation(_program, uniformName), value);
 }

core/materials/Material.h

@@ -11,30 +11,13 @@
 #include "glm/ext/matrix_float4x4.hpp"
 #include "Texture.h"
 #include "Observable.h"
+#include "Shader.h"
 
-class Material {
+class Material : public Shader {
 public:
     explicit Material(const char *shaderFolder);
 
-    void compile();
-
-    virtual void bind();
-
-    virtual void unbind();
-
-    void setMat4(const char *uniformName, const glm::mat4 *matrix) const;
-
-    void setVec3(const char *uniformName, const glm::vec3 *vector) const;
-
-    void setInt(const char *uniformName, int integer) const;
-
-    void setFloat(const char *uniformName, float value) const;
-
-    void setBool(const char *uniformName, bool value) const;
-
-    void bindTexture(const char *uniformName, Texture *texture, int id) const;
-
-    void setDefine(const char *defineName);
+    void bind() override;
 
     bool setWireframe(bool enabled) {
         _isWireframe = enabled;
@@ -52,13 +35,7 @@ class Material {
         _isBackFaceCullingEnabled = enabled;
     }
 
-    Observable<> onBindObservable{};
-
 private:
-    GLuint _program;
-    std::string _vertexShaderCode;
-    std::string _fragmentShaderCode;
-
     bool _isWireframe = false;
     bool _isBackFaceCullingEnabled = true;
 };