feat: finish shader chapter

.vscode/tasks.json

@@ -15,10 +15,7 @@
                 "${workspaceFolder}/Engine/engine/glad.c",
                 "-o",
                 "${workspaceFolder}/Engine/engine/match", "-lglut", "-lglfw", "-lGLU", "-lGL", "-lm",
-                "-ldl",
+                "-ldl"
-                
-                 
-
             ],
             "options": {
                 "cwd": "${fileDirname}"

Engine/engine/Shaders/fragmentShaderTaskThree.fs

@@ -0,0 +1,7 @@
+#version 330 core
+out vec4 FragColor;
+in vec3 vertexColor; // from vertex
+void main()
+{
+    FragColor = vec4(vertexColor, 1.0);
+}

Engine/engine/Shaders/vertexShaderOffset.vs

@@ -0,0 +1,16 @@
+// In your vertex shader:
+// ======================
+#version 330 core
+layout (location = 0) in vec3 aPos;
+layout (location = 1) in vec3 aColor;
+
+out vec3 ourColor;
+
+uniform float xOffset;
+
+void main()
+{
+    gl_Position = vec4(aPos.x + xOffset, aPos.y, aPos.z, 1.0); // add the xOffset to the x position of the vertex position
+    ourColor = aColor;
+}
+

Engine/engine/Shaders/vertexShaderTaskThree.vs

@@ -0,0 +1,8 @@
+#version 330 core
+layout (location = 0) in vec3 aPos;
+out vec3 vertexColor; // output a color to fragment shader
+void main()
+{
+    gl_Position = vec4(aPos.x, aPos.y, aPos.z, 1.0);
+    vertexColor = aPos;
+}

Engine/engine/Shaders/vertexShaderUpsideDown.vs

@@ -0,0 +1,6 @@
+#version 330 core
+layout (location = 0) in vec3 aPos;
+void main()
+{
+    gl_Position = vec4(aPos.x, -aPos.y, aPos.z, 1.0);
+}

Engine/engine/constants.hpp

@@ -4,6 +4,7 @@
 #include <iostream>
 #include <string_view>
 
+
 namespace constants 
 {
     inline constexpr int GLFW_MAJOR_VERSION { 3 };
@@ -47,7 +48,13 @@ namespace constants
         "./Shaders/vertexShaderColor.vs"
     };
 
-    
+    inline const char* VERTEX_SHADER_UPSIDE_DOWN_FILENAME {
+        "./Shaders/vertexShaderUpsideDown.vs"
+    };
+
+        inline const char* VERTEX_SHADER_OFFSET_FILENAME {
+        "./Shaders/vertexShaderOffset.vs"
+    };
     
     // we write vertex shader 
     // version of glsl (since ogl 3.3 same as ogl so we pick 330)
@@ -77,6 +84,14 @@ namespace constants
         "./Shaders/vertexShaderVerticeColor.vs"
     };
 
+    inline const char* VERTEX_SHADER_TASK_THREE_FILENAME {
+        "./Shaders/vertexShaderTaskThree.vs"
+    };
+
+    inline const char* FRAGMENT_SHADER_TASK_THREE_FILENAME {
+        "./Shaders/fragmentShaderTaskThree.fs"
+    };
+
         // ... to fragment shader (vertexColor)
     inline const char *FRAGMENT_SHADER_COLOR_FROM_VERTEX {
         "#version 330 core\n"
@@ -219,7 +234,7 @@ namespace constants
 
     inline constexpr size_t SQUARE_VERTICES_SIZE = { sizeof(SQUARE_VERTICES) };
 
-    inline constexpr int MAX_DRAW_CALL = { 8 };
+    inline constexpr int MAX_DRAW_CALL = { 10 };
 
 }
 

Engine/engine/draw.cpp

