Write an OpenGL program that display a rotating bunny.

1) Initially place a bunny 5 units along the x-axis at (5, 0, 0) of world coordinate system. This is already implemented in the provided starting code.

2) Draw a ground plane and xyz-axis of world coordinate system. Draw xyz axis from an arrow object. This is already implemented in the provided starting code.

3) Rotate the bunny around the global y-axis of world coordinate system (WCS) and at the same time rotate around its own x-axis of local coordinate system (LCS).

For the rotating bunny, do the following transformation in order:

a. rotate the bunny around its own x-axis of local coordinate system by 'a' degree; (grade: 4 points)

b. then rotate the bunny by 'b' degrees around the global y-axis of world coordinate system. (grade: 3 points)

Note that the rotation around its own x-axis will not change the center position of bunny. The center position of bunny is changed when it rotates around the global y-axis. Some implementation hints are given below.

4) The program should have user-interaction controls to allow users to interactively increase or decrease a and b. The controls can be buttons, checkboxes, mouse clicks, mouse motion, etc. as long as it is easy to use. (grade: 2 points)

5) Have a Reset button that can reset the bunny to the initial state, a to 0 and b to 0. (grade: 1 point)

A starting code (c++) animating a bunny has been provided. GUI is implemented by Nanogui and GLFW.

To build the code, the following libraries are needed: GLEW, GLFW, Nanogui.

Hints:

1. Every bunny transformation can be implemented by modifying the ModelView matrix in the OpenGL code. The ModelView matrix is used to transform the vertex coordinates from world coordinate system (WCS) to camera coordinate system (CCS).

2. How to rotate the bunny around its own x-axis of local coordinate system (LCS)? Here are some hints that you can consider:

a. Track the direction of the bunnys x-axis of LCS and represent it in WCS.

b. Construct a rotation matrix, with the rotation axis to be the bunnys x-axis and the rotation angle to be 'a' degree. Rodrigues rotation formula gives the form of this matrix.

c. The rotation pivot point is the origin of bunnys LCS, but not the origin of WCS. Think about how to make the bunny rotate around its own origin.

main.cpp

#include "Renderer.h"

int main() {

Renderer m_renderer;

m_renderer.run();

return EXIT_SUCCESS;

}

Animation.h

#pragma once

#include

#include

#include

#include

class Animation

{

public:

Animation();

~Animation();

void init();

void update(float delta_time);

void reset();

glm::mat4 get_model_mat() { return m_model_mat; };

private:

glm::mat4 m_model_mat;

};

Camera.h

#pragma once

#include

#include

#include

#include

enum Camera_Movement {

FORWARD,

BACKWARD,

LEFT,

RIGHT,

UP,

DOWN,

ROTATE_X_UP,

ROTATE_X_DOWN,

ROTATE_Y_UP,

ROTATE_Y_DOWN,

ROTATE_Z_UP,

ROTATE_Z_DOWN,

};

