Untitled

MAIN.CPP

//Some Windows Headers (For Time, IO, etc.)

#include <windows.h>

#include <mmsystem.h>

#include <GL/glew.h>

#include <GL/freeglut.h>

#include <iostream>

#include "maths_funcs.h"

#include "mesh.h"

// Assimp includes

#include <assimp/cimport.h> // C importer

#include <assimp/scene.h> // collects data

#include <assimp/postprocess.h> // various extra operations

#include <stdio.h>

#include <math.h>

#include <vector> // STL dynamic memory.

/*----------------------------------------------------------------------------

MESH TO LOAD

----------------------------------------------------------------------------*/

// this mesh is a dae file format but you should be able to use any other format too, obj is typically what is used

// put the mesh in your project directory, or provide a filepath for it here

#define MESHNAME1 "monkeyhead.dae"

#define MESHNAME2 "chair.obj"

/*----------------------------------------------------------------------------

----------------------------------------------------------------------------*/

std::vector<float> g_vp, g_vn, g_vt;

int g_point_count = 0;

// Macro for indexing vertex buffer

#define BUFFER_OFFSET(i) ((char *)NULL + (i))

using namespace std;

GLuint shaderProgramID;

unsigned int mesh_vao = 0;

int width = 800;

int height = 600;

GLfloat xpos = 0.0f;

GLfloat ypos = 0.0f;

GLfloat zpos = -5.0f;

GLuint loc1, loc2, loc3;

GLfloat rotate_y = 0.0f;

mat4 model = identity_mat4 ();

mesh chair, monkey;

/*

#pragma region MESH LOADING

/*----------------------------------------------------------------------------

MESH LOADING FUNCTION

----------------------------------------------------------------------------

bool load_mesh (const char* file_name) {

const aiScene* scene = aiImportFile (file_name, aiProcess_Triangulate); // TRIANGLES!

if (!scene) {

fprintf (stderr, "ERROR: reading mesh %s\n", file_name);

return false;

}

printf (" %i animations\n", scene->mNumAnimations);

printf (" %i cameras\n", scene->mNumCameras);

printf (" %i lights\n", scene->mNumLights);

printf (" %i materials\n", scene->mNumMaterials);

printf (" %i meshes\n", scene->mNumMeshes);

printf (" %i textures\n", scene->mNumTextures);

for (unsigned int m_i = 0; m_i < scene->mNumMeshes; m_i++) {

const aiMesh* mesh = scene->mMeshes[m_i];

printf (" %i vertices in mesh\n", mesh->mNumVertices);

g_point_count += mesh->mNumVertices;

for (unsigned int v_i = 0; v_i < mesh->mNumVertices; v_i++) {

if (mesh->HasPositions ()) {

const aiVector3D* vp = &(mesh->mVertices[v_i]);

//printf (" vp %i (%f,%f,%f)\n", v_i, vp->x, vp->y, vp->z);

g_vp.push_back (vp->x);

g_vp.push_back (vp->y);

g_vp.push_back (vp->z);

}

if (mesh->HasNormals ()) {

const aiVector3D* vn = &(mesh->mNormals[v_i]);

//printf (" vn %i (%f,%f,%f)\n", v_i, vn->x, vn->y, vn->z);

g_vn.push_back (vn->x);

g_vn.push_back (vn->y);

g_vn.push_back (vn->z);

}

if (mesh->HasTextureCoords (0)) {

const aiVector3D* vt = &(mesh->mTextureCoords[0][v_i]);

//printf (" vt %i (%f,%f)\n", v_i, vt->x, vt->y);

g_vt.push_back (vt->x);

g_vt.push_back (vt->y);

}

if (mesh->HasTangentsAndBitangents ()) {

// NB: could store/print tangents here

}

}

}

aiReleaseImport (scene);

return true;

}

#pragma endregion MESH LOADING

*/

// Shader Functions- click on + to expand

#pragma region SHADER_FUNCTIONS

