125 lines
3.6 KiB
C
125 lines
3.6 KiB
C
#include <GL/glew.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
|
|
#include "log.h"
|
|
|
|
/**
|
|
* @brief Reads a file in a heap-allocated buffer.
|
|
*
|
|
* This function computes the length of the file, allocate a buffer of
|
|
* the correct size, and reads the file in the buffer. Returns `NULL`
|
|
* on error.
|
|
*
|
|
* @param filename The file to read.
|
|
* @return A buffer containing the contents of the file, or `NULL` if
|
|
* there was an error.
|
|
*/
|
|
char *read_file(const char *const filename) {
|
|
FILE *fd = fopen(filename, "r");
|
|
if (fd == NULL) {
|
|
log_error("Could not open file %s", filename);
|
|
return NULL;
|
|
}
|
|
|
|
if (fseek(fd, 0, SEEK_END) == -1) {
|
|
perror("fseek");
|
|
return NULL;
|
|
}
|
|
long size = ftell(fd);
|
|
if (size == -1) {
|
|
perror("ftell");
|
|
return NULL;
|
|
}
|
|
rewind(fd);
|
|
char *buf = calloc(size + 1, 1);
|
|
if (buf == NULL) {
|
|
log_error("Failed to allocate memory to read file %s", filename);
|
|
return NULL;
|
|
}
|
|
|
|
long bytes_read = fread(buf, 1, size, fd);
|
|
if (bytes_read != size) {
|
|
log_error("Failed to read file %s (%ld bytes read out of %ld total)",
|
|
filename, bytes_read, size);
|
|
return NULL;
|
|
}
|
|
|
|
fclose(fd);
|
|
return buf;
|
|
}
|
|
|
|
/**
|
|
* @brief Compile shaders from source files.
|
|
*
|
|
* This function reads the source files of the vertex and fragment
|
|
* shaders, compiles them, and links them together in a shader
|
|
* program.
|
|
*
|
|
* @param shader_program Pointer to the ID of the shader program
|
|
* where the shaders will be stored.
|
|
* @param fragment_shader_file File name of the fragment shader.
|
|
* @return 0 on success, 1 on error.
|
|
*/
|
|
int compile_shaders(unsigned int *shader_program,
|
|
const char *const fragment_shader_file) {
|
|
/* Compile vertex shader */
|
|
const char *const vertex_shader_source =
|
|
"#version 330 core\n"
|
|
"layout (location = 0) in vec3 aPos;\n"
|
|
"void main()\n"
|
|
"{\n"
|
|
" gl_Position = vec4(aPos, 1.0);\n"
|
|
"}\n";
|
|
|
|
unsigned int vertex_shader = glCreateShader(GL_VERTEX_SHADER);
|
|
glShaderSource(vertex_shader, 1, &vertex_shader_source, NULL);
|
|
glCompileShader(vertex_shader);
|
|
int success = 0;
|
|
char info_log[512];
|
|
glGetShaderiv(vertex_shader, GL_COMPILE_STATUS, &success);
|
|
if (!success) {
|
|
glGetShaderInfoLog(vertex_shader, 512, NULL, info_log);
|
|
log_error("Vertex shader compilation failed: %s", info_log);
|
|
}
|
|
|
|
/* Compile fragment shader */
|
|
const char *const fragment_shader_source = read_file(fragment_shader_file);
|
|
if (fragment_shader_source == NULL) {
|
|
log_error("Could not load fragment shader from file %s",
|
|
fragment_shader_file);
|
|
return 1;
|
|
}
|
|
unsigned int fragment_shader = glCreateShader(GL_FRAGMENT_SHADER);
|
|
glShaderSource(fragment_shader, 1, &fragment_shader_source, NULL);
|
|
glCompileShader(fragment_shader);
|
|
glGetShaderiv(fragment_shader, GL_COMPILE_STATUS, &success);
|
|
if (!success) {
|
|
glGetShaderInfoLog(fragment_shader, 512, NULL, info_log);
|
|
log_error("Fragment shader compilation failed: %s", info_log);
|
|
return 1;
|
|
}
|
|
|
|
/* Link shaders */
|
|
unsigned int new_shader_program = glCreateProgram();
|
|
glAttachShader(new_shader_program, vertex_shader);
|
|
glAttachShader(new_shader_program, fragment_shader);
|
|
glLinkProgram(new_shader_program);
|
|
glGetShaderiv(new_shader_program, GL_LINK_STATUS, &success);
|
|
if (!success) {
|
|
glGetShaderInfoLog(new_shader_program, 512, NULL, info_log);
|
|
log_error("Shader program linking failed: %s", info_log);
|
|
return 1;
|
|
}
|
|
|
|
glDeleteProgram(*shader_program);
|
|
*shader_program = new_shader_program;
|
|
|
|
free((void *)fragment_shader_source);
|
|
glDeleteShader(vertex_shader);
|
|
glDeleteShader(fragment_shader);
|
|
|
|
log_debug("Shaders compiled successfully");
|
|
|
|
return 0;
|
|
}
|