bunny in a box

#include <iostream>
#include <vector>
#include <GL/glew.h>
#include <GLFW/glfw3.h>
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtx/string_cast.hpp>

#include "objloader.h"
#include "shader.h"
#include "textures.h"

void process_keyboard(GLFWwindow* w);
glm::vec3 move();

float deltaT = 0, lastF = 0;
bool jump = false;

glm::vec3 cameraPos = glm::vec3(10.7f, -0.4f, 11.6f);
glm::vec3 cameraFront = glm::vec3(0.4f, 0.f, 0.9f);
glm::vec3 lightPos = glm::vec3(1.4f, 0.f, 5.f);
glm::vec3 lightColor = glm::vec3 (1.f);
glm::vec3 objectColor = glm::vec3 (0.071, 0.682, 0.82);
glm::vec3 cameraUp = glm::vec3(0,1,0);

float box_vertices[] = {
    //prednja
   -1.0f, -0.7f,  1.0f, 0.f, 0.f, 1.f, 0.0f, 0.0f,  //dl
    1.0f, -0.7f,  1.0f, 0.f, 0.f, 1.f, 1.0f, 0.0f,  //dd
    1.0f,  0.7f,  1.0f, 0.f, 0.f, 1.f, 1.0f, 1.0f,  //gd
   -1.0f,  0.7f,  1.0f, 0.f, 0.f, 1.f, 0.0f, 1.0f,  //gl
    //straznja
   -1.0f, -0.7f, -1.0f, 1.f, 0.f, 0.f, 0.0f, 0.0f, //dl
    1.0f, -0.7f, -1.0f, 1.f, 0.f, 0.f, 1.0f, 0.0f, //dd
    1.0f,  0.7f, -1.0f, 1.f, 0.f, 0.f, 1.0f, 1.0f, //gd
   -1.0f,  0.7f, -1.0f, 1.f, 0.f, 0.f, 0.0f, 1.0f, //gl
    //lijeva
   -1.0f, -0.7f, -1.0f, 1.f, 0.f, 0.f, 0.0f, 0.0f,  //ds
   -1.0f, -0.7f,  1.0f, 1.f, 0.f, 0.f, 1.0f, 0.0f,  //dp
   -1.0f,  0.7f,  1.0f, 1.f, 0.f, 0.f, 1.0f, 1.0f,  //gp
   -1.0f,  0.7f, -1.0f, 1.f, 0.f, 0.f, 0.0f, 1.0f,  //gs
    //gornja
   -1.0f,  0.7f, -1.0f, 1.f, 0.f, 0.f, 0.0f, 0.0f,  //sl
    1.0f,  0.7f, -1.0f, 1.f, 0.f, 0.f, 1.0f, 0.0f,  //sd
    1.0f,  0.7f,  1.0f, 1.f, 0.f, 0.f, 1.0f, 1.0f,  //pd
   -1.0f,  0.7f,  1.0f, 1.f, 0.f, 0.f, 0.0f, 1.0f,  //pl
    //donja
   -1.0f, -0.7f, -1.0f, 0.f, 0.f, 1.f, 0.0f, 1.0f,  //sl
    1.0f, -0.7f, -1.0f, 0.f, 0.f, 1.f, 1.0f, 1.0f,  //sd
    1.0f, -0.7f,  1.0f, 0.f, 0.f, 1.f, 1.0f, 0.0f,  //pd
   -1.0f, -0.7f,  1.0f, 0.f, 0.f, 1.f, 0.0f, 0.0f   //pl
};
int box_indices[] = {
    //straznja
    0, 1, 2,
    2, 3, 0,
    //lijeva
    4, 5, 6,
    6, 7, 4,
    //desna
    8, 9, 10,
    10, 11, 8,
    //gornja
    12, 13, 14,
    14, 15, 12,
    //donja
    16, 17, 18,
    18, 19, 16
};
std::vector<glm::vec3> curve_points;
void calc_curve()
{
    const int num = 50, start = -2, end = 5;
    std::vector<double> ts(num);
    const double dx = (end - start) / (num - 1);
    for (int i = 0; i < num; ++i)
    {
        ts[i] = start + i*dx;
    }
    for(const auto& t : ts)
    {
        if(t < 4)
        {
            curve_points.emplace_back(glm::vec3(t, 2.f, 0.f));
        }
    }
}

