Teapot

/*
Had to change the params in antons math class because near and far are already defined somewhere else..i think. Also to get rid of that stupid ambiguous variable error I got rid of the "using namespace std".
Will just use "std::" if i need anything.

*/


#define _CRT_SECURE_NO_DEPRECATE
//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" //Anton's math class
#include "teapot.h" // teapot mesh

// Macro for indexing vertex buffer
#define BUFFER_OFFSET(i) ((char *)NULL + (i))

//using namespace std;
GLuint shaderProgramID;
GLfloat rotateSpeed = 0.0f, move = -40.0f;
unsigned int teapot_vao = 0;
int width = 800.0;
int height = 600.0;

// 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);
    }

    /**
    pShaderText is the problem....

    **/

    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 generateObjectBufferTeapot () {
    GLuint vp_vbo = 0;
    glGenBuffers (1, &vp_vbo);
    glBindBuffer (GL_ARRAY_BUFFER, vp_vbo);
    glBufferData (GL_ARRAY_BUFFER, 3 * teapot_vertex_count * sizeof (float), teapot_vertex_points, GL_STATIC_DRAW);
    GLuint vn_vbo = 0;
    glGenBuffers (1, &vn_vbo);
    glBindBuffer (GL_ARRAY_BUFFER, vn_vbo);
    glBufferData (GL_ARRAY_BUFFER, 3 * teapot_vertex_count * sizeof (float), teapot_normals, GL_STATIC_DRAW);

    glGenVertexArrays (1, &teapot_vao);
    glBindVertexArray (teapot_vao);
    glEnableVertexAttribArray (0);
    glBindBuffer (GL_ARRAY_BUFFER, vp_vbo);
    glVertexAttribPointer (0, 3, GL_FLOAT, GL_FALSE, 0, NULL);
    glEnableVertexAttribArray (1);
    glBindBuffer (GL_ARRAY_BUFFER, vn_vbo);
    glVertexAttribPointer (1, 3, GL_FLOAT, GL_FALSE, 0, NULL);
}

void linkCurrentBuffertoShader(GLuint shaderProgramID){

    glBindAttribLocation (shaderProgramID, 0, "vertex_position");
    glBindAttribLocation (shaderProgramID, 1, "vertex_normals");

}
#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");


    rotateSpeed = rotateSpeed + 0.4f;


    if (move > 40.0f){
        move = -40.0f;
    }
    move = move + 0.4f;

    //Here is where the code for the viewport lab will go, to get you started I have drawn a t-pot in the bottom left
    //The model transform rotates the object by 45 degrees, the view transform sets the camera at -40 on the z-axis, and the perspective projection is setup using Antons method
//******************************************************************************************************************************************************************************
    // bottom-left
    mat4 view = translate (identity_mat4 (), vec3 (0.0, 0.0, -40.0));
    mat4 persp_proj = perspective(50.0, (float)width/(float)height, 0.1, 100.0);
    mat4 model = rotate_x_deg (identity_mat4 (), 40);

    glViewport (0, 0, width / 2, height / 2);
    GLfloat aspect = (width/2) / (height/2);

    glOrtho(-aspect,aspect,-1,1,-1,1000);

    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, teapot_vertex_count);



//******************************************************************************************************************************************************************************
    // bottom-right

    mat4 view1 = translate (identity_mat4 (), vec3 (move, 0.0, -40.0));
    mat4 persp_proj1 = perspective(50.0, (float)width/(float)height, 0.1, 100);//   mat4 persp_proj1 = perspective(50.0, (float)width/(float)height, 0.1, move); this will allow the object to fade in and out.
    mat4 model1 = rotate_x_deg (identity_mat4 (), rotateSpeed);
    model1 = model1 * rotate_y_deg(model1, rotateSpeed*10);
    model1 = model1 * rotate_x_deg(model1, rotateSpeed);


    glViewport (400, 0, width / 2, height / 2);
    glUniformMatrix4fv (proj_mat_location, 1, GL_FALSE, persp_proj1.m);
    glUniformMatrix4fv (view_mat_location, 1, GL_FALSE, view1.m);
    glUniformMatrix4fv (matrix_location, 1, GL_FALSE, model1.m);
    glDrawArrays (GL_TRIANGLES, 0, teapot_vertex_count);


//******************************************************************************************************************************************************************************
    // top-left



    mat4 view2 = translate (identity_mat4 (), vec3 (0.0, 0.0, -40.0));
    mat4 persp_proj2 = perspective(50.0, (float)width/(float)height, 0.1, 100.0);
    mat4 model2 = rotate_x_deg (identity_mat4 (), 0);
    //model2 = model2 * rotate_x_deg(model, );

    glViewport (0, 300, width / 2, height / 2);
    glUniformMatrix4fv (proj_mat_location, 1, GL_FALSE, persp_proj2.m);
    glUniformMatrix4fv (view_mat_location, 1, GL_FALSE, view2.m);
    glUniformMatrix4fv (matrix_location, 1, GL_FALSE, model2.m);
    glDrawArrays (GL_TRIANGLES, 0, teapot_vertex_count);

//******************************************************************************************************************************************************************************
    // top-right

    mat4 view3 = translate (identity_mat4 (), vec3 (0.0, 0.0, -40.0));
    mat4 persp_proj3 = perspective(50.0, (float)width/(float)height, 0.1, 100.0);
    mat4 model3 = rotate_y_deg (identity_mat4 (), 90);
    //model = model * rotate_x_deg(model, );



    glViewport (400, 300, width / 2, height / 2);
    glUniformMatrix4fv (proj_mat_location, 1, GL_FALSE, persp_proj3.m);
    glUniformMatrix4fv (view_mat_location, 1, GL_FALSE, view3.m);
    glUniformMatrix4fv (matrix_location, 1, GL_FALSE, model3.m);
    glDrawArrays (GL_TRIANGLES, 0, teapot_vertex_count);

    glutSwapBuffers();
}


void updateScene() {

        // 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;

    // Draw the next frame
    glutPostRedisplay();
}


void init()
{
    // Create 3 vertices that make up a triangle that fits on the viewport
    GLfloat vertices[] = {-1.0f, -1.0f, 0.0f, 1.0,
            1.0f, -1.0f, 0.0f, 1.0,
            0.0f, 1.0f, 0.0f, 1.0};
    // Create a color array that identfies the colors of each vertex (format R, G, B, A)
    GLfloat colors[] = {0.0f, 1.0f, 0.0f, 1.0f,
            1.0f, 0.0f, 0.0f, 1.0f,
            0.0f, 0.0f, 1.0f, 1.0f};
    // Set up the shaders
    GLuint shaderProgramID = CompileShaders();
    // load teapot mesh into a vertex buffer array
    generateObjectBufferTeapot ();
    // Link the current buffer to the shader
    linkCurrentBuffertoShader(shaderProgramID);
}


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

    switch(key){
    case 27:
        exit(0);
        break;
    default:
        break;
    }



}


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

    // Set up the window
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGB);
    glutInitWindowSize(width, height);
    glutCreateWindow("Viewport Teapots");
    glutKeyboardFunc(keyPressed);
    // Tell glut where the display function is

    glutDisplayFunc(display);

    glutIdleFunc(updateScene);

     // 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;
}