3ddatagen lab3_full

#include <glad/glad.h>
#include <gl/GL.h>
#include <iostream>
#include <GLFW/glfw3.h>

#include <linmath/linmath.h>

#include <stdlib.h>
#include <stdio.h>

#include <CourseSupport.h>
#include <ObjToVertices.h>

const float PI_F = 3.14159265359f;

struct LightParameters {
    vec3 ambientFactor;
    vec3 diffuseFactor;
    vec3 specFactor;
    int shininess;
};

LightParameters lightParams = {
    {0.2f,0.2f,0.2f}, //ambientFactor
    {0.8f,0.8f,0.8f}, //diffuseFactor
    {0.99f,0.99f,0.99f}, //specFactor
    1 //shininess
};

const int OCTAEDER=0;
const int MODEL = 1;
int selectedVertices = 1;

int matIndex = 0;
void handleKeypress(GLFWwindow *window, int key, int scancode, int action, int mods)
{
    if (action == GLFW_PRESS)
        switch (key)
        {
        case GLFW_KEY_ESCAPE:
            exit(0);
        case GLFW_KEY_Q:
            lightParams.ambientFactor[0]+=0.1f;
            lightParams.ambientFactor[1]+=0.1f;
            lightParams.ambientFactor[2]+=0.1f;
            printf("ambient: %f, %f, %f\n", lightParams.ambientFactor[0],lightParams.ambientFactor[1], lightParams.ambientFactor[2]);
            break;
        case GLFW_KEY_A:
            lightParams.ambientFactor[0] -= 0.1f;
            lightParams.ambientFactor[1] -= 0.1f;
            lightParams.ambientFactor[2] -= 0.1f;
            printf("ambient: %f, %f, %f\n", lightParams.ambientFactor[0],lightParams.ambientFactor[1], lightParams.ambientFactor[2]);
            break;
        case GLFW_KEY_W:
            lightParams.diffuseFactor[0] +=0.1f;
            lightParams.diffuseFactor[1] +=0.1f;
            lightParams.diffuseFactor[2] +=0.1f;
            printf("diffuse: %f, %f, %f\n", lightParams.diffuseFactor[0],lightParams.diffuseFactor[1], lightParams.diffuseFactor[2]);
        break;
        case GLFW_KEY_S:
            lightParams.diffuseFactor[0] -=0.1f;
            lightParams.diffuseFactor[1] -=0.1f;
            lightParams.diffuseFactor[2] -=0.1f;
            printf("diffuse: %f, %f, %f\n", lightParams.diffuseFactor[0],lightParams.diffuseFactor[1], lightParams.diffuseFactor[2]);
        break;

        case GLFW_KEY_E:
            lightParams.specFactor[0] += 0.1f;
            lightParams.specFactor[1] += 0.1f;
            lightParams.specFactor[2] += 0.1f;
            printf("specular: %f, %f, %f\n", lightParams.specFactor[0],lightParams.specFactor[1], lightParams.specFactor[2]);
            break;
        case GLFW_KEY_D:
            lightParams.specFactor[0] -= 0.1f;
            lightParams.specFactor[1] -= 0.1f;
            lightParams.specFactor[2] -= 0.1f;
            printf("specular: %f, %f, %f\n", lightParams.specFactor[0],lightParams.specFactor[1], lightParams.specFactor[2]);
            break;
        case GLFW_KEY_R:
            lightParams.shininess += 1;
            printf("shininess: %d\n", lightParams.shininess);
            break;
        case GLFW_KEY_F:
            lightParams.shininess -= 1;
            printf("shininess: %d\n", lightParams.shininess);
            break;
        case GLFW_KEY_T:
            matIndex += 1;
            matIndex %= 25;
            lightParams.specFactor[0] = materials[matIndex].specular[0];
            lightParams.specFactor[1] = materials[matIndex].specular[1];
            lightParams.specFactor[2] = materials[matIndex].specular[2];
            lightParams.ambientFactor[0] = materials[matIndex].ambient[0];
            lightParams.ambientFactor[1] = materials[matIndex].ambient[1];
            lightParams.ambientFactor[2] = materials[matIndex].ambient[2];
            lightParams.diffuseFactor[0] = materials[matIndex].diffuse[0];
            lightParams.diffuseFactor[1] = materials[matIndex].diffuse[1];
            lightParams.diffuseFactor[2] = materials[matIndex].diffuse[2];
            lightParams.shininess = materials[matIndex].shininess;
            printf("Selected Material:%s", materials[matIndex].name);
            break;
        case GLFW_KEY_G:
            matIndex -= 1;
            matIndex %= 25;
            lightParams.specFactor[0] = materials[matIndex].specular[0];
            lightParams.specFactor[1] = materials[matIndex].specular[1];
            lightParams.specFactor[2] = materials[matIndex].specular[2];
            lightParams.ambientFactor[0] = materials[matIndex].ambient[0];
            lightParams.ambientFactor[1] = materials[matIndex].ambient[1];
            lightParams.ambientFactor[2] = materials[matIndex].ambient[2];
            lightParams.diffuseFactor[0] = materials[matIndex].diffuse[0];
            lightParams.diffuseFactor[1] = materials[matIndex].diffuse[1];
            lightParams.diffuseFactor[2] = materials[matIndex].diffuse[2];
            lightParams.shininess = materials[matIndex].shininess;
            printf("Selected Material:%s\n", materials[matIndex].name);
            break;
        default:
        {
            printf("unboud key pressed!\n");
        }
        }
}