// Create a NULL-terminated string by reading the provided file

char* readShaderSource(const char* shaderFile) {

FILE* fp = fopen(shaderFile, "rb"); //!->Why does binary flag "RB" work and not "R"... wierd msvc thing?

if ( fp == NULL ) { return NULL; }

fseek(fp, 0L, SEEK_END);

long size = ftell(fp);

fseek(fp, 0L, SEEK_SET);

char* buf = new char[size + 1];

fread(buf, 1, size, fp);

buf[size] = '\0';

fclose(fp);

return buf;

}

static void AddShader(GLuint ShaderProgram, const char* pShaderText, GLenum ShaderType)

{

// create a shader object

GLuint ShaderObj = glCreateShader(ShaderType);

if (ShaderObj == 0) {

fprintf(stderr, "Error creating shader type %d\n", ShaderType);

exit(0);

}

const char* pShaderSource = readShaderSource( pShaderText);

// Bind the source code to the shader, this happens before compilation

glShaderSource(ShaderObj, 1, (const GLchar**)&pShaderSource, NULL);

// compile the shader and check for errors

glCompileShader(ShaderObj);

GLint success;

// check for shader related errors using glGetShaderiv

glGetShaderiv(ShaderObj, GL_COMPILE_STATUS, &success);

if (!success) {

GLchar InfoLog[1024];

glGetShaderInfoLog(ShaderObj, 1024, NULL, InfoLog);

fprintf(stderr, "Error compiling shader type %d: '%s'\n", ShaderType, InfoLog);

exit(1);

}

// Attach the compiled shader object to the program object

glAttachShader(ShaderProgram, ShaderObj);

}

GLuint CompileShaders()

{

//Start the process of setting up our shaders by creating a program ID

//Note: we will link all the shaders together into this ID

shaderProgramID = glCreateProgram();

if (shaderProgramID == 0) {

fprintf(stderr, "Error creating shader program\n");

exit(1);

}

// Create two shader objects, one for the vertex, and one for the fragment shader

AddShader(shaderProgramID, "../Shaders/simpleVertexShader.txt", GL_VERTEX_SHADER);

AddShader(shaderProgramID, "../Shaders/simpleFragmentShader.txt", GL_FRAGMENT_SHADER);

GLint Success = 0;

GLchar ErrorLog[1024] = { 0 };

// After compiling all shader objects and attaching them to the program, we can finally link it

glLinkProgram(shaderProgramID);

// check for program related errors using glGetProgramiv

glGetProgramiv(shaderProgramID, GL_LINK_STATUS, &Success);

if (Success == 0) {

glGetProgramInfoLog(shaderProgramID, sizeof(ErrorLog), NULL, ErrorLog);

fprintf(stderr, "Error linking shader program: '%s'\n", ErrorLog);

exit(1);

}

// program has been successfully linked but needs to be validated to check whether the program can execute given the current pipeline state

glValidateProgram(shaderProgramID);

// check for program related errors using glGetProgramiv

glGetProgramiv(shaderProgramID, GL_VALIDATE_STATUS, &Success);

if (!Success) {

glGetProgramInfoLog(shaderProgramID, sizeof(ErrorLog), NULL, ErrorLog);

fprintf(stderr, "Invalid shader program: '%s'\n", ErrorLog);

exit(1);

}

// Finally, use the linked shader program

// Note: this program will stay in effect for all draw calls until you replace it with another or explicitly disable its use

glUseProgram(shaderProgramID);

return shaderProgramID;

}

#pragma endregion SHADER_FUNCTIONS

// VBO Functions - click on + to expand

#pragma region VBO_FUNCTIONS