int main()
{
    if( !glfwInit() )
    {
        std::cerr << "GLFW nije inicijaliziran\n";
        getchar();
        return -1;
    }

    glfwWindowHint(GLFW_SAMPLES, 4);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
    glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); // samo za MacOS
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

    GLFWwindow* window = glfwCreateWindow( 1024, 768, "prog", nullptr, nullptr);
    if( window == nullptr )
    {
        std::cerr << "Nije prošao init glfw prozora. Npr. neki Intel GPU nisu 3.3 kompatibilni.\n";
        getchar();
        glfwTerminate();
        return -1;
    }
    glfwMakeContextCurrent(window);

    if (glewInit() != GLEW_OK)
    {
        std::cerr << "GLEW nije inicijaliziran\n";
        getchar();
        glfwTerminate();
        return -1;
    }

    glfwSetInputMode(window, GLFW_STICKY_KEYS, GL_TRUE);

    glEnable(GL_DEPTH_TEST);
    glDisable(GL_CULL_FACE);
    glPolygonMode( GL_FRONT_AND_BACK, GL_FILL );
    glClearColor(0.3f, 0.3f, 0.3f, 0.0f);

    std::vector<glm::vec3> bunny_vertices, bunny_normals;
    bool res = loadOBJ("..//..//models//bunny.obj", bunny_vertices, bunny_normals);
    calc_curve();
    std::vector<ShaderInfo> shaders = {
        {GL_VERTEX_SHADER, "shaders/vert.glsl"},
        {GL_FRAGMENT_SHADER, "shaders/frag.glsl"}
    };
    Shader shader(shaders);
    unsigned int box_texture = loadTexture("../../images/metal_03.jpg");

    glm::mat4 model(1.f), proj, view;
    proj = glm::perspective(glm::radians(45.f), 16.f/9.f, 0.1f, 100.f);

    unsigned int VAO, VBO[3], EBO, NBO;
    glGenVertexArrays(1, &VAO);
    glBindVertexArray(VAO);

    glGenBuffers(3, VBO);
    glGenBuffers(1, &EBO);
    glGenBuffers(1, &NBO);

    glEnableVertexAttribArray(0);
    glEnableVertexAttribArray(1);
    glEnableVertexAttribArray(2);
    do {
        glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
        glCullFace(GL_BACK);

        float currentF = glfwGetTime();
        deltaT = currentF - lastF;
        lastF = currentF;
        process_keyboard(window);
        view = glm::lookAt(cameraPos, cameraPos - cameraFront, glm::vec3(0.0, 1.0, 0.0));

        // box
        model = glm::translate(glm::mat4(1.f), glm::vec3(-2.f, 3.f, 0.f));
        model = glm::scale(model, glm::vec3(1.8f));

        shader.use();
        shader.setMat4("model", model);
        shader.setMat4("proj", proj);
        shader.setMat4("view", view);
        shader.setVec3("lightColor", lightColor);
        shader.setVec3("viewPos", cameraPos);
        shader.setVec3("lightPos", lightPos);
        shader.setInt("texture", 0);
        glActiveTexture(GL_TEXTURE0);
        glBindTexture(GL_TEXTURE_2D, box_texture);

        glBindBuffer(GL_ARRAY_BUFFER, VBO[0]);
        glBufferData(GL_ARRAY_BUFFER, sizeof(box_vertices), box_vertices, GL_STATIC_DRAW);
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
        glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(box_indices), box_indices, GL_STATIC_DRAW);

        glVertexAttribPointer(0, 3, GL_FLOAT, false, 8*sizeof(float), (void*)0);
        glVertexAttribPointer(1, 3, GL_FLOAT, false, 8*sizeof(float), (void*)(3 * sizeof(float)));
        glVertexAttribPointer(2, 2, GL_FLOAT, false, 8*sizeof(float), (void*)(6 * sizeof(float)));

        glDrawElements(GL_TRIANGLES, 30, GL_UNSIGNED_INT, 0);

        // bunny
        glm::vec3 bunny_pos = jump ? move() : glm::vec3(-2.2f, 2.f, 0.f);
        model = glm::translate(glm::mat4(1.f), bunny_pos);
        model = glm::scale(model, glm::vec3(0.8f));
        model = glm::rotate(model, glm::radians(100.f), glm::vec3(0.f, 1.f, 0.f));
        shader.setMat4("model", model);

        glBindBuffer(GL_ARRAY_BUFFER, VBO[1]);
        glBufferData(GL_ARRAY_BUFFER, bunny_vertices.size() * sizeof(glm::vec3), &bunny_vertices[0], GL_STATIC_DRAW);
        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, (void*)0);

        glBindBuffer(GL_ARRAY_BUFFER, NBO);
        glBufferData(GL_ARRAY_BUFFER, bunny_normals.size() * sizeof(glm::vec3), &bunny_normals[0], GL_STATIC_DRAW);
        glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, (void*)0);

        glDrawArrays(GL_TRIANGLES, 0, bunny_vertices.size());

        model = glm::mat4(1.f);
        shader.setMat4("model", model);

        glBindBuffer(GL_ARRAY_BUFFER, VBO[2]);
        glBufferData(GL_ARRAY_BUFFER, curve_points.size() * sizeof(glm::vec3), &curve_points.front(), GL_STATIC_DRAW);

        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, (void*) 0);
        glDrawArrays(GL_LINE_STRIP, 0, curve_points.size());

        glfwSwapBuffers(window);
        glfwPollEvents();
    }
    while( glfwGetKey(window, GLFW_KEY_ESCAPE ) != GLFW_PRESS &&
           glfwWindowShouldClose(window) == 0 );
    glDisableVertexAttribArray(0);
    glDisableVertexAttribArray(1);
    glDisableVertexAttribArray(2);

    glfwTerminate();

    return 0;
}