static myVertexType* createOctaeder(float radius, int* size)
{
    float xAndZ = sqrt((radius * radius) / 2);
    vec3 fr = { xAndZ, 0.0f, xAndZ };
    vec3 br = { xAndZ, 0.0f, -xAndZ };
    vec3 bl = { -xAndZ, 0.0f, -xAndZ };
    vec3 fl = { -xAndZ, 0.0f, xAndZ };
    vec3 top = { 0.0f, radius, 0.0f };
    vec3 bottom = { 0.0f, -radius, 0.0f };

    vec3 norm;

    myVertexType* octaederEdges;
    octaederEdges = new myVertexType[24];

    int vertexCounter = 0;

    getNormal(norm, top, fl, fr);
    octaederEdges[vertexCounter++] = { top, norm };
    octaederEdges[vertexCounter++] = { fr, norm };
    octaederEdges[vertexCounter++] = { fl, norm };

    getNormal(norm, bottom, fr, fl);
    octaederEdges[vertexCounter++] = { bottom, norm };
    octaederEdges[vertexCounter++] = { fl, norm };
    octaederEdges[vertexCounter++] = { fr, norm };

    getNormal(norm, top, fr, br);
    octaederEdges[vertexCounter++] = { top, norm };
    octaederEdges[vertexCounter++] = { br, norm };
    octaederEdges[vertexCounter++] = { fr, norm };

    getNormal(norm, bottom, br, fr);
    octaederEdges[vertexCounter++] = { bottom, norm };
    octaederEdges[vertexCounter++] = { fr, norm };
    octaederEdges[vertexCounter++] = { br, norm };

    getNormal(norm, top, br, bl);
    octaederEdges[vertexCounter++] = { top, norm };
    octaederEdges[vertexCounter++] = { bl, norm };
    octaederEdges[vertexCounter++] = { br, norm };

    getNormal(norm, bottom, bl, br);
    octaederEdges[vertexCounter++] = { bottom, norm };
    octaederEdges[vertexCounter++] = { br, norm };
    octaederEdges[vertexCounter++] = { bl, norm };

    getNormal(norm, top, bl, fl);
    octaederEdges[vertexCounter++] = { top, norm };
    octaederEdges[vertexCounter++] = { fl, norm };
    octaederEdges[vertexCounter++] = { bl, norm };

    getNormal(norm, bottom, fl, bl);
    octaederEdges[vertexCounter++] = { bottom, norm };
    octaederEdges[vertexCounter++] = { bl, norm };
    octaederEdges[vertexCounter++] = { fl, norm };


    *size =24;
    return octaederEdges;
}
const int lineCount = 100;

const int sphereVerticesCount = lineCount * lineCount * 6;

const int countOfSphereEdges = lineCount * lineCount;
const int customCountOfSphereVertices = 14;


void createFile(){
    FILE* f;
    f = fopen("C:\\test.txt","w+");
    fputs("Meh :/\n", f);
    fclose(f);

}