/*

void generateObjectBufferMesh() {

/*----------------------------------------------------------------------------

LOAD MESH HERE AND COPY INTO BUFFERS

----------------------------------------------------------------------------

//Note: you may get an error "vector subscript out of range" if you are using this code for a mesh that doesnt have positions and normals

//Might be an idea to do a check for that before generating and binding the buffer.

//load_mesh (MESH_NAME1);

//int variable = g_point_count;

load_mesh (MESH_NAME2);

unsigned int vp_vbo = 0;

loc1 = glGetAttribLocation(shaderProgramID, "vertex_position");

loc2 = glGetAttribLocation(shaderProgramID, "vertex_normal");

loc3 = glGetAttribLocation(shaderProgramID, "vertex_texture");

glGenBuffers (1, &vp_vbo);

glBindBuffer (GL_ARRAY_BUFFER, vp_vbo);

glBufferData (GL_ARRAY_BUFFER, g_point_count * 3 * sizeof (float), &g_vp[0], GL_STATIC_DRAW);

unsigned int vn_vbo = 0;

glGenBuffers (1, &vn_vbo);

glBindBuffer (GL_ARRAY_BUFFER, vn_vbo);

glBufferData (GL_ARRAY_BUFFER, g_point_count * 3 * sizeof (float), &g_vn[0], GL_STATIC_DRAW);

// This is for texture coordinates which you don't currently need, so I have commented it out

// unsigned int vt_vbo = 0;

// glGenBuffers (1, &vt_vbo);

// glBindBuffer (GL_ARRAY_BUFFER, vt_vbo);

// glBufferData (GL_ARRAY_BUFFER, g_point_count * 2 * sizeof (float), &g_vt[0], GL_STATIC_DRAW);

unsigned int vao = 0;

glBindVertexArray (vao);

glEnableVertexAttribArray (loc1);

glBindBuffer (GL_ARRAY_BUFFER, vp_vbo);

glVertexAttribPointer (loc1, 3, GL_FLOAT, GL_FALSE, 0, NULL);

glEnableVertexAttribArray (loc2);

glBindBuffer (GL_ARRAY_BUFFER, vn_vbo);

glVertexAttribPointer (loc2, 3, GL_FLOAT, GL_FALSE, 0, NULL);

// This is for texture coordinates which you don't currently need, so I have commented it out

// glEnableVertexAttribArray (loc3);

// glBindBuffer (GL_ARRAY_BUFFER, vt_vbo);

// glVertexAttribPointer (loc3, 2, GL_FLOAT, GL_FALSE, 0, NULL);

}

#pragma endregion VBO_FUNCTIONS

*/

void display(){

// tell GL to only draw onto a pixel if the shape is closer to the viewer

glEnable (GL_DEPTH_TEST); // enable depth-testing

glDepthFunc (GL_LESS); // depth-testing interprets a smaller value as "closer"

glClearColor (0.5f, 0.5f, 0.5f, 1.0f);

glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

glUseProgram (shaderProgramID);

//Declare your uniform variables that will be used in your shader

int matrix_location = glGetUniformLocation (shaderProgramID, "model");

int view_mat_location = glGetUniformLocation (shaderProgramID, "view");

int proj_mat_location = glGetUniformLocation (shaderProgramID, "proj");

monkey.view = identity_mat4();

monkey.persp_proj = perspective(45.0, (float)width/(float)height, 0.1, 100.0);

monkey.view = translate (monkey.view, vec3 (xpos, ypos, zpos));

/*

// Root of the Hierarchy

mat4 view = identity_mat4 ();

mat4 persp_proj = perspective(45.0, (float)width/(float)height, 0.1, 100.0);

model = rotate_y_deg (model, rotate_y);

view = translate (view, vec3 (xpos, ypos, zpos));

// update uniforms & draw

glUniformMatrix4fv (proj_mat_location, 1, GL_FALSE, persp_proj.m);

glUniformMatrix4fv (view_mat_location, 1, GL_FALSE, view.m);

glUniformMatrix4fv (matrix_location, 1, GL_FALSE, model.m);

*/

glutSwapBuffers();

}

