Nothing on screen after rendering OpenGL - c++

Question

I'm using my Macbook with Xcode and OpenGL (coding using C++) to learn how to add cameras to a graphic. Here I want to add a camera behind an object as a third-person view camera, and then use the 'WASD' buttons to move the object and use the mouse cursor to change the object's direction while the camera remains behind the object. But nothing is being drawn in the window, and I get no errors from Xcode. I have no idea where I'm going wrong.
My code is:
#include <iostream>
#include <string>
#define GLEW_STATIC
#include <GL/glew.h>
#include <GLFW/glfw3.h>
#include <glm/glm.hpp>
#include <glm/ext.hpp>
#include <glm/gtx/string_cast.hpp>
GLFWwindow* window = NULL;
const char* WINDOW_TITLE = "GRA_Tutorial";
const GLint WINDOW_WIDTH = 800;
const GLint WINDOW_HEIGHT = 600;
bool initOpenGL();
void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods);
void drawSolidCube(float r);
//cube key control boolean
bool wKey, sKey, aKey, dKey;
static void error_callback(int error, const char* description)
{
fprintf(stderr, "Error: %s\n", description);
}
int main()
{
std::cout << "GRA_Tutorial!" << std::endl;
if (!initOpenGL())
{
std::cerr << "GLFW initialisation failed." << std::endl;
return -1;
}
/* Enable depth testing */
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LESS);
/* Enable back-face culling */
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
/* Enable transparency blending */
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
/* Choose a colour to clear the screen (RGBA range [0, 1]) */
glClearColor(0.4f, 0.5f, 0.6f, 1.0f);
/* Cube */
float cubeSize = 0.5f;
glm::vec3 cube_pos = glm::vec3(0.f, 0.f, -2.f); // Position in World Space
glm::vec3 cube_head = glm::vec3(0.f, 0.f, 1.f);
glm::vec3 cube_fixup = glm::vec3(0.f, 1.f, 0.f);
glm::vec3 cube_up = cube_fixup;
glm::vec3 cube_direction;
glm::vec3 cube_right;
glm::mat4 cube_rotation;
/* Set mouse start position at centre of window */
glfwSetCursorPos(window, WINDOW_WIDTH / 2, WINDOW_HEIGHT / 2);
double mouseX, mouseY;
glfwGetCursorPos(window, &mouseX, &mouseY);
glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_HIDDEN);
float sensitivity = 0.01f;
float cubeSpeed = 0.001f;
//camera
/* Vectors containing eye coordinates */
glm::vec3 pos;
/* Loop until the user closes the window */
while (!glfwWindowShouldClose(window))
{
/* Render here */
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
/* Projection */
glViewport(0, 0, WINDOW_WIDTH, WINDOW_HEIGHT);
glMatrixMode(GL_PROJECTION); // switch from model/view to projection mode
glLoadIdentity(); // reset matrix
/* Perspective projection */
float aspectRatio = static_cast<GLdouble>(WINDOW_WIDTH) / static_cast<GLdouble>(WINDOW_HEIGHT);
//gluPerspective(60.0, aspect, 1.0, 1000.0);
float znear = 0.1f;
float zfar = 1000.f;
float fovyInDegrees = 60.f;
glm::mat4 proj = glm::perspective(glm::radians(fovyInDegrees), aspectRatio, znear, zfar);
float* matProjectionArray = glm::value_ptr(proj);
glLoadMatrixf(matProjectionArray);
/* Set modelview matrix as the current matrix */
glMatrixMode(GL_MODELVIEW);
/* Reset the current matrix */
glLoadIdentity();
/* Camera */
pos = cube_pos + (cube_up* 1.f) + (cube_direction * -2.f);
glm::vec3 cameraDirection = glm::normalize(cube_direction);
glm::vec3 up = glm::vec3(0.0f, 1.0f, 0.0f);
glm::vec3 cameraRight = glm::normalize(glm::cross(up, cameraDirection));
glm::vec3 cameraUp = glm::cross(cameraDirection, cameraRight);
glm::mat4 view = glm::mat4(
cameraRight[0], cameraUp[0], -cameraDirection[0], 0.0f,
cameraRight[1], cameraUp[1], -cameraDirection[1], 0.0f,
cameraRight[2], cameraUp[2], -cameraDirection[2], 0.0f,
0.0f, 0.0f, 0.0f, 1.0f
);
view = glm::translate(view, -pos);
float* viewArray = glm::value_ptr(view);
glLoadMatrixf(viewArray);
/* Cube */
cube_direction = glm::normalize(cube_head);
cube_right = glm::normalize(glm::cross(cube_fixup, cube_direction));
cube_up = glm::cross(cube_direction, cube_right);
cube_rotation = glm::mat4(
-cube_right[0], -cube_right[1], -cube_right[2], 0.0f,
cube_up[0], cube_up[1], cube_up[2], 0.0f,
-cube_direction[0], -cube_direction[1], -cube_direction[2], 0.0f,
0.0f, 0.0f, 0.0f, 1.0f
);
// Mouse input
double xpos, ypos;
glfwGetCursorPos(window, &xpos, &ypos);
cube_head = cube_head + cube_right * (float)((xpos - mouseX) * sensitivity);
cube_head = cube_head + cube_up * (float)(-(ypos - mouseY) * sensitivity);
mouseX = xpos;
mouseY = ypos;
// Key input
if (wKey)
{
cube_pos = cube_pos + cube_direction * cubeSpeed;
}
if (sKey)
{
cube_pos = cube_pos + cube_direction * -cubeSpeed;
}
if (aKey)
{
cube_pos = cube_pos + cube_right * -cubeSpeed;
}
if (dKey)
{
cube_pos = cube_pos + cube_right * cubeSpeed;
}
glPushMatrix(); // save transformation state
//Do not add translate into rotation matrix as this will translate object origin coordinate
//cube_rotation = glm::translate(p1_rotation, p1_pos);
glTranslatef(cube_pos[0], cube_pos[1], cube_pos[2]); // Apply translation
glMultMatrixf(glm::value_ptr(cube_rotation)); // Apply rotation
drawSolidCube(cubeSize); // draw a cube
glPopMatrix(); // restore transformation state
glPushMatrix();
drawSolidCube(cubeSize); // draw a stationary cube for comparison
glPopMatrix();
/* Swap front and back buffers */
glfwSwapBuffers(window);
/* Poll for and process events */
glfwPollEvents();
}
glfwTerminate();
return 0;
}
bool initOpenGL()
{
/* Initialize the GLFW library */
if (!glfwInit()) {
std::cout << "GLFW initialisation failed." << std::endl;
return false;
}
glfwSetErrorCallback(error_callback);
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_COMPAT_PROFILE);
/* For macOS uncomment the following line */
//glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
/* Create a windowed mode window and its OpenGL context */
window = glfwCreateWindow(WINDOW_WIDTH, WINDOW_HEIGHT, WINDOW_TITLE, NULL, NULL);
if (!window)
{
std::cout << "GLFW failed to create window." << std::endl;
glfwTerminate();
return false;
}
/* Make the window's context current */
glfwMakeContextCurrent(window);
glfwSetKeyCallback(window, key_callback);
/* Initialize the GLEW library */
glewExperimental = GL_TRUE;
GLenum err = glewInit();
if (err != GLEW_OK)
{
/* Problem: glewInit failed, something is seriously wrong */
std::cout << "GLEW initialisation failed: " << glewGetErrorString(err) << std::endl;
return false;
}
std::cout << "Status: Using GLEW " << glewGetString(GLEW_VERSION) << std::endl;
return true;
}
void drawSolidCube(float r)
{
glBegin(GL_QUADS);
// Back face (z = r)
glColor4f(1.0f, 0.0f, 0.0f, 0.5f); // Red
glVertex3f(r, r, r);
glVertex3f(r, -r, r);
glVertex3f(-r, -r, r);
glVertex3f(-r, r, r);
// Near face (z = -r)
glColor4f(0.0f, 1.0f, 0.0f, 0.5f); // Green
glVertex3f(r, r, -r);
glVertex3f(-r, r, -r);
glVertex3f(-r, -r, -r);
glVertex3f(r, -r, -r);
// Right face (x = r)
glColor4f(0.0f, 0.0f, 1.0f, 0.5f); // Blue
glVertex3f(r, r, r);
glVertex3f(r, r, -r);
glVertex3f(r, -r, -r);
glVertex3f(r, -r, r);
// Left face (x = -r)
glColor4f(1.0f, 1.0f, 0.0f, 0.5f); // Yellow
glVertex3f(-r, r, r);
glVertex3f(-r, -r, r);
glVertex3f(-r, -r, -r);
glVertex3f(-r, r, -r);
// Top face (y = r)
glColor4f(1.0f, 0.0f, 1.0f, 0.5f); // Magenta
glVertex3f(r, r, r);
glVertex3f(-r, r, r);
glVertex3f(-r, r, -r);
glVertex3f(r, r, -r);
// Bottom face (y = -r)
glColor4f(0.0f, 1.0f, 1.0f, 0.5f); // Cyan
glVertex3f(r, -r, r);
glVertex3f(r, -r, -r);
glVertex3f(-r, -r, -r);
glVertex3f(-r, -r, r);
glEnd();
}
void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods)
{
if (key == GLFW_KEY_ESCAPE && action == GLFW_PRESS)
{
std::cout << "Esc key is pressed." << std::endl;
glfwSetWindowShouldClose(window, GL_TRUE);
}
if (key == GLFW_KEY_W && action == GLFW_PRESS)
{
wKey = true;
}
if (key == GLFW_KEY_W && action == GLFW_RELEASE)
{
wKey = false;
}
if (key == GLFW_KEY_S && action == GLFW_PRESS)
{
sKey = true;
}
if (key == GLFW_KEY_S && action == GLFW_RELEASE)
{
sKey = false;
}
if (key == GLFW_KEY_A && action == GLFW_PRESS)
{
aKey = true;
}
if (key == GLFW_KEY_A && action == GLFW_RELEASE)
{
aKey = false;
}
if (key == GLFW_KEY_D && action == GLFW_PRESS)
{
dKey = true;
}
if (key == GLFW_KEY_D && action == GLFW_RELEASE)
{
dKey = false;
}
if (key == GLFW_KEY_SPACE && action == GLFW_PRESS)
{
glLoadIdentity();
}
}