@@ -16,30 +16,39 @@ int drawFigure(const int whatToDraw)
     switch (whatToDraw)
     {
     case 0:
-        return drawTriangleClass(constants::TRIANGLE_VERTICES, constants::TRIANGLE_VERTICES_SIZE, constants::VERTEX_SHADER_SOURCE_FILENAME, constants::FRAGMENT_SHADER_SOURCE_FILENAME, false);
+        return drawTriangleClass(constants::TRIANGLE_VERTICES, constants::TRIANGLE_VERTICES_SIZE, constants::VERTEX_SHADER_SOURCE_FILENAME, constants::FRAGMENT_SHADER_SOURCE_FILENAME);
     case 1:
         return drawSquareClass(constants::VERTEX_SHADER_SOURCE_FILENAME, constants::FRAGMENT_SHADER_SOURCE_FILENAME);
     case 2:
         // Try to draw 2 triangles next to each other using glDrawArrays by adding more vertices to your data.
-        return drawTriangleClass(constants::TRIANGLES_VERTICES, constants::TRIANGLES_VERTICES_SIZE, constants::VERTEX_SHADER_SOURCE_FILENAME, constants::FRAGMENT_SHADER_SOURCE_FILENAME, false);
+        return drawTriangleClass(constants::TRIANGLES_VERTICES, constants::TRIANGLES_VERTICES_SIZE, constants::VERTEX_SHADER_SOURCE_FILENAME, constants::FRAGMENT_SHADER_SOURCE_FILENAME);
     case 3:
         // Now create the same 2 triangles using two different VAOs and VBOs for their data
-        return (drawTriangleClass(constants::TRIANGLE_ONE, constants::TRIANGLE_ONE_SIZE, constants::VERTEX_SHADER_SOURCE_FILENAME, constants::FRAGMENT_SHADER_SOURCE_FILENAME, false) == -1 || drawTriangleClass(constants::TRIANGLE_TWO, constants::TRIANGLE_TWO_SIZE, constants::VERTEX_SHADER_SOURCE_FILENAME, constants::FRAGMENT_SHADER_SOURCE_FILENAME, false) == -1);
+        return (drawTriangleClass(constants::TRIANGLE_ONE, constants::TRIANGLE_ONE_SIZE, constants::VERTEX_SHADER_SOURCE_FILENAME, constants::FRAGMENT_SHADER_SOURCE_FILENAME) == -1 || drawTriangleClass(constants::TRIANGLE_TWO, constants::TRIANGLE_TWO_SIZE, constants::VERTEX_SHADER_SOURCE_FILENAME, constants::FRAGMENT_SHADER_SOURCE_FILENAME) == -1);
     case 4:
         // Create two shader programs where the second program uses a different fragment shader that outputs the color yellow; draw both triangles again where one outputs the color yellow
-        return (drawTriangleClass(constants::TRIANGLE_ONE, constants::TRIANGLE_ONE_SIZE, constants::VERTEX_SHADER_SOURCE_FILENAME, constants::FRAGMENT_SHADER_SOURCE_FILENAME, false) == -1 || drawTriangleClass(constants::TRIANGLE_TWO, constants::TRIANGLE_TWO_SIZE, constants::VERTEX_SHADER_SOURCE_FILENAME, constants::FRAGMENT_SHADER_SOURCE_YELLOW_FILENAME, false) == -1);
+        return (drawTriangleClass(constants::TRIANGLE_ONE, constants::TRIANGLE_ONE_SIZE, constants::VERTEX_SHADER_SOURCE_FILENAME, constants::FRAGMENT_SHADER_SOURCE_FILENAME) == -1 || drawTriangleClass(constants::TRIANGLE_TWO, constants::TRIANGLE_TWO_SIZE, constants::VERTEX_SHADER_SOURCE_FILENAME, constants::FRAGMENT_SHADER_SOURCE_YELLOW_FILENAME) == -1);
     case 5:
         // Get color from vertex shader to fragment shader
-        return drawTriangleClass(constants::TRIANGLE_VERTICES, constants::TRIANGLE_VERTICES_SIZE, constants::VERTEX_SHADER_COLOR_FILENAME, constants::FRAGMENT_SHADER_COLOR_FROM_VERTEX_FILENAME, false);
+        return drawTriangleClass(constants::TRIANGLE_VERTICES, constants::TRIANGLE_VERTICES_SIZE, constants::VERTEX_SHADER_COLOR_FILENAME, constants::FRAGMENT_SHADER_COLOR_FROM_VERTEX_FILENAME);
     case 6:
         // set color from opengl code to uniform value in fragment shader
-        return drawTriangleClass(constants::TRIANGLE_VERTICES, constants::TRIANGLE_VERTICES_SIZE, constants::VERTEX_SHADER_COLOR_FILENAME, constants::FRAGMENT_SHADER_UNIFORMS_FILENAME, false);
+        return drawTriangleClass(constants::TRIANGLE_VERTICES, constants::TRIANGLE_VERTICES_SIZE, constants::VERTEX_SHADER_COLOR_FILENAME, constants::FRAGMENT_SHADER_UNIFORMS_FILENAME);
     case 7:
         // set color from opengl code to uniform value in fragment shader
         return drawTriangleClass(constants::TRIANGLE_COLORS, constants::TRIANGLE_COLORS_SIZE, constants::VERTEX_SHADER_VERTICE_COLOR_FILENAME, constants::FRAGMENT_SHADER_COLOR_FROM_VERTEX_FILENAME, true);
+    case 8:
+        // upside down triangle
+        return drawTriangleClass(constants::TRIANGLE_VERTICES, constants::TRIANGLE_VERTICES_SIZE, constants::VERTEX_SHADER_UPSIDE_DOWN_FILENAME, constants::FRAGMENT_SHADER_SOURCE_FILENAME);
+    case 9:
+    {
+        // offset triangle
+        offsetsStruct offsets = offsetsStruct();
+        offsets.xOffset = 0.5f;
+        return drawTriangleClass(constants::TRIANGLE_VERTICES, constants::TRIANGLE_VERTICES_SIZE, constants::VERTEX_SHADER_OFFSET_FILENAME, constants::FRAGMENT_SHADER_SOURCE_FILENAME, false, offsets);
+    }
     case constants::MAX_DRAW_CALL:
-        // set color from opengl code to uniform value in fragment shader
+        return drawTriangleClass(constants::TRIANGLE_VERTICES, constants::TRIANGLE_VERTICES_SIZE, constants::VERTEX_SHADER_TASK_THREE_FILENAME, constants::FRAGMENT_SHADER_TASK_THREE_FILENAME);
-        return drawTriangleClass(constants::TRIANGLE_VERTICES, constants::TRIANGLE_VERTICES_SIZE, constants::VERTEX_SHADER_SOURCE_FILENAME, constants::FRAGMENT_SHADER_SOURCE_FILENAME, false);
     default:
         throw "No function for this draw call";
     }
