Fix multiple problems:

- update install instructions for MinGW (use x86_64 architecture)
- add #define GLM_ENABLE_EXPERIMENTAL for newer GLM versions
- fix GLM matrix initialization to identity matrix
- several small fixes

Author: kapecp

README.md

@@ -162,7 +162,7 @@ On Microsoft Windows you may try to open the `CMakeLists.txt` file with the late
 However the recommended way is to avoid Visual Studio and install [CLion IDE](https://www.jetbrains.com/clion/) and a __GCC__ based compiler:
 
 * Download and install [MinGW-w64](https://sourceforge.net/projects/mingw-w64/), this is the latest GCC compiler for Windows in a nice installer.
-* Make sure to install the __64bit version__, you need to manually switch this in the installer process. 
+* Make sure to install the __64bit version (select x86_64, NOT i686)__, you need to manually switch this in the installer process. 
 * To avoid issues with malformed paths also edit the installation destination to C:/mingw-w64 instead of Program Files.
 * Run CLion and select MinGW as the __toolchain__ when prompted (default is C:/mingw-w64/..)
 * Setup the rest of the settings as you see fit.

ppgso/image.cpp

@@ -1,8 +1,13 @@
+#include <algorithm>
 #include "image.h"
 
 using namespace std;
 using namespace ppgso;
 
+uint8_t clamp(float value) {
+  return (uint8_t) (std::min(std::max(value, 0.0f), 1.0f) * 255.0f);
+}
+
 Image::Image(int width, int height) : width{width}, height{height} {
   framebuffer.resize((size_t) (width * height));
 }
@@ -28,5 +33,5 @@ void Image::setPixel(int x, int y, int r, int g, int b) {
 }
 
 void Image::setPixel(int x, int y, float r, float g, float b) {
-  setPixel(x,y,{(uint8_t) (r * 255), (uint8_t) (g * 255), (uint8_t) (b * 255)});
+  setPixel(x,y,{clamp(r), clamp(g), clamp(b)});
 }

ppgso/ppgso.h

@@ -1,4 +1,5 @@
 #pragma once
+#define GLM_ENABLE_EXPERIMENTAL
 #include <glm/glm.hpp>
 #include <glm/gtc/random.hpp>
 #include <glm/gtx/compatibility.hpp>

ppgso/window.cpp

@@ -101,7 +101,7 @@ void Window::glfw_mouse_button_callback(GLFWwindow *window, int button, int acti
 }
 
 void Window::close() {
-  glfwSetWindowShouldClose(window, true);
+  glfwSetWindowShouldClose(window, GLFW_TRUE);
 }
 
 void Window::glfw_window_refresh_callback(GLFWwindow *window) {

shader/color_vert.glsl

@@ -1,7 +1,7 @@
 #version 330
 // The inputs will be fed by the vertex buffer objects
 layout(location = 0) in vec3 Position;
-in vec3 Color;
+layout(location = 4) in vec3 Color;
 
 // Matrices as program attributes
 uniform mat4 ProjectionMatrix;

src/gl1_gradient/gl1_gradient.cpp

@@ -27,7 +27,7 @@ class GradientWindow : public Window {
   vector<vec3> vertex_buffer{
       // x, y
       {0.0f, 0.8f, 0.0f},
-      {0.8f,  -0.8f, 0.0f}, 
+      {0.8f,  -0.8f, 0.0f},
       {-0.8f, -0.8f, 0.0f},
   };
 
@@ -76,9 +76,9 @@ class GradientWindow : public Window {
     glEnableVertexAttribArray(color_attrib);
 
     // Set Matrices to identity so there are no projections/transformations applied in the vertex shader
-    program.setUniform("ModelMatrix", mat4{});
-    program.setUniform("ViewMatrix", mat4{});
-    program.setUniform("ProjectionMatrix", mat4{});
+    program.setUniform("ModelMatrix", mat4{1.0f});
+    program.setUniform("ViewMatrix", mat4{1.0f});
+    program.setUniform("ProjectionMatrix", mat4{1.0f});
   }
 
   /*!
@@ -92,9 +92,9 @@ class GradientWindow : public Window {
   }
 
   /*!
-   * Window update implementation that will be called automatically from pollEvents
+   * Window refresh implementation that will be called automatically from pollEvents when needed
    */
-  void onIdle() override {
+  void onRefresh() override {
     // Set gray background
     glClearColor(.5, .5, .5, 0);
 

src/gl2_texture/gl2_texture.cpp

@@ -77,9 +77,9 @@ class TextureWindow : public Window {
     glBindTexture(GL_TEXTURE_2D, texture_id);
 
     // Set Matrices to identity so there are no projections/transformations applied in the vertex shader
-    program.setUniform("ModelMatrix", mat4{});
-    program.setUniform("ViewMatrix", mat4{});
-    program.setUniform("ProjectionMatrix", mat4{});
+    program.setUniform("ModelMatrix", mat4{1.0f});
+    program.setUniform("ViewMatrix", mat4{1.0f});
+    program.setUniform("ProjectionMatrix", mat4{1.0f});
   }
 
   /*!
@@ -90,9 +90,9 @@ class TextureWindow : public Window {
   }
 
   /*!
-   * Window update implementation that will be called automatically from pollEvents
+   * Window refresh implementation that will be called automatically from pollEvents when needed
    */
-  void onIdle() override {
+  void onRefresh() override {
     // Set gray background
     glClearColor(.5f, .5f, .5f, 0);
 

src/gl3_animate/gl3_animate.cpp

@@ -68,9 +68,9 @@ class AnimateWindow : public Window {
     program.setUniform("Texture", texture);
 
     // Set Matrices to identity so there are no projections/transformations applied in the vertex shader
-    program.setUniform("ModelMatrix", mat4{});
-    program.setUniform("ViewMatrix", mat4{});
-    program.setUniform("ProjectionMatrix", mat4{});
+    program.setUniform("ModelMatrix", mat4{1.0f});
+    program.setUniform("ViewMatrix", mat4{1.0f});
+    program.setUniform("ProjectionMatrix", mat4{1.0f});
   }
 
   /*!

src/gl4_transform/gl4_transform.cpp

@@ -107,14 +107,14 @@ class TransformWindow : public Window {
         });
 
       case Mode::ROTATE_TOP_LEFT:
-        return translate(mat4{}, vec3{-1, 1, 0})
-               * rotate(mat4{}, time, vec3{0, 0, 1})
-               * glm::translate(mat4{}, -vec3{-1, 1, 0});
+        return translate(mat4{1.0f}, vec3{-1, 1, 0})
+               * rotate(mat4{1.0f}, time, vec3{0, 0, 1})
+               * glm::translate(mat4{1.0f}, -vec3{-1, 1, 0});
 
       default:
         break;
     }
-    return mat4{};
+    return mat4{1.0f};
   }
 
 public:
@@ -125,8 +125,8 @@ class TransformWindow : public Window {
     // Set program input for texture uniform
     program.setUniform("Texture", texture);
     // Set Matrices to identity so there are no projections/transformations applied in the vertex shader
-    program.setUniform("ViewMatrix", mat4{});
-    program.setUniform("ProjectionMatrix", mat4{});
+    program.setUniform("ViewMatrix", mat4{1.0f});
+    program.setUniform("ProjectionMatrix", mat4{1.0f});
   }
 
   /*!

src/gl5_projection/gl5_projection.cpp

@@ -51,7 +51,7 @@ class ProjectionWindow : public Window {
         program.setUniform("ProjectionMatrix", perspective((PI / 180.f) * 60.0f, 1.0f, 0.1f, 10.0f));
 
         // Create view matrix (translate camera a bit backwards, so we can see the geometry)
-        program.setUniform("ViewMatrix", translate(mat4{}, {0.0f, 0.0f, -3.0f}));
+        program.setUniform("ViewMatrix", translate(mat4{1.0f}, {0.0f, 0.0f, -3.0f}));
         break;
       case Mode::PARALLEL:
         // Create projection matrix (field of view (radians), aspect ratio, near plane distance, far plane distance)
@@ -87,8 +87,8 @@ class ProjectionWindow : public Window {
 
     // Quad positions
     // Coordinates in world coordinates
-    quad1ModelMatrix = translate(mat4{}, {0, 0, 1});
-    quad2ModelMatrix = translate(mat4{}, {0, 0, -1});
+    quad1ModelMatrix = translate(mat4{1.0f}, {0, 0, 1});
+    quad2ModelMatrix = translate(mat4{1.0f}, {0, 0, -1});
   }
 
   /*!
@@ -112,7 +112,7 @@ class ProjectionWindow : public Window {
   void onIdle() override {
     // Update time and create a rotation matrix
     auto time = glfwGetTime();
-    auto rotateMat = rotate(mat4{}, (float)time, {0, 1, 0});
+    auto rotateMat = rotate(mat4{1.0f}, (float)time, {0, 1, 0});
 
     // Set up projection and view matrix
     setProjection();

src/gl6_mesh/gl6_mesh.cpp

@@ -91,12 +91,12 @@ class MeshWindow : public Window {
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
     // Create object matrices
-    auto cubeMat = rotate(mat4{}, time, {0.5f, 1.0f, 0.0f});
-    auto sphereMat = translate(mat4{}, {sin(time), cos(time), 0});
+    auto cubeMat = rotate(mat4{1.0f}, time, {0.5f, 1.0f, 0.0f});
+    auto sphereMat = translate(mat4{1.0f}, {sin(time), cos(time), 0});
     sphereMat = scale(sphereMat, {0.5f, 0.5f, 0.5f});
 
     // Camera position/rotation - for example, translate camera a bit backwards (positive value in Z axis), so we can see the objects
-    auto cameraMat = translate(mat4{}, {0.0f, 0.0f, -2.5f});
+    auto cameraMat = translate(mat4{1.0f}, {0.0f, 0.0f, -2.5f});
     program.setUniform("ViewMatrix", cameraMat);
 
     // Update camera position with perspective projection
@@ -117,7 +117,7 @@ class MeshWindow : public Window {
     program.setUniform("ProjectionMatrix", ortho(-1.0f, 1.0f, -1.0f, 1.0f, 1000.0f, -1000.0f));
 
     // Create object matrix
-    auto cursorMat =  translate(mat4{}, {cursorX, cursorY, 0.0f}) * scale(mat4{}, {0.1f, 0.1f, 0.1f});
+    auto cursorMat =  translate(mat4{1.0f}, {cursorX, cursorY, 0.0f}) * scale(mat4{1.0f}, {0.1f, 0.1f, 0.1f});
 
     // Render objects
     program.setUniform("Texture", cursorTexture);

src/gl7_diffuse/gl7_diffuse.cpp

@@ -30,7 +30,7 @@ class DiffuseWindow : public Window {
    */
   DiffuseWindow() : Window{"gl7_diffuse", SIZE, SIZE} {
     // Set camera position/rotation - for example, translate camera a bit backwards (positive value in Z axis), so we can see the objects
-    auto cameraMat = translate(mat4{}, {0.0f, 0.0f, -1.0f});
+    auto cameraMat = translate(mat4{1.0f}, {0.0f, 0.0f, -1.0f});
     program.setUniform("ViewMatrix", cameraMat);
 
     // Set camera position with perspective projection
@@ -81,7 +81,7 @@ class DiffuseWindow : public Window {
     auto time = glfwGetTime();
 
     // Create object matrix that rotates in time
-    auto sphereMat = rotate(mat4{}, (float)time, {0.5f, 1.0f, 0.0f});
+    auto sphereMat = rotate(mat4{1.0f}, (float)time, {0.5f, 1.0f, 0.0f});
 
     // Set the matrix as model matrix for current program
     program.setUniform("ModelMatrix", sphereMat);

src/gl8_framebuffer/gl8_framebuffer.cpp

@@ -100,10 +100,10 @@ class FramebufferWindow : public Window {
     auto sphereProjectionMatrix = perspective((PI / 180.f) * 60.0f, (float)SIZE/(float)SIZE, 1.0f, 10.0f);
 
     // Create view matrix (translate camera backwards a bit, so we can see the geometry)
-    auto sphereViewMatrix = translate(mat4(), {0.0f, 0.0f, -1.5f});
+    auto sphereViewMatrix = translate(mat4{1.0}, {0.0f, 0.0f, -1.5f});
 
     // Assign sphere texture
-    auto sphereModelMatrix = rotate(mat4{}, time, {0, 1, 0});
+    auto sphereModelMatrix = rotate(mat4{1.0f}, time, {0, 1, 0});
 
     // Set shader inputs
     sphereShader.use();
@@ -128,10 +128,10 @@ class FramebufferWindow : public Window {
     auto quadProjectionMatrix = perspective((PI / 180.f) * 60.0f, (float)SIZE/(float)SIZE, 1.0f, 10.0f);
 
     // Create view matrix (translate camera backwards a bit, so we can see the geometry)
-    auto quadViewMatrix = translate(mat4(), {0.0f, 0.0f, -3.0f});
+    auto quadViewMatrix = translate(mat4{1.0f}, {0.0f, 0.0f, -3.0f});
 
     // Animate rotation of the quad
-    auto quadModelMatrix = rotate(mat4{}, sin(time / 2.0f) * 1.5f, {0, 1, .1});
+    auto quadModelMatrix = rotate(mat4{1.0f}, sin(time / 2.0f) * 1.5f, {0, 1, .1});
 
     // Set shader inputs
     quadShader.use();

src/gl9_scene/object.cpp

@@ -1,3 +1,4 @@
+#define GLM_ENABLE_EXPERIMENTAL
 #include <glm/glm.hpp>
 #include <glm/gtc/matrix_transform.hpp>
 #include <glm/gtx/euler_angles.hpp>

src/gl9_scene/space.cpp

@@ -35,8 +35,8 @@ void Space::render(Scene &scene) {
 
   // Render mesh, not using any projections, we just render in 2D
   shader->setUniform("ModelMatrix", modelMatrix);
-  shader->setUniform("ViewMatrix", mat4{});
-  shader->setUniform("ProjectionMatrix", mat4{});
+  shader->setUniform("ViewMatrix", mat4{1.0f});
+  shader->setUniform("ProjectionMatrix", mat4{1.0f});
   shader->setUniform("Texture", *texture);
   mesh->render();
 

src/raw2_raycast/raw2_raycast.cpp

@@ -212,9 +212,7 @@ struct World {
     }
 
     // Additive lighting result
-    dvec3 color = ambientColor + emissionColor + diffuseColor + specularColor;
-
-    return clamp(color, 0.0, 1.0);
+    return ambientColor + emissionColor + diffuseColor + specularColor;
   }
 
   /*!
@@ -225,7 +223,7 @@ struct World {
     // Render section of the framebuffer
     for(int y = 0; y < image.height; ++y) {
       for (int x = 0; x < image.width; ++x) {
-        dvec3 color;
+        dvec3 color{};
         for (unsigned int i = 0; i < samples; i++) {
           auto ray = camera.generateRay(x, y, image.width, image.height);
           color = color + trace(ray);

src/raw3_raytrace/raw3_raytrace.cpp

@@ -223,15 +223,15 @@ struct World {
     #pragma omp parallel for
     for (int y = 0; y < image.height; ++y) {
       for (int x = 0; x < image.width; ++x) {
-        dvec3 color;
+        dvec3 color{};
 
         // Generate multiple samples
         for (unsigned int i = 0; i < samples; ++i) {
           auto ray = camera.generateRay(x, y, image.width, image.height);
           color = color + trace(ray, depth);
         }
         // Collect the data
-        color = clamp(color / (double) samples, 0.0, 1.0);
+        color = color / (double) samples;
         image.setPixel(x, y, (float)color.r, (float)color.g, (float)color.b);
       }
     }
@@ -266,7 +266,7 @@ int main() {
   };
 
   // Render the scene
-  world.render(image, 64, 5);
+  world.render(image, 32, 5);
 
   // Save the result
   image::saveBMP(image, "raw3_raytrace.bmp");

src/raw4_raster/raw4_raster.cpp

@@ -100,7 +100,7 @@ class Program {
     auto x = (int) (textCoord.x * (image.width - 1));
     auto y = (int) (textCoord.y * (image.height - 1));
     // NOTE: The coordinates are vertically inverted for compatibility with object files generated using Blender 3D.
-    auto pixel = image.getPixel(x, image.height-y-1);
+    auto pixel = image.getPixel(x, image.height-y);
     // Return normalized color vector
     return vec4{pixel.r / 255.0f, pixel.g / 255.0f, pixel.b / 255.0f, 1.0};
   }
@@ -122,7 +122,7 @@ class Rasterizer {
    */
   Vertex toViewport(const Vertex &vertex) {
     // Matrix that aligns the screen coordinates to viewport coordinates
-    static const mat4 viewportMatrix = glm::translate(glm::scale(mat4{}, vec3{image.width / 2.0, -image.height / 2.0, 1.0}), vec3{1, -1, 0});
+    static const mat4 viewportMatrix = glm::translate(glm::scale(mat4{1.0f}, vec3{image.width / 2.0, -image.height / 2.0, 1.0}), vec3{1, -1, 0});
     // First convert homogeneous coordinates to cartesian and transform to viewport
     vec4 viewportCoordinates = viewportMatrix * (vertex.position / vertex.position.w);
     // Copy rest of the data without change

src/task5_2dshapes/task5_2dshapes.cpp

@@ -6,6 +6,7 @@
 #include <iostream>
 #include <vector>
 
+#define GLM_ENABLE_EXPERIMENTAL
 #include <glm/glm.hpp>
 #include <glm/gtx/matrix_transform_2d.hpp>
 #include <glm/gtx/euler_angles.hpp>

src/task6_bezier_surface/task6_bezier_surface.cpp

@@ -7,6 +7,7 @@
 #include <iostream>
 #include <vector>
 
+#define GLM_ENABLE_EXPERIMENTAL
 #include <glm/glm.hpp>
 #include <glm/gtc/matrix_transform.hpp>
 #include <glm/gtx/euler_angles.hpp>

src/task7_particles/task7_particles.cpp

@@ -9,6 +9,7 @@
 #include <map>
 #include <list>
 
+#define GLM_ENABLE_EXPERIMENTAL
 #include <glm/glm.hpp>
 #include <glm/gtc/matrix_transform.hpp>
 #include <glm/gtx/euler_angles.hpp>