LorenzAttractor/src/Renderer.c

#include "Renderer.h"

GLFWwindow* initOpenGL() {
	
	glfwInit();
	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
	glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

	GLFWwindow* window = glfwCreateWindow(800, 600, "Hello World", NULL, NULL);
	if(window == NULL) {
		printf("Failed to create a window\n");
		glfwTerminate();
		exit(-1);
	}

	glfwMakeContextCurrent(window);
	glfwSetFramebufferSizeCallback(window, WindowGotResized);

	if(!gladLoadGLLoader( (GLADloadproc) glfwGetProcAddress )) {
		printf("Failed to initialize GLAD");
		exit(-1);
	}


	// Set Global Texture Parameters
	float borderColor[] = {1.0f, 1.0f, 0.0f, 1.0f};
	glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, borderColor);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

	glEnable(GL_DEPTH_TEST);

	return window;
}

void WindowGotResized(GLFWwindow* window, int width, int height) {

	glViewport(0, 0, width, height);
}

unsigned int compileShaderProgram(const char** vertexSrc, const char** fragmentSrc) {
	unsigned int vertexShader;
	vertexShader = glCreateShader(GL_VERTEX_SHADER);
	glShaderSource(vertexShader, 1, vertexSrc, NULL);
	glCompileShader(vertexShader);

	int vertexSuccess;
	char infoLog[512];
	glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &vertexSuccess);
	if(!vertexSuccess) {
		glGetShaderInfoLog(vertexShader, 512, NULL, infoLog);		
		printf("SHADER::VERTEX::COMPILATION_FAILED\n %s \n", infoLog);
	}

	unsigned int fragmentShader;
	fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
	glShaderSource(fragmentShader, 1, fragmentSrc, NULL);
	glCompileShader(fragmentShader);

	int fragmentSuccess;
	glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &fragmentSuccess);
	if(!fragmentSuccess){
		glGetShaderInfoLog(fragmentShader, 512, NULL, infoLog);
		printf("SHADER::FRAGMENT::COMPILATION_FAILED\n %s \n", infoLog);
	}

	unsigned int shaderProgram;
	shaderProgram = glCreateProgram();
	glAttachShader(shaderProgram, vertexShader);
	glAttachShader(shaderProgram, fragmentShader);
	
	glLinkProgram(shaderProgram);

	int programSuccess;
	glGetProgramiv(shaderProgram, GL_LINK_STATUS, &programSuccess);
	if(!programSuccess) {
		glGetProgramInfoLog(shaderProgram, 512, NULL, infoLog);
		printf("SHADER::PROGRAM::LINKING_FAILED\n %s \n", infoLog);
	}
	glDeleteShader(vertexShader);
	glDeleteShader(fragmentShader);

	return shaderProgram;

}

unsigned int createShader(char* vertexPath, char* fragmentPath) {
	FILE* vertex_file = fopen(vertexPath, "r");
	FILE* fragment_file = fopen(fragmentPath, "r");
	if( vertex_file == NULL || fragment_file == NULL ) {
		printf("Failed to load shaders.\n");
		exit(1);
	}

	struct stat vertex_stat;
	struct stat fragment_stat;
	stat(vertexPath, &vertex_stat);
	stat(fragmentPath, &fragment_stat);

	int vertex_length = vertex_stat.st_size;
	int fragment_length = fragment_stat.st_size;
	
	char* vertex_src = (char*)malloc(vertex_length+1);
	char* fragment_src = (char*)malloc(fragment_length+1);
	memset(vertex_src, 0, vertex_length+1);
	memset(fragment_src, 0, fragment_length+1);

	fread(vertex_src, sizeof(char), vertex_length, vertex_file );
	fread(fragment_src, sizeof(char), fragment_length, fragment_file );
	
	vertex_src[vertex_length] = '\0';
	fragment_src[fragment_length] = '\0';
//	printf("%s", vertex_src);
//	printf("%s", fragment_src);

	const char* vertexSrc = vertex_src;
	const char* fragmentSrc = fragment_src;
	
	unsigned int shaderProgram;
	shaderProgram = compileShaderProgram(&vertexSrc, &fragmentSrc);
	free(fragment_src);
	free(vertex_src);

	return shaderProgram;
}

unsigned int createTexture(char* path){
	// Generate Texture
	unsigned int texture;
	glGenTextures(1, &texture);
	glBindTexture(GL_TEXTURE_2D, texture);

	// Set Texure Parameters
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_MIRRORED_REPEAT);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_MIRRORED_REPEAT);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

	// Load texture image
	int width, height, channels;
	unsigned char *data = stbi_load(path, &width, &height, &channels, 0);

	if (data) {
		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, data);
		glGenerateMipmap(GL_TEXTURE_2D);
	} else {
		printf("Failed to load texture %s", path);
	}
	stbi_image_free(data);

	return texture;
}

void buffercpy(int VBO, void* ptr, int size){
	glBindBuffer(GL_ARRAY_BUFFER, VBO);
	void* buffer = glMapBuffer(GL_ARRAY_BUFFER, GL_READ_WRITE);
	memcpy(buffer, ptr, size);
	glUnmapBuffer(GL_ARRAY_BUFFER);
}