glm::vec3 move()
{

}

void process_keyboard(GLFWwindow* w)
{
    float camSpeed = 4 * deltaT;

    if(glfwGetKey(w,GLFW_KEY_G) == GLFW_PRESS)
    {
        jump = true;
    }
    if(glfwGetKey(w,GLFW_KEY_S) == GLFW_PRESS)
    {
        jump = false;
    }
    if(glfwGetKey(w,GLFW_KEY_I) == GLFW_PRESS)
    {
        cameraPos -= cameraFront * camSpeed;
    }
    if(glfwGetKey(w,GLFW_KEY_K) == GLFW_PRESS)
    {
        cameraPos += cameraFront * camSpeed;
    }
    if(glfwGetKey(w,GLFW_KEY_J) == GLFW_PRESS)
    {
        cameraPos += glm::cross(cameraFront, cameraUp) * camSpeed;
    }
    if(glfwGetKey(w,GLFW_KEY_L) == GLFW_PRESS)
    {
        cameraPos -= glm::cross(cameraFront, cameraUp) * camSpeed;
    }
    if(glfwGetKey(w,GLFW_KEY_U) == GLFW_PRESS)
    {
        cameraFront = glm::rotate(glm::mat4(1.f), std::acos(std::cos(deltaT)), cameraUp) * glm::vec4(cameraFront, 1.f);
    }
    if(glfwGetKey(w,GLFW_KEY_O) == GLFW_PRESS)
    {
        cameraFront = glm::rotate(glm::mat4(1.f), -std::acos(std::cos(deltaT)), cameraUp) * glm::vec4(cameraFront, 1.f);
    }
    if(glfwGetKey(w,GLFW_KEY_N) == GLFW_PRESS)
    {
        cameraPos += glm::vec3(0,1,0) * camSpeed;
    }
    if(glfwGetKey(w,GLFW_KEY_M) == GLFW_PRESS)
    {
        cameraPos -= glm::vec3(0,1,0) * camSpeed;
    }
}