Projection and View Transformations with GLM

glm::mat4 glm::perspective(
    glm::radians(Fovy), // Zoom level (usually 90 to 30)
    aspect,		// Aspect ratio
    znear,		// Near clipping plane
    zfar		// Far clipping plane
);

glm::mat4 glm::lookAt(
    glm::vec3(x,y,z), // Camera position in world space
    glm::vec3(x,y,z), // Position the camera looks at
    glm::vec3(x,y,z)  // Up direction. Setting it to (0,1.0,0) makes the y-axis point up
);

/* C++ side */
// At initialization
// Get the handle of the uniform variable MVP
GLuint matrixID = glGetUniformLocation(shader, "MVP");

// Inside the loop (because the value to send may change as needed)
// Send the transformation matrix to the uniform variable "MVP" of the currently bound shader
// The fourth argument is the address of the first element of the matrix to send.
glUniformMatrix4fv(matrixID, 1, GL_FALSE, &mvpMat[0][0]);

/* GLSL side */
// This receives a 4x4 matrix.
// Other types work too, of course.
uniform mat4 MVP;

#include "stdafx.h"
#include <iostream>
#include <string>
#include <fstream>
#include <sstream>
#include <gl/glew.h>
#include <GLFW/glfw3.h>

// Include the GLM features we use
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>

//using namespace glm; would also work, but here we let only a few names skip "glm::"
using glm::vec3;
using glm::vec4;
using glm::mat4;

GLFWwindow* initGLFW(int width, int height)
{
    /*See an earlier article*/
}

int readShaderSource(GLuint shaderObj, std::string fileName)
{
    /*See an earlier article*/
}

GLint makeShader(std::string vertexFileName, std::string fragmentFileName)
{
    /*See an earlier article*/
}

int main()
{
    GLint width = 640, height = 480;
    GLFWwindow* window = initGLFW(width, height);

    GLint shader = makeShader("shader.vert", "shader.frag");

    GLuint matrixID = glGetUniformLocation(shader, "MVP");

    // Frame loop
    while (glfwWindowShouldClose(window) == GL_FALSE)
    {
        glUseProgram(shader);

        glEnable(GL_DEPTH_TEST);
        //glDepthFunc(GL_LESS);
        glClearColor(0.2f, 0.2f, 0.2f, 0.0f);
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

        // They hold the identity matrix when declared
        mat4 modelMat, viewMat, projectionMat;

        // Compute the view matrix
        viewMat = glm::lookAt(
            vec3(1.0, 2.0, 6.0), // Camera position in world space
            vec3(0.0, 0.0, 0.0), // Position the camera looks at
            vec3(0.0, 0.0, 1.0)  // Up direction. Setting it to (0,1.0,0) makes the y-axis point up
        );

        // Compute the projection matrix
        projectionMat = glm::perspective(
            glm::radians(45.0f), // Zoom level (usually 90 to 30)
            (GLfloat)width / (GLfloat)height,		// Aspect ratio
            0.1f,		// Near clipping plane
            100.0f		// Far clipping plane
        );

        // Compute the ModelViewProjection matrix
        mat4 mvpMat = projectionMat * viewMat* modelMat;

        // Send the transformation matrix to the uniform variable "MVP" of the currently bound shader
        // The fourth argument is the address of the first element of the matrix.
        glUniformMatrix4fv(matrixID, 1, GL_FALSE, &mvpMat[0][0]);

        // Send the data for a triangular pyramid made of four polygons
        vec3 position[4][3] = { 
            {vec3( 0, 0, 1),vec3(-1,-1, 0),vec3( 1, 0, 0)},
            {vec3( 0, 0, 1),vec3( 1, 0, 0),vec3( 0, 1, 0)},
            {vec3( 0, 0, 1),vec3( 0, 1, 0),vec3(-1,-1, 0)},
            {vec3(-1,-1, 0),vec3( 0, 1, 0),vec3( 1, 0, 0)} 
        };
        vec4 color[4] = { vec4(1,0,0,1), vec4(0,1,0,1), vec4(0,0,1,1), vec4(1,1,0,1)};
        for (int i = 0; i < 4; ++i)
        {
            glColor4f(color[i].r, color[i].g, color[i].b, color[i].a);
            glBegin(GL_TRIANGLES);
            glVertex3f(position[i][0].x, position[i][0].y, position[i][0].z);
            glVertex3f(position[i][1].x, position[i][1].y, position[i][1].z);
            glVertex3f(position[i][2].x, position[i][2].y, position[i][2].z);
            glEnd();
        }

        // Swap the double buffers
        glfwSwapBuffers(window);
        glfwPollEvents();
    }

    // Shut down GLFW
    glfwTerminate();

    return 0;
}

#version 120

//
// shader.vert
//

uniform mat4 MVP;

void main(void)
{
    gl_Position = MVP * gl_Vertex;
    gl_FrontColor = gl_Color;
}

#version 120
    
//
// shader.frag
//
    
void main(void)
{
    gl_FragColor = gl_Color;
}