void updateScene() {

// Placeholder code, if you want to work with framerate

// Wait until at least 16ms passed since start of last frame (Effectively caps framerate at ~60fps)

static DWORD last_time = 0;

DWORD curr_time = timeGetTime();

float delta = (curr_time - last_time) * 0.001f;

if (delta > 0.03f)

delta = 0.03f;

last_time = curr_time;

// rotate the model slowly around the y axis

//rotate_y+=0.0002f;

// Draw the next frame

glutPostRedisplay();

}

void init()

{

// Set up the shaders

GLuint shaderProgramID = CompileShaders();

// load mesh into a vertex buffer array

monkey.generateObjectBufferMesh(shaderProgramID, MESHNAME1);

chair.generateObjectBufferMesh(shaderProgramID, MESHNAME2);

}

void scale1()

{

mat4 scalar = identity_mat4();

scalar = scale(scalar, vec3(0.8, 0.8, 0.8));

model = model * scalar;

}

void scale2()

{

mat4 scalar = identity_mat4();

scalar = scale(scalar, vec3(1.2, 1.2, 1.2));

model = model * scalar;

}

// Placeholder code for the keypress

void keypress(unsigned char key, int x, int y) {

switch (key)

{

case 'w':

ypos += 0.1;

break;

case 'a':

xpos -= 0.1;

break;

case 's':

ypos -= 0.1;

break;

case 'd':

xpos += 0.1;

break;

case '1':

scale1();

break;

case '2':

scale2();

break;

}

}

int main(int argc, char** argv){

// Set up the window

glutInit(&argc, argv);

glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGB);

glutInitWindowSize(width, height);

glutCreateWindow("Hello Triangle");

// Tell glut where the display function is

glutDisplayFunc(display);

glutIdleFunc(updateScene);

glutKeyboardFunc(keypress);

// A call to glewInit() must be done after glut is initialized!

GLenum res = glewInit();

// Check for any errors

if (res != GLEW_OK) {

fprintf(stderr, "Error: '%s'\n", glewGetErrorString(res));

return 1;

}

// Set up your objects and shaders

init();

// Begin infinite event loop

glutMainLoop();

return 0;

}

MESH.CPP

//Some Windows Headers (For Time, IO, etc.)

#include <windows.h>

#include <mmsystem.h>

#include <GL/glew.h>

#include <GL/freeglut.h>

#include <iostream>

#include "maths_funcs.h"

#include "mesh.h"

// Assimp includes

#include <assimp/cimport.h> // C importer

#include <assimp/scene.h> // collects data

#include <assimp/postprocess.h> // various extra operations

#include <stdio.h>

#include <math.h>

#include <vector> // STL dynamic memory.

unsigned int vp_vbo = 0;

unsigned int vn_vbo = 0;

//loadmesh, genertateobjectbufferMesh, draw

bool mesh::load_mesh (const char* file_name) {

const aiScene* scene = aiImportFile (file_name, aiProcess_Triangulate); // TRIANGLES!

if (!scene) {

fprintf (stderr, "ERROR: reading mesh %s\n", file_name);

return false;

}

printf (" %i animations\n", scene->mNumAnimations);

printf (" %i cameras\n", scene->mNumCameras);

printf (" %i lights\n", scene->mNumLights);

printf (" %i materials\n", scene->mNumMaterials);

printf (" %i meshes\n", scene->mNumMeshes);

printf (" %i textures\n", scene->mNumTextures);

g_point_count = 0;

for (unsigned int m_i = 0; m_i < scene->mNumMeshes; m_i++) {

const aiMesh* mesh = scene->mMeshes[m_i];

printf (" %i vertices in mesh\n", mesh->mNumVertices);

g_point_count += mesh->mNumVertices;

for (unsigned int v_i = 0; v_i < mesh->mNumVertices; v_i++) {

if (mesh->HasPositions ()) {

const aiVector3D* vp = &(mesh->mVertices[v_i]);

//printf (" vp %i (%f,%f,%f)\n", v_i, vp->x, vp->y, vp->z);

g_vp.push_back (vp->x);

g_vp.push_back (vp->y);

g_vp.push_back (vp->z);

}

if (mesh->HasNormals ()) {

const aiVector3D* vn = &(mesh->mNormals[v_i]);

//printf (" vn %i (%f,%f,%f)\n", v_i, vn->x, vn->y, vn->z);

g_vn.push_back (vn->x);

g_vn.push_back (vn->y);

g_vn.push_back (vn->z);

}

if (mesh->HasTextureCoords (0)) {

const aiVector3D* vt = &(mesh->mTextureCoords[0][v_i]);

//printf (" vt %i (%f,%f)\n", v_i, vt->x, vt->y);

g_vt.push_back (vt->x);

g_vt.push_back (vt->y);

}

if (mesh->HasTangentsAndBitangents ()) {

// NB: could store/print tangents here

}

}

}

aiReleaseImport (scene);

return true;

}

