functions.c

#include <math.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#define GLEW STATIC
#include <GL/glew.h>
#include <GLFW/glfw3.h>

#include "functions.h"

void key_callback(GLFWwindow* window, int key, int scancode, int action, int mode)
{
    if (key == GLFW_KEY_ESCAPE && action == GLFW_PRESS)
        glfwSetWindowShouldClose(window, GL_TRUE);
}

void textFileRead(const char *filename, char **interstring) {
    FILE *fp;
    char *textFile;
    int textFileSize;
    // Open file
    fp = fopen(filename, "r");
    // Find out file length
    fseek(fp, 0L, SEEK_END);
    textFileSize = ftell(fp);
    fseek(fp, 0L, SEEK_SET);
    // Allocate necessary space
    textFile = malloc(textFileSize+10);
    *interstring = malloc(textFileSize+10);
    // Read file into string and put '\0' to end
    fread(textFile, textFileSize, 1, fp);
    textFile[textFileSize+1] = '\0';
    // Copy to external array
    strcpy(*interstring, textFile);
    fclose(fp);
}

int aaaInit(GLFWwindow **window, GLuint winWidth, GLuint winHeight, const GLchar **winName) {
    glfwInit();
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
    glfwWindowHint(GLFW_RESIZABLE, GL_FALSE);
    glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); //For MacOS

    // Create window
    *window = glfwCreateWindow(winWidth, winHeight, *winName, 0, 0);
    if (*window == 0)   // catching error
    {
        printf("%s", "Failed to Create GLFW window\n");
        glfwTerminate();
        return -1;
    }
    glfwMakeContextCurrent(*window);

    // Enable GLEW experimental
    glewExperimental = GL_TRUE;
    if (glewInit() != GLEW_OK)
    {
        printf("%s", "Failed to initialize GLEW");
        return -1;
    }

    // Define rht viewport dimensions
    int width, height;
    glfwGetFramebufferSize(*window, &width, &height);

    // Settng viewport
    glViewport(0, 0, width, height);

    return 0;
}

int aaaShaderCompile(const GLchar **vertexShaderSource, const GLchar **fragmentShaderSource, GLuint *shaderProgramInter) {

    // Build and compile shader program
    // Vertex shader
    GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER);
    glShaderSource(vertexShader, 1, vertexShaderSource, 0);
    glCompileShader(vertexShader);

    // Check for compile time errors
    GLint success;
    GLchar infoLog[512];
    glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &success);
    if (!success)
    {
        glGetShaderInfoLog(vertexShader, 512, 0, infoLog);
        printf("ERROR::SHADER::VERTEX::COMPILATION_FAILED\n %s", infoLog);
    }

    // Fragment shader
    GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
    glShaderSource(fragmentShader, 1, fragmentShaderSource, 0);
    glCompileShader(fragmentShader);

    // Check for linking errors
    glGetProgramiv(fragmentShader, GL_COMPILE_STATUS, &success);
    if (!success) {
        glGetProgramInfoLog(fragmentShader, 512, 0, infoLog);
        printf("ERROR::SHADER::FRAGMENT::COMPILATION_FAILED\n %s", infoLog);
    }

    // Link shaders
    *shaderProgramInter = glCreateProgram();
    glAttachShader(*shaderProgramInter, vertexShader);
    glAttachShader(*shaderProgramInter, fragmentShader);
    glLinkProgram(*shaderProgramInter);

    // Check for linking errors
    glGetProgramiv(*shaderProgramInter, GL_LINK_STATUS, &success);
    if (!success) {
        glGetProgramInfoLog(*shaderProgramInter, 512, 0, infoLog);
        printf("ERROR::SHADER::FRAGMENT::LINKING_FAILED\n %s", infoLog);
    }
    glDeleteShader(vertexShader);
    glDeleteShader(fragmentShader);

    return 0;
}