class Camera {

public:

// Camera view parameters

glm::vec3 ori_position;

glm::vec3 ori_front;

glm::vec3 ori_up;

glm::vec3 ori_right;

glm::vec3 position;

glm::vec3 front;

glm::vec3 up;

glm::vec3 right;

// Camera projection parameters

float ori_zoom;

float zoom;

float near;

float far;

unsigned int width;

unsigned int height;

// Camera projection matrix: used for projection

glm::mat4 proj_mat;

// Camera view matrix: used for changing camera rotation and position

glm::mat4 view_mat;

// Camera parameter initialization

Camera(

glm::vec3 position_ = glm::vec3(0, 1, 10),

glm::vec3 front_ = glm::vec3(0, 0, -1),

glm::vec3 up_ = glm::vec3(0, 1, 0),

glm::vec3 right_ = glm::vec3(1, 0, 0),

float zoom_ = 45.0,

float near_ = 0.1,

float far_ = 100,

unsigned int width_ = 1600,

unsigned int height_ = 900

)

{

this->ori_position = position_;

this->ori_front = front_;

this->ori_up = up_;

this->ori_right = right_;

this->ori_zoom = zoom_;

this->near = near_;

this->far = far_;

this->width = width_;

this->height = height_;

}

void init() {

reset();

};

void reset() {

this->position = ori_position;

this->front = ori_front;

this->up = ori_up;

this->right = ori_right;

this->zoom = ori_zoom;

}

void process_keyboard(Camera_Movement direction, GLfloat delta_time)

{

GLfloat velocity = delta_time;

if (direction == FORWARD)

this->position += this->front * velocity;

if (direction == BACKWARD)

this->position -= this->front * velocity;

if (direction == LEFT)

this->position -= this->right * velocity;

if (direction == RIGHT)

this->position += this->right * velocity;

if (direction == UP)

this->position += this->up * velocity;

if (direction == DOWN)

this->position -= this->up * velocity;

if (direction == ROTATE_X_UP)

rotate_x(velocity);

if (direction == ROTATE_X_DOWN)

rotate_x(-velocity);

if (direction == ROTATE_Y_UP)

rotate_y(velocity);

if (direction == ROTATE_Y_DOWN)

rotate_y(-velocity);

if (direction == ROTATE_Z_UP)

rotate_z(velocity);

if (direction == ROTATE_Z_DOWN)

rotate_z(-velocity);

}

// Rotate specific angle along local camera system(LCS)

void rotate_x(GLfloat angle)

{

glm::vec3 up = this->up;

glm::mat4 rotation_mat(1);

rotation_mat = glm::rotate(rotation_mat, angle, this->right);

this->up = glm::normalize(glm::vec3(rotation_mat * glm::vec4(up, 1.0)));

this->front = glm::normalize(glm::cross(this->up, this->right));

}

void rotate_y(GLfloat angle)

{

glm::vec3 front = this->front;

glm::mat4 rotation_mat(1);

rotation_mat = glm::rotate(rotation_mat, angle, this->up);

this->front = glm::normalize(glm::vec3(rotation_mat * glm::vec4(front, 1.0)));

this->right = glm::normalize(glm::cross(this->front, this->up));

}

void rotate_z(GLfloat angle)

{

glm::vec3 right = this->right;

glm::mat4 rotation_mat(1);

rotation_mat = glm::rotate(rotation_mat, angle, this->front);

this->right = glm::normalize(glm::vec3(rotation_mat * glm::vec4(right, 1.0)));

this->up = glm::normalize(glm::cross(this->right, this->front));

}

// Get camera view matrix

glm::mat4 get_view_mat()

{

this->view_mat = glm::lookAt(this->position, this->position + this->front, this->up);

return this->view_mat;

}

// Get camera projection matrix

glm::mat4 get_projection_mat()

{

this->proj_mat = glm::perspective(this->zoom, (GLfloat)this->width / (GLfloat)this->height, this->near, this->far);

return this->proj_mat;

}

};

Lighting.h

#pragma once

#include

#include

#include

class Lighting {

struct Direction_Light {

bool status;

glm::vec3 direction;

glm::vec4 ambient;

glm::vec4 diffuse;

glm::vec4 specular;

};

struct Point_Light {

bool status;

glm::vec3 position;

float constant;

float linear;

float quadratic;

glm::vec4 ambient;

glm::vec4 diffuse;

glm::vec4 specular;

};

public:

Direction_Light direction_light;

Point_Light point_light;

Lighting() {

}

~Lighting() {}

void init()

{

direction_light.status = true;

direction_light.direction = glm::vec3(0.0f, -1.0f, 0.0f);

direction_light.ambient = glm::vec4(0.1f, 0.1f, 0.1f, 1.0f);

direction_light.diffuse = glm::vec4(0.3f, 0.3f, 0.3f, 1.0f);

direction_light.specular = glm::vec4(0.0f, 0.0f, 0.0f, 1.0f);

point_light.status = true;

point_light.position = glm::vec3(1.2f, 1.0f, 2.0f);

point_light.ambient = glm::vec4(1.0f, 1.0f, 1.0f, 1.0f);

point_light.diffuse = glm::vec4(1.0f, 1.0f, 1.0f, 1.0f);

point_light.specular = glm::vec4(1.0f, 1.0f, 1.0f, 1.0f);

point_light.constant = 1.0f;

point_light.linear = 0.09f;

point_light.quadratic = 0.032f;

};

};

Object.h

#pragma once

#include

#include

#include

#include

#include

#include

#include

#include

#include

class Object