void mesh::generateObjectBufferMesh(GLuint shaderProgramID, const char* file_name) {

/*----------------------------------------------------------------------------

LOAD MESH HERE AND COPY INTO BUFFERS

----------------------------------------------------------------------------*/

//Note: you may get an error "vector subscript out of range" if you are using this code for a mesh that doesnt have positions and normals

//Might be an idea to do a check for that before generating and binding the buffer.

//load_mesh (MESH_NAME1);

//int variable = g_point_count;

load_mesh (file_name);

loc1 = glGetAttribLocation(shaderProgramID, "vertex_position");

loc2 = glGetAttribLocation(shaderProgramID, "vertex_normal");

loc3 = glGetAttribLocation(shaderProgramID, "vertex_texture");

glGenBuffers (1, &vp_vbo);

glBindBuffer (GL_ARRAY_BUFFER, vp_vbo);

glBufferData (GL_ARRAY_BUFFER, g_point_count * 3 * sizeof (float), &g_vp[0], GL_STATIC_DRAW);

glGenBuffers (1, &vn_vbo);

glBindBuffer (GL_ARRAY_BUFFER, vn_vbo);

glBufferData (GL_ARRAY_BUFFER, g_point_count * 3 * sizeof (float), &g_vn[0], GL_STATIC_DRAW);

// This is for texture coordinates which you don't currently need, so I have commented it out

// unsigned int vt_vbo = 0;

// glGenBuffers (1, &vt_vbo);

// glBindBuffer (GL_ARRAY_BUFFER, vt_vbo);

// glBufferData (GL_ARRAY_BUFFER, g_point_count * 2 * sizeof (float), &g_vt[0], GL_STATIC_DRAW);

unsigned int vao = 0;

glBindVertexArray (vao);

// This is for texture coordinates which you don't currently need, so I have commented it out

// glEnableVertexAttribArray (loc3);

// glBindBuffer (GL_ARRAY_BUFFER, vt_vbo);

// glVertexAttribPointer (loc3, 2, GL_FLOAT, GL_FALSE, 0, NULL);

}

void mesh::draw(int width, int heigth, int matrix_location, int view_mat_location, int proj_mat_location)

{

glEnableVertexAttribArray (loc1);

glBindBuffer (GL_ARRAY_BUFFER, vp_vbo);

glVertexAttribPointer (loc1, 3, GL_FLOAT, GL_FALSE, 0, NULL);

glEnableVertexAttribArray (loc2);

glBindBuffer (GL_ARRAY_BUFFER, vn_vbo);

glVertexAttribPointer (loc2, 3, GL_FLOAT, GL_FALSE, 0, NULL);

glUniformMatrix4fv (proj_mat_location, 1, GL_FALSE, persp_proj.m);

glUniformMatrix4fv (view_mat_location, 1, GL_FALSE, view.m);

glUniformMatrix4fv (matrix_location, 1, GL_FALSE, model.m);

glDrawArrays (GL_TRIANGLES, 0, g_point_count);

}