mybox/mybox.cpp

#include <glad/glad.h>
#include <GLFW/glfw3.h>
#include <iostream>
#include <cassert>
#include <string.h>

#include "src/standard_ints.h"
#include "src/lgl_callbacks.h"
#include "src/lgl_shader_tools.h"

#define SHADER_CNT 3

char *shader_list[SHADER_CNT] = {
	"vertex.vert",
	"fragment.frag",
	"fragment2.frag"
};

struct shader_storage {
	u32 type;
	bool compiled;
	bool freed;
	u32 h;
};

struct shader_storage shader_set[SHADER_CNT] = {
	{GL_VERTEX_SHADER},
	{GL_FRAGMENT_SHADER},
	{GL_FRAGMENT_SHADER}
};

void helper_capabilitiesCheck() {
	i32 numAttrs;
	glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &numAttrs);
	std::cout << "Maximum number of vertex attributes for this hardware: " 
		<< numAttrs << std::endl;
}

int main(void) {
	std::cout << "Hello Shaders." << std::endl;

	glfwInit();

	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2);
	glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

	GLFWwindow *window = glfwCreateWindow(960, 400,
		"Hello Shader", NULL, NULL);
	glfwSetWindowPos(window, 140, 1000);

	if (window == NULL) {
		std::cout << "Failed to create GLFW window." << std::endl;
		glfwTerminate();
		return -1;
	}

	glfwMakeContextCurrent(window);
	glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);

	if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) {
		std::cout << "Failed to initalize GLAD." << std::endl;
		glfwTerminate();
		return -1;
	}

	helper_capabilitiesCheck();

	/* ====================================================================== */
	/* ====================================================================== */
	/* ====================================================================== */
	i32 success;
	char debug_msg[512];
	GLchar *shdr_source;

	for (u32 i = 0; i < SHADER_CNT; i++) {
		shader_set[i].h = glCreateShader(shader_set[i].type);
		readshader(shader_list[i], &shdr_source);
		glShaderSource(shader_set[i].h, 1, &shdr_source, NULL);
		glCompileShader(shader_set[i].h);
		glGetShaderiv(shader_set[i].h, GL_COMPILE_STATUS, &success);
		freeshader(shdr_source);
		if (!success) {
			glGetShaderInfoLog(shader_set[i].h, 512, NULL, debug_msg);
			std::cerr << "ERROR SHADER::Compilation Failed for shader: \n\t" <<
				shader_list[i] << std::endl;
			return -1;
		} else {
			shader_set[i].compiled = true;
		}
	}

	// Next, generate the shader programs
	u32 shaderProgram[2];
	for (u32 i = 0; i < 2; i++) {
		shaderProgram[i] = glCreateProgram();
		glAttachShader(shaderProgram[i], shader_set[0].h);
	}
	glAttachShader(shaderProgram[0], shader_set[1].h);
	glAttachShader(shaderProgram[1], shader_set[2].h);
	for (u32 i = 0; i < 2; i++) {
		glLinkProgram(shaderProgram[i]);
		glGetProgramiv(shaderProgram[i], GL_LINK_STATUS, &success);
		if (!success) {
			glGetProgramInfoLog(shaderProgram[i], 512, NULL, debug_msg);
			std::cout << "ERROR SHADER::Linking Failed\n" << 
				debug_msg << std::endl;
			return -1;
		}
	}

	for (u32 i = 0; i < SHADER_CNT; i++) {
		if (shader_set[i].compiled && !shader_set[i].freed) {
			glDeleteShader(shader_set[i].h);
			shader_set[i].freed = true;
		}
	}

	/* ====================================================================== */
	/* ====================================================================== */
	/* ====================================================================== */
	// Define the vertex shader dat.
	f32 vertices_1[] = {
		-0.9f, -0.66f, 0.0f,
		-0.1f, -0.66f, 0.0f,
		-0.50f, +0.66f, 0.0f
	};
	f32 vertices_2[sizeof(vertices_1)/sizeof(f32)];
	memcpy(vertices_2, vertices_1, sizeof(vertices_1));
	for (u32 i = 0; i < sizeof(vertices_1)/sizeof(f32); i+=3) {
		vertices_2[i] *= -1;
	}

	f32 *vert_ptr[2];
	vert_ptr[0] = vertices_1;
	vert_ptr[1] = vertices_2;

	u32 indicies[] {
		0, 1, 2,	// t1
	};

	u32 VAOs[2];
	glGenVertexArrays(2, VAOs);
	u32 VBOs[2];
	glGenBuffers(2, VBOs);
	u32 EBO;
	glGenBuffers(1, &EBO);

	for (u32 i = 0; i < 2; i++) {
		glBindVertexArray(VAOs[i]);
		glBindBuffer(GL_ARRAY_BUFFER, VBOs[i]);
		glBufferData(GL_ARRAY_BUFFER, sizeof(vertices_1), vert_ptr[i], GL_STATIC_DRAW);
		glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3*sizeof(f32), (void *)0);
		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
		glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indicies), indicies, GL_STATIC_DRAW);

		glEnableVertexAttribArray(0);
	}

	glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);

	while(!glfwWindowShouldClose(window)) {
		processInput(window);

		glClearColor(0.0f, 0.1f, 0.3f, 1.0f);
		glClear(GL_COLOR_BUFFER_BIT);
		
		for (u32 i = 0; i < 2; i++) {
			glUseProgram(shaderProgram[i]);
			glBindVertexArray(VAOs[i]);
			glDrawArrays(GL_TRIANGLES, 0, 3);
		}

		glfwSwapBuffers(window);
		glfwPollEvents();
	}

	glDeleteVertexArrays(2, VAOs);
	glDeleteBuffers(2, VBOs);
	glDeleteTextures(1, &EBO);
	for (u32 i = 0; i < 2; i++) {
		glDeleteProgram(shaderProgram[i]);
	}

	i32 xpos, ypos;
	glfwGetWindowPos(window, &xpos, &ypos);
	std::cout << "Closed window at pos`ition\n  (X,Y) = "
		<< xpos << ", " << ypos << "\n" << std::endl;

	glfwTerminate();
	return 0;

}