path: root/main.c

#define GLFW_INCLUDE_NONE
#include <glad/glad.h>
#include <GLFW/glfw3.h>
#include <GL/gl.h>
#include <stdio.h>

// struct and function declaration
// ----------------------------------------------------------------------------
void framebuffer_size_callback(GLFWwindow* window, int width, int height);
void processInput(GLFWwindow* window);
// ----------------------------------------------------------------------------
// END

int main(void) {
    int w_width = 1280;
    int w_height = 820;
    int shader_success;
    unsigned int VBO[2], VAO[2], EBO;
    // fragment shader
    unsigned int vertex_shader;
    unsigned int fragment_shader, fragment_shader2;
    unsigned int shader_program, shader_program_2;

    char info_Log[512];
    // vertex shader source
    const char* vertex_shader_source =
	"#version 460 core\n"
	"layout (location = 0) in vec3 aPos;\n"
	"\n"
	"void main() {\n"
	    "gl_Position = vec4(aPos.x, aPos.y, aPos.z, 1.0);\n"
	"}\n\0";
    // Fragment shader
    // ---------------
    const char* fragment_shader_source =
	"#version 460 core\n"
	"out vec4 FragColor;\n"
	"\n"
	"void main() {\n"
	    "FragColor = vec4(1.0f, 0.5f, 0.2f, 1.0f);\n"
	"}\n\0";
    const char* fragment_shader_source_2 =
	"#version 460 core\n"
	"out vec4 FragColor;\n"
	"\n"
	"void main() {\n"
	    "FragColor = vec4(1.0f, 1.0f, 0.0f, 1.0f);\n"
	"}\n\0";

    // Triangle shenanigans and now two of them!
    // -----------------------------------------
    float verticies[] = {
	-0.5f, -0.5f, 0.0f, 	// bottom left
	 0.5f, -0.5f, 0.0f, 	// bottom right
	-0.5f,  0.5f, 0.0f,  	// top left
	 0.5f,  0.5f, 0.0f,  	// top right
				// second triangle
	 0.8f,  0.9f, 0.0f,  	// exercise 1 top
	 0.9f,  0.7f, 0.0f,  	// exercise 1 right
	 0.7f,  0.7f, 0.0f,  	// exercise 1 left
    };

    // exercise 2 
    float verticies2[] = {
	-1.0f, -1.0f, 0.0f,	// left
	-0.8f, -1.0f, 0.0f,	// rigth
	-0.9f, -0.8f, 0.0f	// top
    };
    unsigned int indices[] = {
	0, 1, 2,	// first triangle
	2, 3, 1		// second triangle
    };


    // GLFW settings init and which version of opengl we should use
    // and which subset of opengl profiles
    glfwInit();
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 4);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
    
    

    // glfw window creation
    GLFWwindow* window = glfwCreateWindow(w_width, w_height, "Test", NULL, NULL);
    if (window == NULL) {
	printf("Failed to create GLFW window\n");
	glfwTerminate();
	glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
	return -1;
    }
    // init window
    glfwMakeContextCurrent(window);

    // init GLAD
    if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) {
	printf("Failed to initialize GLAD\n");
	return -1;
    }

    // opengl viewport
    framebuffer_size_callback(window, w_width, w_height);


    // build and compile our shader program
    // ------------------------------------

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

    // check for compilation error
    glGetShaderiv(vertex_shader, GL_COMPILE_STATUS, &shader_success);
    if (!shader_success) {
	glGetShaderInfoLog(vertex_shader, 512, NULL, info_Log);
	printf("ERROR SHADER VERTEX COMPILATION FAILED: %s\n", info_Log);
    }

    // fragment_shader
    fragment_shader = glCreateShader(GL_FRAGMENT_SHADER);
    fragment_shader2 = glCreateShader(GL_FRAGMENT_SHADER);
    glShaderSource(fragment_shader, 1, &fragment_shader_source, NULL);
    glShaderSource(fragment_shader2, 1, &fragment_shader_source_2, NULL);
    glCompileShader(fragment_shader);
    glCompileShader(fragment_shader2);

    // check for compilation error
    glGetShaderiv(fragment_shader, GL_COMPILE_STATUS, &shader_success);
    glGetShaderiv(fragment_shader2, GL_COMPILE_STATUS, &shader_success);
    if (!shader_success) {
	glGetShaderInfoLog(fragment_shader, 512, NULL, info_Log);
	printf("ERROR SHADER FRAGMENT COMPILATION FAILED: %s\n", info_Log);
    }

    // create shader program
    // ---------------------
    shader_program = glCreateProgram();
    shader_program_2 = glCreateProgram();
    // attach to shader program id
    glAttachShader(shader_program, vertex_shader);
    glAttachShader(shader_program, fragment_shader);
    glLinkProgram(shader_program);

    glAttachShader(shader_program_2, vertex_shader);
    glAttachShader(shader_program_2, fragment_shader2);
    glLinkProgram(shader_program_2);

    // check for linking erros
    glGetProgramiv(shader_program, GL_LINK_STATUS, &shader_success);
    if (!shader_success) {
	glGetProgramInfoLog(shader_program, 512, NULL, info_Log);
	printf("ERROR WHILE LINKIN THE SHADERS TO THE PROGRAM: %s\n", info_Log);
    }

    // delete now unneeded shaders
    glDeleteShader(vertex_shader);
    glDeleteShader(fragment_shader);
    glDeleteShader(fragment_shader2);

    // set up vertex data (and buffers) and configure vertex attributes
    // ----------------------------------------------------------------
    
    glGenVertexArrays(2, VAO);
    glGenBuffers(2, VBO);
    glGenBuffers(1, &EBO);

    // bind the vertex array object first, then bind and set vertex buffers, and then configure vertex attributes.
    glBindVertexArray(VAO[0]);

    // 0. copy our vertices array in a buffer for OpenGL to use
    glBindBuffer(GL_ARRAY_BUFFER, VBO[0]);
    glBufferData(GL_ARRAY_BUFFER, sizeof(verticies), verticies, GL_STATIC_DRAW);

    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);


    // 1. then set the vertex attributes pointer
    // location of array, size of vertex attribute (vec3), type of data(float), normialition?, stride (space between data in array), offset of where the position data begins in the buffer
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
    glEnableVertexAttribArray(0);

    // exercise 2: 2 VAO VBO
    glBindVertexArray(VAO[1]);
    glBindBuffer(GL_ARRAY_BUFFER, VBO[1]);
    glBufferData(GL_ARRAY_BUFFER, sizeof(verticies2), verticies2, GL_STATIC_DRAW);
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
    glEnableVertexAttribArray(0);

    // note that this is allowed, the call to glVertexAttribPointer registered VBO as the vertex attribute's bound vertex buffer object so afterwards we can safely unbind
    glBindBuffer(GL_ARRAY_BUFFER, 0);

    glBindVertexArray(0);

    // uncomment this call to draw in wireframe polygons.
    //glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);

    // -------------------------------------------------------------------------
    // render loop
    // -------------------------------------------------------------------------
    while (!glfwWindowShouldClose(window)) {
	// input
	// -----
	processInput(window);

	// rendering commands here
	// -----------------------
	static GLclampf c = 0.0f;
	glClearColor(c, c, c, 0.0f);
	glClear(GL_COLOR_BUFFER_BIT);
	
	c += 1.0f / 256.0f;
	if (c >= 1.0f) c = 0.0f;

	// render triangle
	glUseProgram(shader_program);
	glBindVertexArray(VAO[0]);
	glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
	glDrawArrays(GL_TRIANGLES, 4, 6);
	glUseProgram(shader_program_2);
	glBindVertexArray(VAO[1]);
	glDrawArrays(GL_TRIANGLES, 0, 3);

	// check and call events and swap the buffers
	// ------------------------------------------
	glfwSwapBuffers(window);
	glfwPollEvents();
    }

    // de-allocate all resources
    glDeleteVertexArrays(2, VAO);
    glDeleteBuffers(2, VBO);
    glDeleteBuffers(1, &EBO);
    glDeleteProgram(shader_program);
    glDeleteProgram(shader_program_2);

    // Terminate program
    // -----------------
    glfwTerminate();
    return 0;
}

// END render loop
// -----------------------------------------------------------------------------

// Functions
// -----------------------------------------------------------------------------
// glfw: whenever the window size changed (by OS or user resize) this callback function executes
// ---------------------------------------------------------------------------------------------
void framebuffer_size_callback(GLFWwindow* window, int width, int height) {
    glViewport(0, 0, width, height);
}

// process all input: query GLFW whether relevant keys are pressed/released this frame and react accordingly
// ---------------------------------------------------------------------------------------------------------
void processInput(GLFWwindow* window) {
    if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS) glfwSetWindowShouldClose(window, 1);
    if (glfwGetKey(window, GLFW_KEY_Q) == GLFW_PRESS) glfwSetWindowShouldClose(window, 1);
}