@@ -57,10 +66,22 @@ unsigned int getShaderProgram(const char* vertexShaderSource, const char* fragme
     return shaderProgram;
 }
 
-int drawTriangleClass(const float triangleVertices[], const size_t triangleVerticesSize, const char* vertexPath, const char* fragmentPath, const bool colorIncluded) 
+void setOffsets(Shader shader, const offsetsStruct offsets) {
+    shader.setFloat("xOffset", offsets.xOffset);
+    shader.setFloat("yOffset", offsets.yOffset);
+    shader.setFloat("zOffset", offsets.zOffset);
+}
+
+int drawTriangleClass(const float triangleVertices[], const size_t triangleVerticesSize, const char* vertexPath, const char* fragmentPath, const bool colorIncluded, const offsetsStruct offsets) 
 {
+    // In your CPP file:
+    // ======================
+    // float offset = 0.5f;
+
     Shader ourShader(vertexPath, fragmentPath);
     ourShader.use();
+    setOffsets(ourShader, offsets);
+
     const unsigned int vertexBufferObject = copyVerticesMemory(triangleVertices, triangleVerticesSize, GL_ARRAY_BUFFER);
     const unsigned int vertexArrayObject = generateBindVAO();
     copyVerticesArray(vertexBufferObject, triangleVertices, triangleVerticesSize, GL_ARRAY_BUFFER);

Engine/engine/draw.hpp

@@ -4,12 +4,17 @@
 #include <GLFW/glfw3.h>
 #include <string>
 
+struct offsetsStruct {
+    offsetsStruct(): xOffset(0), yOffset(0), zOffset(0) { }
+    float xOffset, yOffset, zOffset;
+};
+
 int drawFigure(const int whatToDraw);
 int drawSquare(const char* vertexShaderSource, const char* fragmentShaderSource);
 int drawSquareClass(const char* vertexPath, const char* fragmentPath);
 void doDrawElements(const unsigned int shaderProgram, const unsigned int vertexArrayObject, const GLenum drawArrayMode, const GLenum drawType, const int numberOfElementsToDraw);
 int drawTriangle(const float triangleVertices[], const size_t triangleVerticesSize, const char* vertexShaderSource, const char* fragmentShaderSource, const bool colorIncluded);
-int drawTriangleClass(const float triangleVertices[], const size_t triangleVerticesSize, const char* vertexPath, const char* fragmentPath, const bool colorIncluded);
+int drawTriangleClass(const float triangleVertices[], const size_t triangleVerticesSize, const char* vertexPath, const char* fragmentPath, const bool colorIncluded = false, const offsetsStruct offsets = offsetsStruct());
 void updateUniformColor(const unsigned int shaderProgram, const GLchar* uniformName);
 void doDrawArrays(const unsigned int shaderProgram, const unsigned int vertexArrayObject, const GLenum drawArrayMode, const int firstIndex, const unsigned int numberOfIndicesToBeRendered );
 unsigned int drawSquareShaderProgram(const char* vertexShaderSource, const char* fragmentShaderSource);

Engine/engine/shader.hpp

@@ -31,5 +31,6 @@ private:
     // utility function for checking shader compilation/linking errors.
     // ------------------------------------------------------------------------
     void checkCompileErrors(unsigned int shader, std::string type);
+    void compileErrorsMessage(const unsigned int shader, const bool compilation, const std::string type, const std::string errorMessage);
 };
 #endif