{

public:

struct Vertex {

// Position

glm::vec3 Position;

// Normal

glm::vec3 Normal;

// TexCoords

glm::vec2 TexCoords;

};

struct Vertex_Index {

int pos_idx;

int normal_idx;

int texcoord_idx;

};

struct Face_Index {

Vertex_Index vertex[3];

};

// veo and vao vector

std::vector vao_vertices;

std::vector veo_indices;

// obj original data vector

std::vector ori_positions;

std::vector ori_normals;

std::vector ori_texcoords;

// obj face index vector

std::vector indexed_faces;

glm::vec3 obj_center;

glm::vec4 obj_color = glm::vec4(0.7, 0.7, 0.7, 1.0);

GLfloat shininess = 32.0f;

std::string m_obj_path;

std::string obj_name;

GLuint vao, vbo;

public:

void load_obj(std::string obj_path)

{

int path_str_length = obj_path.size();

std::string suffix = obj_path.substr(path_str_length - 3, path_str_length);

if (suffix == "obj") {

this->vao_vertices.clear();

this->veo_indices.clear();

this->indexed_faces.clear();

this->ori_positions.clear();

this->ori_normals.clear();

this->ori_texcoords.clear();

std::ifstream ifs;

// Store original data vector

try {

ifs.open(obj_path);

std::string one_line;

while (getline(ifs, one_line)) {

std::stringstream ss(one_line);

std::string type;

ss >> type;

if (type == "v") {

glm::vec3 vert_pos;

ss >> vert_pos[0] >> vert_pos[1] >> vert_pos[2];

this->ori_positions.push_back(vert_pos);

}

else if (type == "vt") {

glm::vec2 tex_coord;

ss >> tex_coord[0] >> tex_coord[1];

this->ori_texcoords.push_back(tex_coord);

}

else if (type == "vn") {

glm::vec3 vert_norm;

ss >> vert_norm[0] >> vert_norm[1] >> vert_norm[2];

this->ori_normals.push_back(vert_norm);

}

else if (type == "f") {

Face_Index face_idx;

// Here we only accept face number 3

for (int i = 0; i < 3; i++) {

std::string s_vertex;

ss >> s_vertex;

int pos_idx = -1;

int tex_idx = -1;

int norm_idx = -1;

sscanf(s_vertex.c_str(), "%d/%d/%d", &pos_idx, &tex_idx, &norm_idx);

// We have to use index -1 because the obj index starts at 1

// Incorrect input will be set as -1

face_idx.vertex[i].pos_idx = pos_idx > 0 ? pos_idx - 1 : -1;

face_idx.vertex[i].texcoord_idx = tex_idx > 0 ? tex_idx - 1 : -1;

face_idx.vertex[i].normal_idx = norm_idx > 0 ? norm_idx - 1 : -1;

}

indexed_faces.push_back(face_idx);

}

}

}

catch (const std::exception&) {

std::cout << "Error: Obj file cannot be read ";

}

// Retrieve data from index and assign to vao and veo

for (int i = 0; i < indexed_faces.size(); i++) {

Face_Index cur_idx_face = indexed_faces[i];

// If no normal: recalculate for them

glm::vec3 v0 = ori_positions[cur_idx_face.vertex[0].pos_idx];

glm::vec3 v1 = ori_positions[cur_idx_face.vertex[1].pos_idx];

glm::vec3 v2 = ori_positions[cur_idx_face.vertex[2].pos_idx];

glm::vec3 new_normal = glm::cross(v1 - v0, v2 - v0);

for (int j = 0; j < 3; j++) {

Vertex cur_vertex;

Vertex_Index cur_idx_vertex = cur_idx_face.vertex[j];

if (cur_idx_vertex.pos_idx >= 0) {

cur_vertex.Position = ori_positions[cur_idx_vertex.pos_idx];

}

if (cur_idx_vertex.normal_idx >= 0) {

cur_vertex.Normal = ori_normals[cur_idx_vertex.normal_idx];

}

else {

cur_vertex.Normal = new_normal;

}

if (cur_idx_vertex.texcoord_idx >= 0) {

cur_vertex.TexCoords = ori_texcoords[cur_idx_vertex.texcoord_idx];

}

vao_vertices.push_back(cur_vertex);

veo_indices.push_back(i * 3 + j);

}

}

}

};

void calculate_center()

{

glm::vec3 max_bound(INT_MIN);

glm::vec3 min_bound(INT_MAX);

for (auto vertex : this->vao_vertices) {

max_bound[0] = std::max(vertex.Position[0], max_bound[0]);

max_bound[1] = std::max(vertex.Position[1], max_bound[1]);

max_bound[2] = std::max(vertex.Position[2], max_bound[2]);

min_bound[0] = std::min(vertex.Position[0], min_bound[0]);

min_bound[1] = std::min(vertex.Position[1], min_bound[1]);

min_bound[2] = std::min(vertex.Position[2], min_bound[2]);

}

this->obj_center = (max_bound + min_bound) * 0.5f;

};

Object(std::string obj_path) {

this->m_obj_path = obj_path;

load_obj(this->m_obj_path);

calculate_center();

};

~Object() {};

};

Renderer.h

#pragma once

#include

#define GLEW_STATIC

#include

#include

#include

#include

#include

#include

#include

#include "Shader.h"

#include "Camera.h"

#include "Object.h"

#include "Lighting.h"

#include "Animation.h"

class Renderer

{

public:

GLFWwindow * m_window;

static Camera* m_camera;

static Lighting* m_lightings;

static Animation* m_animation;

static nanogui::Screen* m_nanogui_screen;

std::vector