int main(void)
{
    //TODO: debugging only
    //createFile();

    GLFWwindow* window;
    GLuint vertex_buffer, vertex_shader, fragment_shader, complete_shader_program;
    GLint  matrix_access, position_access, normal_access;

    printf("Hi This is the numbner of Vertices: %d\n", sphereVerticesCount);
    int vertices_size = -1;
    myVertexType *triangle_vertices=NULL;
    if(selectedVertices == MODEL){
        const char* monkey = "C:\\Users\\Lukas\\source\\repos\\FirstTestProject\\x64\\Debug\\plane.obj";
        triangle_vertices = loadModel(monkey, &vertices_size);
        printf("loaded MODEL with vertices_size: %d\n", vertices_size);
        float zoom = 0.001;//for plane
        //float zoom = 0.8;//for monkey
        for (int i = 0; i < vertices_size; i++)
        {
            triangle_vertices[i].x *= zoom;
            triangle_vertices[i].y *= zoom;
            triangle_vertices[i].z *= zoom;
        }
    }else if (selectedVertices == OCTAEDER){
        triangle_vertices = createOctaeder(0.5f, &vertices_size);
        printf("loaded OCTAEDER with vertices_size: %d\n", vertices_size);
    }
    int count = 0;
    int help = 0;

    if (!glfwInit())
        exit(EXIT_FAILURE);

    window = glfwCreateWindow(1280, 1024, "Happy Sphere", NULL, NULL);
    if (!window)
    {
        glfwTerminate();
        exit(EXIT_FAILURE);
    }

    glfwSetKeyCallback(window, handleKeypress);
    glfwMakeContextCurrent(window);
    gladLoadGL();

    static const char* vertex_shader_code = readTextFileIntoString("VertexShader.glsl");
    static const char* fragment_shader_code = readTextFileIntoString("FragmentShader.glsl");


    vertex_shader = glCreateShader(GL_VERTEX_SHADER);
    glShaderSource(vertex_shader, 1, &vertex_shader_code, NULL);
    glCompileShader(vertex_shader);

    char info[500];
    int num;
    glGetShaderInfoLog(vertex_shader, 500, &num, info);
    printf("%s", info);


    fragment_shader = glCreateShader(GL_FRAGMENT_SHADER);
    glShaderSource(fragment_shader, 1, &fragment_shader_code, NULL);
    glCompileShader(fragment_shader);

    glGetShaderInfoLog(fragment_shader, 500, &num, info);
    printf("%s", info);



    complete_shader_program = glCreateProgram();
    glAttachShader(complete_shader_program, vertex_shader);
    glAttachShader(complete_shader_program, fragment_shader);
    glLinkProgram(complete_shader_program);


    matrix_access = glGetUniformLocation(complete_shader_program, "matrix");
    position_access = glGetAttribLocation(complete_shader_program, "position");
    normal_access = glGetAttribLocation(complete_shader_program, "normal");


    GLint ambient;
    GLint diffuse;
    GLint specular;
    int shininess;


    ambient = glGetUniformLocation(complete_shader_program, "params.ambientFactor");
    diffuse = glGetUniformLocation(complete_shader_program, "params.diffuseFactor");
    specular = glGetUniformLocation(complete_shader_program, "params.specFactor");
    shininess = glGetUniformLocation(complete_shader_program, "params.shininess");




    glGenBuffers(1, &vertex_buffer);
    glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer);

    glBufferData(GL_ARRAY_BUFFER, vertices_size * sizeof(myVertexType), triangle_vertices, GL_STATIC_DRAW);

    glEnableVertexAttribArray(position_access);
    glVertexAttribPointer(position_access, 3, GL_FLOAT, GL_FALSE,
        sizeof(myVertexType), (void*)0);

    glEnableVertexAttribArray(normal_access);
    glVertexAttribPointer(normal_access, 3, GL_FLOAT, GL_FALSE,
        sizeof(myVertexType), (void*)(sizeof(float) * 3));

    glEnable(GL_DEPTH_TEST);
    while (!glfwWindowShouldClose(window))
    {
        float ratio;
        int width, height;
        mat4x4 m, p, matrix, colMat;

        glfwGetFramebufferSize(window, &width, &height);
        ratio = width / (float)height;

        glViewport(0, 0, width, height);
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

        mat4x4_identity(m);
        mat4x4_rotate_Y(m, m, (float)glfwGetTime());
        mat4x4_rotate_Z(m, m, (float)glfwGetTime());
        mat4x4_ortho(p, -ratio, ratio, -1.f, 1.f, 1.f, -1.f);
        mat4x4_mul(matrix, p, m);

        glUseProgram(complete_shader_program);
        glUniformMatrix4fv(matrix_access, 1, GL_FALSE, (const GLfloat*)matrix);

        // glUniform1f(ambient, ambfac);
        glUniform3fv(ambient,  1, lightParams.ambientFactor);
        glUniform3fv(diffuse,  1, lightParams.diffuseFactor);
        glUniform3fv(specular, 1, lightParams.specFactor);
        glUniform1i(shininess, lightParams.shininess);


        glDrawArrays(GL_TRIANGLES, 0, vertices_size * sizeof(myVertexType));

        glfwSwapBuffers(window);
        glfwPollEvents();
    }

    glfwDestroyWindow(window);

    glfwTerminate();
    exit(EXIT_SUCCESS);
}